Split (1)

train · 481k rows

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.

bugged stringlengths 4 228k	fixed stringlengths 0 96.3M	__index_level_0__ int64 0 481k
def action(self, discriminator, callable=None, args=(), kw=None, order=0): """ Register an action which will be executed when :meth:`pyramid.config.Configuration.commit` is called (or executed immediately if ``autocommit`` is ``True``).	def action(self, discriminator, callable=None, args=(), kw=None, order=0): """ Register an action which will be executed when :meth:`pyramid.config.Configuration.commit` is called (or executed immediately if ``autocommit`` is ``True``).	476,900
def commit(self): """ Commit any pending configuration actions added. If a configuration conflict has occurred, this method will raise a :exc:`ConfigurationConflictError`; within the traceback of this error will be information about the source of the conflict, usually including file names and line numbers of the cause of the configuration conflicts.""" if self._ctx is None: return self._ctx.execute_actions() # unwrap and reset the context self._ctx = None	def commit(self): """ Commit any pending configuration actions. If a configuration conflict is detected in the pending configuration actins, this method will raise a :exc:`ConfigurationConflictError`; within the traceback of this error will be information about the source of the conflict, usually including file names and line numbers of the cause of the configuration conflicts.""" if self._ctx is None: return self._ctx.execute_actions() # unwrap and reset the context self._ctx = None	476,901
def main(global_config, **settings): config = Configurator() config.include('myapp.myconfig.configure')	def main(global_config, **settings): config = Configurator() config.include('myapp.myconfig.configure')	476,902
def main(global_config, **settings): config = Configurator() config.include('myapp.myconfig.configure')	def main(global_config, **settings): config = Configurator() config.include('myapp.myconfig.configure')	476,903
def main(global_config, **settings): config = Configurator() config.include('myapp.myconfig.configure')	def main(global_config, **settings): config = Configurator() config.include('myapp.myconfig.configure')	476,904
def main(global_config, **settings): config = Configurator() config.include('myapp.myconfig.configure')	def main(global_config, **settings): config = Configurator() config.include('myapp.myconfig.configure')	476,905
def test_spec_notyetregistered(self): import os from pyramid import tests module_name = tests.__name__ relpath = 'test_renderers.py' renderer = {} factory = DummyFactory(renderer) spec = '%s:%s' % (module_name, relpath) info = DummyRendererInfo({ 'name':spec, 'package':None, 'registry':self.config.registry, 'settings':{}, 'type':'type', }) result = self._callFUT(info, factory) self.failUnless(result is renderer) path = os.path.abspath(__file__) if path.endswith('pyc'): # pragma: no cover path = path[:-1] self.assertEqual(factory.path, path) self.assertEqual(factory.kw, {})	def test_spec_notyetregistered(self): import os from pyramid import tests module_name = tests.__name__ relpath = 'test_renderers.py' renderer = {} factory = DummyFactory(renderer) spec = '%s:%s' % (module_name, relpath) info = DummyRendererInfo({ 'name':spec, 'package':None, 'registry':self.config.registry, 'settings':{}, 'type':'type', }) result = self._callFUT(info, factory) self.failUnless(result is renderer) path = os.path.abspath(__file__) if path.endswith('pyc'): # pragma: no cover path = path[:-1] self.assertEqual(factory.path, path) self.assertEqual(factory.kw, {})	476,906
def get_app(config_file, name, loadapp=loadapp): """ Return the WSGI application named ``name`` in the PasteDeploy config file ``config_file``""" config_name = 'config:%s' % config_file here_dir = os.getcwd() app = loadapp(config_name, name=name, relative_to=here_dir) return app	def get_app(config_file, name, loadapp=loadapp): """ Return the WSGI application named ``name`` in the PasteDeploy config file ``config_file``""" config_name = 'config:%s' % config_file here_dir = os.getcwd() app = loadapp(config_name, name=name, relative_to=here_dir) return app	476,907
def route_path(route_name, request, elements, kw): """Generates a path (aka a 'relative URL', a URL minus the host, scheme, and port) for a named :app:`Pyramid` :term:`route configuration`. .. note:: Calling :meth:`pyramid.Request.route_path` can be used to achieve the same result as :func:`pyramid.url.route_path`. This function accepts the same argument as :func:`pyramid.url.route_url` and performs the same duty. It just omits the host, port, and scheme information in the return value; only the path, query parameters, and anchor data are present in the returned string. For example, if you've defined a route named 'foobar' with the path ``/:foo/:bar``, this call to ``route_path``:: route_path('foobar', request, foo='1', bar='2') Will return the string ``/1/2``. .. note:: Calling ``route_path('route', request)`` is the same as calling ``route_url('route', request, _app_url='')``. ``route_path`` is, in fact, implemented in terms of ``route_url`` in just this way. As a result, passing ``_app_url`` within the ``kw`` values passed to ``route_path`` will result in an exception. """ return route_url(route_name, request, elements, _app_url='', **kw)	def route_path(route_name, request, elements, kw): """Generates a path (aka a 'relative URL', a URL minus the host, scheme, and port) for a named :app:`Pyramid` :term:`route configuration`. .. note:: Calling :meth:`pyramid.Request.route_path` can be used to achieve the same result as :func:`pyramid.url.route_path`. This function accepts the same argument as :func:`pyramid.url.route_url` and performs the same duty. It just omits the host, port, and scheme information in the return value; only the path, query parameters, and anchor data are present in the returned string. For example, if you've defined a route named 'foobar' with the path ``/:foo/:bar``, this call to ``route_path``:: route_path('foobar', request, foo='1', bar='2') Will return the string ``/1/2``. .. note:: Calling ``route_path('route', request)`` is the same as calling ``route_url('route', request, _app_url='')``. ``route_path`` is, in fact, implemented in terms of ``route_url`` in just this way. As a result, any ``_app_url`` pass within the ``kw`` values to ``route_path`` will be ignored. """ kw['_app_url'] = '' return route_url(route_name, request, elements, **kw)	476,908
def register(): config = Configurator(reg, package=_context.package) config.add_view( permission=permission, context=context, view=view, name=name, request_type=request_type, route_name=route_name, request_method=request_method, request_param=request_param, containment=containment, attr=attr, renderer=renderer, wrapper=wrapper, xhr=xhr, accept=accept, header=header, path_info=path_info, match_val=match_val, custom_predicates=custom_predicates, _info=_context.info)	def register(): config = Configurator(reg, package=_context.package) config.add_view( permission=permission, context=context, view=view, name=name, request_type=request_type, route_name=route_name, request_method=request_method, request_param=request_param, containment=containment, attr=attr, renderer=renderer, wrapper=wrapper, xhr=xhr, accept=accept, header=header, path_info=path_info, match_val=match_val, custom_predicates=custom_predicates, _info=_context.info)	476,909
def test_setup_registry_locale_negotiator(self): from repoze.bfg.registry import Registry from repoze.bfg.interfaces import ILocaleNegotiator reg = Registry() config = self._makeOne(reg) config.setup_registry(locale_negotiator='abc') utility = reg.getUtility(ILocaleNegotiator) self.assertEqual(utility, 'abc')	def test_setup_registry_locale_negotiator(self): from repoze.bfg.registry import Registry from repoze.bfg.interfaces import ILocaleNegotiator reg = Registry() config = self._makeOne(reg) negotiator = object() config.setup_registry(locale_negotiator=negotiator) utility = reg.getUtility(ILocaleNegotiator) self.assertEqual(utility, 'abc')	476,910
def test_setup_registry_locale_negotiator(self): from repoze.bfg.registry import Registry from repoze.bfg.interfaces import ILocaleNegotiator reg = Registry() config = self._makeOne(reg) config.setup_registry(locale_negotiator='abc') utility = reg.getUtility(ILocaleNegotiator) self.assertEqual(utility, 'abc')	def test_setup_registry_locale_negotiator(self): from repoze.bfg.registry import Registry from repoze.bfg.interfaces import ILocaleNegotiator reg = Registry() config = self._makeOne(reg) config.setup_registry(locale_negotiator='abc') utility = reg.getUtility(ILocaleNegotiator) self.assertEqual(utility, 'abc')	476,911
def test_setup_registry_request_factory(self): from repoze.bfg.registry import Registry from repoze.bfg.interfaces import IRequestFactory reg = Registry() config = self._makeOne(reg) config.setup_registry(request_factory='abc') utility = reg.getUtility(IRequestFactory) self.assertEqual(utility, 'abc')	def test_setup_registry_request_factory(self): from repoze.bfg.registry import Registry from repoze.bfg.interfaces import IRequestFactory reg = Registry() config = self._makeOne(reg) factory = object() config.setup_registry(request_factory=factory) utility = reg.getUtility(IRequestFactory) self.assertEqual(utility, 'abc')	476,912
def test_setup_registry_request_factory(self): from repoze.bfg.registry import Registry from repoze.bfg.interfaces import IRequestFactory reg = Registry() config = self._makeOne(reg) config.setup_registry(request_factory='abc') utility = reg.getUtility(IRequestFactory) self.assertEqual(utility, 'abc')	def test_setup_registry_request_factory(self): from repoze.bfg.registry import Registry from repoze.bfg.interfaces import IRequestFactory reg = Registry() config = self._makeOne(reg) config.setup_registry(request_factory='abc') utility = reg.getUtility(IRequestFactory) self.assertEqual(utility, 'abc')	476,913
def test_setup_registry_renderer_globals_factory(self): from repoze.bfg.registry import Registry from repoze.bfg.interfaces import IRendererGlobalsFactory reg = Registry() config = self._makeOne(reg) config.setup_registry(renderer_globals_factory='abc') utility = reg.getUtility(IRendererGlobalsFactory) self.assertEqual(utility, 'abc')	def test_setup_registry_renderer_globals_factory(self): from repoze.bfg.registry import Registry from repoze.bfg.interfaces import IRendererGlobalsFactory reg = Registry() config = self._makeOne(reg) factory = object() config.setup_registry(renderer_globals_factory=factory) utility = reg.getUtility(IRendererGlobalsFactory) self.assertEqual(utility, 'abc')	476,914
def test_setup_registry_renderer_globals_factory(self): from repoze.bfg.registry import Registry from repoze.bfg.interfaces import IRendererGlobalsFactory reg = Registry() config = self._makeOne(reg) config.setup_registry(renderer_globals_factory='abc') utility = reg.getUtility(IRendererGlobalsFactory) self.assertEqual(utility, 'abc')	def test_setup_registry_renderer_globals_factory(self): from repoze.bfg.registry import Registry from repoze.bfg.interfaces import IRendererGlobalsFactory reg = Registry() config = self._makeOne(reg) config.setup_registry(renderer_globals_factory='abc') utility = reg.getUtility(IRendererGlobalsFactory) self.assertEqual(utility, 'abc')	476,915
def test_set_request_factory(self): from repoze.bfg.interfaces import IRequestFactory config = self._makeOne() config.set_request_factory('abc') self.assertEqual(config.registry.getUtility(IRequestFactory), 'abc')	def test_set_request_factory(self): from repoze.bfg.interfaces import IRequestFactory config = self._makeOne() config.set_request_factory('abc') self.assertEqual(config.registry.getUtility(IRequestFactory), 'abc')	476,916
def forget(self, request): return []	def forget(self, request): return []	476,917
def renderer_factory(info): path = info.name registry = info.registry settings = info.settings lookup = registry.queryUtility(IMakoLookup) if lookup is None: reload_templates = settings.get('reload_templates', False) directories = settings.get('mako.directories') module_directory = settings.get('mako.module_directory') input_encoding = settings.get('mako.input_encoding', 'utf-8') error_handler = settings.get('mako.error_handler', None) default_filters = settings.get('mako.default_filters', []) imports = settings.get('mako.imports', []) if directories is None: raise ConfigurationError( 'Mako template used without a ``mako.directories`` setting') directories = directories.splitlines() directories = [ abspath_from_resource_spec(d) for d in directories ] lookup = PkgResourceTemplateLookup(directories=directories, module_directory=module_directory, input_encoding=input_encoding, error_handler=error_handler, default_filters=default_filters, imports=imports, filesystem_checks=reload_templates) registry_lock.acquire() try: registry.registerUtility(lookup, IMakoLookup) finally: registry_lock.release() return MakoLookupTemplateRenderer(path, lookup)	def renderer_factory(info): path = info.name registry = info.registry settings = info.settings lookup = registry.queryUtility(IMakoLookup) if lookup is None: reload_templates = settings.get('reload_templates', False) directories = settings.get('mako.directories') module_directory = settings.get('mako.module_directory') input_encoding = settings.get('mako.input_encoding', 'utf-8') error_handler = settings.get('mako.error_handler', None) default_filters = settings.get('mako.default_filters', None) imports = settings.get('mako.imports', []) if directories is None: raise ConfigurationError( 'Mako template used without a ``mako.directories`` setting') directories = directories.splitlines() directories = [ abspath_from_resource_spec(d) for d in directories ] lookup = PkgResourceTemplateLookup(directories=directories, module_directory=module_directory, input_encoding=input_encoding, error_handler=error_handler, default_filters=default_filters, imports=imports, filesystem_checks=reload_templates) registry_lock.acquire() try: registry.registerUtility(lookup, IMakoLookup) finally: registry_lock.release() return MakoLookupTemplateRenderer(path, lookup)	476,918
def template_renderer_factory(spec, impl): reg = get_current_registry() if os.path.isabs(spec): # 'spec' is an absolute filename if not os.path.exists(spec): raise ValueError('Missing template file: %s' % spec) renderer = reg.queryUtility(ITemplateRenderer, name=spec) if renderer is None: renderer = impl(spec) reg.registerUtility(renderer, ITemplateRenderer, name=spec) else: # spec is a package:relpath resource spec renderer = reg.queryUtility(ITemplateRenderer, name=spec) if renderer is None: try: package_name, filename = spec.split(':', 1) except ValueError: # pragma: no cover # somehow we were passed a relative pathname; this # should die package_name = caller_package(4).__name__ filename = spec abspath = pkg_resources.resource_filename(package_name, filename) if not pkg_resources.resource_exists(package_name, filename): raise ValueError( 'Missing template resource: %s (%s)' % (spec, abspath)) renderer = impl(abspath) if not _reload_resources(): # cache the template reg.registerUtility(renderer, ITemplateRenderer, name=spec) return renderer	registry_lock = threading.Lock() def template_renderer_factory(spec, impl, lock=registry_lock): reg = get_current_registry() if os.path.isabs(spec): # 'spec' is an absolute filename if not os.path.exists(spec): raise ValueError('Missing template file: %s' % spec) renderer = reg.queryUtility(ITemplateRenderer, name=spec) if renderer is None: renderer = impl(spec) reg.registerUtility(renderer, ITemplateRenderer, name=spec) else: # spec is a package:relpath resource spec renderer = reg.queryUtility(ITemplateRenderer, name=spec) if renderer is None: try: package_name, filename = spec.split(':', 1) except ValueError: # pragma: no cover # somehow we were passed a relative pathname; this # should die package_name = caller_package(4).__name__ filename = spec abspath = pkg_resources.resource_filename(package_name, filename) if not pkg_resources.resource_exists(package_name, filename): raise ValueError( 'Missing template resource: %s (%s)' % (spec, abspath)) renderer = impl(abspath) if not _reload_resources(): # cache the template reg.registerUtility(renderer, ITemplateRenderer, name=spec) return renderer	476,919
def template_renderer_factory(spec, impl): reg = get_current_registry() if os.path.isabs(spec): # 'spec' is an absolute filename if not os.path.exists(spec): raise ValueError('Missing template file: %s' % spec) renderer = reg.queryUtility(ITemplateRenderer, name=spec) if renderer is None: renderer = impl(spec) reg.registerUtility(renderer, ITemplateRenderer, name=spec) else: # spec is a package:relpath resource spec renderer = reg.queryUtility(ITemplateRenderer, name=spec) if renderer is None: try: package_name, filename = spec.split(':', 1) except ValueError: # pragma: no cover # somehow we were passed a relative pathname; this # should die package_name = caller_package(4).__name__ filename = spec abspath = pkg_resources.resource_filename(package_name, filename) if not pkg_resources.resource_exists(package_name, filename): raise ValueError( 'Missing template resource: %s (%s)' % (spec, abspath)) renderer = impl(abspath) if not _reload_resources(): # cache the template reg.registerUtility(renderer, ITemplateRenderer, name=spec) return renderer	def template_renderer_factory(spec, impl): reg = get_current_registry() if os.path.isabs(spec): # 'spec' is an absolute filename if not os.path.exists(spec): raise ValueError('Missing template file: %s' % spec) renderer = reg.queryUtility(ITemplateRenderer, name=spec) if renderer is None: renderer = impl(spec) try: lock.acquire() reg.registerUtility(renderer, ITemplateRenderer, name=spec) finally: lock.release() else: # spec is a package:relpath resource spec renderer = reg.queryUtility(ITemplateRenderer, name=spec) if renderer is None: try: package_name, filename = spec.split(':', 1) except ValueError: # pragma: no cover # somehow we were passed a relative pathname; this # should die package_name = caller_package(4).__name__ filename = spec abspath = pkg_resources.resource_filename(package_name, filename) if not pkg_resources.resource_exists(package_name, filename): raise ValueError( 'Missing template resource: %s (%s)' % (spec, abspath)) renderer = impl(abspath) if not _reload_resources(): # cache the template try: lock.acquire() reg.registerUtility(renderer, ITemplateRenderer, name=spec) finally: lock.release() return renderer	476,920
def template_renderer_factory(spec, impl): reg = get_current_registry() if os.path.isabs(spec): # 'spec' is an absolute filename if not os.path.exists(spec): raise ValueError('Missing template file: %s' % spec) renderer = reg.queryUtility(ITemplateRenderer, name=spec) if renderer is None: renderer = impl(spec) reg.registerUtility(renderer, ITemplateRenderer, name=spec) else: # spec is a package:relpath resource spec renderer = reg.queryUtility(ITemplateRenderer, name=spec) if renderer is None: try: package_name, filename = spec.split(':', 1) except ValueError: # pragma: no cover # somehow we were passed a relative pathname; this # should die package_name = caller_package(4).__name__ filename = spec abspath = pkg_resources.resource_filename(package_name, filename) if not pkg_resources.resource_exists(package_name, filename): raise ValueError( 'Missing template resource: %s (%s)' % (spec, abspath)) renderer = impl(abspath) if not _reload_resources(): # cache the template reg.registerUtility(renderer, ITemplateRenderer, name=spec) return renderer	def template_renderer_factory(spec, impl): reg = get_current_registry() if os.path.isabs(spec): # 'spec' is an absolute filename if not os.path.exists(spec): raise ValueError('Missing template file: %s' % spec) renderer = reg.queryUtility(ITemplateRenderer, name=spec) if renderer is None: renderer = impl(spec) try: lock.acquire() reg.registerUtility(renderer, ITemplateRenderer, name=spec) finally: lock.release() else: # spec is a package:relpath resource spec renderer = reg.queryUtility(ITemplateRenderer, name=spec) if renderer is None: try: package_name, filename = spec.split(':', 1) except ValueError: # pragma: no cover # somehow we were passed a relative pathname; this # should die package_name = caller_package(4).__name__ filename = spec abspath = pkg_resources.resource_filename(package_name, filename) if not pkg_resources.resource_exists(package_name, filename): raise ValueError( 'Missing template resource: %s (%s)' % (spec, abspath)) renderer = impl(abspath) if not _reload_resources(): # cache the template try: lock.acquire() reg.registerUtility(renderer, ITemplateRenderer, name=spec) finally: lock.release() return renderer	476,921
def __call__(self, request): environ = request.environ try: # empty if mounted under a path in mod_wsgi, for example path = environ['PATH_INFO'] or '/' except KeyError: path = '/'	def __call__(self, request): environ = request.environ try: # empty if mounted under a path in mod_wsgi, for example path = environ['PATH_INFO'] or '/' except KeyError: path = '/'	476,922
def test_directories_list(self): from pyramid.mako_templating import IMakoLookup settings = {'mako.directories':['a', 'b']} info = DummyRendererInfo({ 'name':'helloworld.mak', 'package':None, 'registry':self.config.registry, 'settings':settings, }) self._callFUT(info) lookup = self.config.registry.getUtility(IMakoLookup) self.assertEqual(lookup.directories, ['a', 'b'])	def test_directories_list(self): from pyramid.mako_templating import IMakoLookup settings = {'mako.directories':['a', 'b']} info = DummyRendererInfo({ 'name':'helloworld.mak', 'package':None, 'registry':self.config.registry, 'settings':settings, }) self._callFUT(info) lookup = self.config.registry.getUtility(IMakoLookup) self.assertEqual(lookup.directories, ['a', 'b'])	476,923
def caller_package(level=2, caller_module=caller_module): # caller_module in arglist for tests module = caller_module(level+1) if '__init__.py' in getattr(module, '__file__', ''): # empty at >>> # Module is a package return module # Go up one level to get package package_name = module.__name__.rsplit('.', 1)[0] return sys.modules[package_name]	def caller_package(level=2, caller_module=caller_module): # caller_module in arglist for tests module = caller_module(level+1) f = getattr(module, '__file__', '') if (('__init__.py' in f) or ('__init__$py' in f)): # empty at >>> # Module is a package return module # Go up one level to get package package_name = module.__name__.rsplit('.', 1)[0] return sys.modules[package_name]	476,924
def pre(self, command, output_dir, vars): # pragma: no cover vars['random_string'] = os.urandom(20).encode('hex') return Template.pre(self, command, output_dir, vars)	def pre(self, command, output_dir, vars): # pragma: no cover vars['random_string'] = os.urandom(20).encode('hex') return Template.pre(self, command, output_dir, vars)	476,925
def restore_point(): config = cmds.init.config() user = config["db_user"] password = config["db_pass"] db = config["db_db"] return mysqldump_command ("-u%s %s%s --add-drop-table --default-character-set=utf8 %s" % (user, "-p" if password else "", password, db))	def restore_point(): config = cmds.init.config() user = config["db_user"] password = config["db_pass"] db = config["db_db"] host = config["db_host"] return mysqldump_command ("-u%s %s%s %s --add-drop-table --default-character-set=utf8 %s" % (user, "-p" if password else "", password, "-h"+host if host <> 'localhost' else "", db))	476,926
def dump(): config = cmds.init.config() user = config["db_user"] password = config["db_pass"] db = config["db_db"] return mysqldump_command ("--no-data --compact -u%s %s%s --default-character-set=utf8 %s" % (user, "-p" if password else "", password, db))	def dump(): config = cmds.init.config() user = config["db_user"] password = config["db_pass"] db = config["db_db"] host = config["db_host"] return mysqldump_command ("--no-data --add-lock=false --compact -u%s %s%s %s --default-character-set=utf8 %s" % (user, "-p" if password else "", password, "-h"+host if host <> 'localhost' else "", db))	476,927
def load (sql): config = cmds.init.config() user = config["db_user"] password = config["db_pass"] db = config["db_db"] tempfile = ".temp-mygrate-%s" % str(datetime.time()).replace (':', '_') f = open (tempfile, 'w') f.write (sql) f.close() (output, errors) = mysql_command ("-u%s %s%s --default-character-set=utf8 %s < %s" % (user, "-p" if password else "", password, db, tempfile)) os.unlink(tempfile) if errors: raise SQLLoadError (sql = sql, errors = errors) return True	def load (sql): config = cmds.init.config() user = config["db_user"] password = config["db_pass"] db = config["db_db"] tempfile = ".temp-mygrate-%s" % str(datetime.time()).replace (':', '_') f = open (tempfile, 'w') f.write (sql) f.close() (output, errors) = mysql_command ("-u%s %s%s %s --default-character-set=utf8 %s < %s" % (user, "-p" if password else "", password, "-h"+host if host <> 'localhost' else "", db, tempfile)) os.unlink(tempfile) if errors: raise SQLLoadError (sql = sql, errors = errors) return True	476,928
def _toText(self): if self.type == OPERAND_IMMEDIATE: if self.value >= 0: return "0x%x" % self.value else: return "-0x%x" % abs(self.value) elif self.type == OPERAND_REGISTER: return self.GetName() elif self.type == OPERAND_ABSOLUTE_ADDRESS: return '[0x%x]' % self.disp elif self.type == OPERAND_FAR_MEMORY: return '%s:%s' % (hex(self.seg), hex(self.off)) elif (self.type == OPERAND_MEMORY): result = "[" if self.base != None: result += Registers[self.base] + "+" if self.index != None: result += Registers[self.index] if self.scale > 1: result += "*%d" % self.scale if self.disp >= 0: result += "+0x%x" % self.disp else: result += "-0x%x" % abs(self.disp) return result + "]"	def _toText(self): if self.type == OPERAND_IMMEDIATE: if self.value >= 0: return "0x%x" % self.value else: return "-0x%x" % abs(self.value) elif self.type == OPERAND_REGISTER: return self.name elif self.type == OPERAND_ABSOLUTE_ADDRESS: return '[0x%x]' % self.disp elif self.type == OPERAND_FAR_MEMORY: return '%s:%s' % (hex(self.seg), hex(self.off)) elif (self.type == OPERAND_MEMORY): result = "[" if self.base != None: result += Registers[self.base] + "+" if self.index != None: result += Registers[self.index] if self.scale > 1: result += "*%d" % self.scale if self.disp >= 0: result += "+0x%x" % self.disp else: result += "-0x%x" % abs(self.disp) return result + "]"	476,929
def DecodeGenerator(codeOffset, code, dt): """ @type codeOffset: long @param codeOffset: Memory address where the code is located. This is B{not} an offset into the code! It's the actual memory address where it was read from. @type code: str @param code: Code to disassemble. @type dt: int @param dt: Disassembly type. Can be one of the following: * L{Decode16Bits}: 80286 decoding * L{Decode32Bits}: IA-32 decoding * L{Decode64Bits}: AMD64 decoding @rtype: generator of tuple( long, int, str, str ) @return: Generator of tuples. Each tuple represents an assembly instruction and contains: - Memory address of instruction. - Size of instruction in bytes. - Disassembly line of instruction. - Hexadecimal dump of instruction. @raise ValueError: Invalid arguments. """ if not code: return if not codeOffset: codeOffset = 0 if dt not in (Decode16Bits, Decode32Bits, Decode64Bits): raise ValueError("Invalid decode type value: %r" % (dt,)) codeLen = len(code) p_code = byref(create_string_buffer(code)) result = (_DecodedInst * MAX_INSTRUCTIONS)() p_result = byref(result) instruction_off = 0 while codeLen > 0: usedInstructionsCount = c_uint(0) status = internal_decode(_OffsetType(codeOffset), p_code, codeLen, dt, p_result, MAX_INSTRUCTIONS, byref(usedInstructionsCount)) if status == DECRES_INPUTERR: raise ValueError("Invalid arguments passed to distorm_decode()") used = usedInstructionsCount.value if not used: break for index in xrange(used): di = result[index] asm = di.mnemonic.p if len(di.operands.p): asm += " " + di.operands.p pydi = ( di.offset, di.size, asm, di.instructionHex.p ) instruction_off += di.size yield pydi di = result[used - 1] delta = di.offset - codeOffset + result[used -1].size if delta <= 0: break codeOffset = codeOffset + delta p_code = byref(create_string_buffer(code), instruction_off) codeLen = codeLen - delta	def DecodeGenerator(codeOffset, code, dt): """ @type codeOffset: long @param codeOffset: Memory address where the code is located. This is B{not} an offset into the code! It's the actual memory address where it was read from. @type code: str @param code: Code to disassemble. @type dt: int @param dt: Disassembly type. Can be one of the following: * L{Decode16Bits}: 80286 decoding * L{Decode32Bits}: IA-32 decoding * L{Decode64Bits}: AMD64 decoding @rtype: generator of tuple( long, int, str, str ) @return: Generator of tuples. Each tuple represents an assembly instruction and contains: - Memory address of instruction. - Size of instruction in bytes. - Disassembly line of instruction. - Hexadecimal dump of instruction. @raise ValueError: Invalid arguments. """ if not code: return if not codeOffset: codeOffset = 0 if dt not in (Decode16Bits, Decode32Bits, Decode64Bits): raise ValueError("Invalid decode type value: %r" % (dt,)) codeLen = len(code) code_buf = create_string_buffer(code) p_code = byref(code_buf) result = (_DecodedInst * MAX_INSTRUCTIONS)() p_result = byref(result) instruction_off = 0 while codeLen > 0: usedInstructionsCount = c_uint(0) status = internal_decode(_OffsetType(codeOffset), p_code, codeLen, dt, p_result, MAX_INSTRUCTIONS, byref(usedInstructionsCount)) if status == DECRES_INPUTERR: raise ValueError("Invalid arguments passed to distorm_decode()") used = usedInstructionsCount.value if not used: break for index in xrange(used): di = result[index] asm = di.mnemonic.p if len(di.operands.p): asm += " " + di.operands.p pydi = ( di.offset, di.size, asm, di.instructionHex.p ) instruction_off += di.size yield pydi di = result[used - 1] delta = di.offset - codeOffset + result[used -1].size if delta <= 0: break codeOffset = codeOffset + delta p_code = byref(create_string_buffer(code), instruction_off) codeLen = codeLen - delta	476,930
def DecodeGenerator(codeOffset, code, dt): """ @type codeOffset: long @param codeOffset: Memory address where the code is located. This is B{not} an offset into the code! It's the actual memory address where it was read from. @type code: str @param code: Code to disassemble. @type dt: int @param dt: Disassembly type. Can be one of the following: * L{Decode16Bits}: 80286 decoding * L{Decode32Bits}: IA-32 decoding * L{Decode64Bits}: AMD64 decoding @rtype: generator of tuple( long, int, str, str ) @return: Generator of tuples. Each tuple represents an assembly instruction and contains: - Memory address of instruction. - Size of instruction in bytes. - Disassembly line of instruction. - Hexadecimal dump of instruction. @raise ValueError: Invalid arguments. """ if not code: return if not codeOffset: codeOffset = 0 if dt not in (Decode16Bits, Decode32Bits, Decode64Bits): raise ValueError("Invalid decode type value: %r" % (dt,)) codeLen = len(code) p_code = byref(create_string_buffer(code)) result = (_DecodedInst * MAX_INSTRUCTIONS)() p_result = byref(result) instruction_off = 0 while codeLen > 0: usedInstructionsCount = c_uint(0) status = internal_decode(_OffsetType(codeOffset), p_code, codeLen, dt, p_result, MAX_INSTRUCTIONS, byref(usedInstructionsCount)) if status == DECRES_INPUTERR: raise ValueError("Invalid arguments passed to distorm_decode()") used = usedInstructionsCount.value if not used: break for index in xrange(used): di = result[index] asm = di.mnemonic.p if len(di.operands.p): asm += " " + di.operands.p pydi = ( di.offset, di.size, asm, di.instructionHex.p ) instruction_off += di.size yield pydi di = result[used - 1] delta = di.offset - codeOffset + result[used -1].size if delta <= 0: break codeOffset = codeOffset + delta p_code = byref(create_string_buffer(code), instruction_off) codeLen = codeLen - delta	def DecodeGenerator(codeOffset, code, dt): """ @type codeOffset: long @param codeOffset: Memory address where the code is located. This is B{not} an offset into the code! It's the actual memory address where it was read from. @type code: str @param code: Code to disassemble. @type dt: int @param dt: Disassembly type. Can be one of the following: * L{Decode16Bits}: 80286 decoding * L{Decode32Bits}: IA-32 decoding * L{Decode64Bits}: AMD64 decoding @rtype: generator of tuple( long, int, str, str ) @return: Generator of tuples. Each tuple represents an assembly instruction and contains: - Memory address of instruction. - Size of instruction in bytes. - Disassembly line of instruction. - Hexadecimal dump of instruction. @raise ValueError: Invalid arguments. """ if not code: return if not codeOffset: codeOffset = 0 if dt not in (Decode16Bits, Decode32Bits, Decode64Bits): raise ValueError("Invalid decode type value: %r" % (dt,)) codeLen = len(code) p_code = byref(create_string_buffer(code)) result = (_DecodedInst * MAX_INSTRUCTIONS)() p_result = byref(result) instruction_off = 0 while codeLen > 0: usedInstructionsCount = c_uint(0) status = internal_decode(_OffsetType(codeOffset), p_code, codeLen, dt, p_result, MAX_INSTRUCTIONS, byref(usedInstructionsCount)) if status == DECRES_INPUTERR: raise ValueError("Invalid arguments passed to distorm_decode()") used = usedInstructionsCount.value if not used: break for index in xrange(used): di = result[index] asm = di.mnemonic.p if len(di.operands.p): asm += " " + di.operands.p pydi = ( di.offset, di.size, asm, di.instructionHex.p ) instruction_off += di.size yield pydi di = result[used - 1] delta = di.offset - codeOffset + result[used -1].size if delta <= 0: break codeOffset = codeOffset + delta p_code = byref(code_buf, instruction_off) codeLen = codeLen - delta	476,931
def DecomposeGenerator(codeOffset, code, dt): """ @type codeOffset: long @param codeOffset: Memory address where the code is located. This is B{not} an offset into the code! It's the actual memory address where it was read from. @type code: str @param code: Code to disassemble. @type dt: int @param dt: Disassembly type. Can be one of the following: * L{Decode16Bits}: 80286 decoding * L{Decode32Bits}: IA-32 decoding * L{Decode64Bits}: AMD64 decoding @rtype: generator of TODO @return: Generator of TODO @raise ValueError: Invalid arguments. """ if not code: return if not codeOffset: codeOffset = 0 if dt not in (Decode16Bits, Decode32Bits, Decode64Bits): raise ValueError("Invalid decode type value: %r" % (dt,)) codeLen = len(code) p_code = byref(create_string_buffer(code)) result = (_DInst * MAX_INSTRUCTIONS)() instruction_off = 0 while codeLen > 0: usedInstructionsCount = c_uint(0) codeInfo = _CodeInfo(_OffsetType(codeOffset), _OffsetType(0), cast(p_code, c_char_p), codeLen, dt, 0) status = internal_decompose(byref(codeInfo), byref(result), MAX_INSTRUCTIONS, byref(usedInstructionsCount)) if status == DECRES_INPUTERR: raise ValueError("Invalid arguments passed to distorm_decode()") used = usedInstructionsCount.value if not used: break delta = 0 for index in xrange(used): di = result[index] yield Instruction(di, code[instruction_off : instruction_off + di.size], dt) delta += di.size instruction_off += di.size if delta <= 0: break codeOffset = codeOffset + delta p_code = byref(create_string_buffer(code), instruction_off) codeLen = codeLen - delta	def DecomposeGenerator(codeOffset, code, dt): """ @type codeOffset: long @param codeOffset: Memory address where the code is located. This is B{not} an offset into the code! It's the actual memory address where it was read from. @type code: str @param code: Code to disassemble. @type dt: int @param dt: Disassembly type. Can be one of the following: * L{Decode16Bits}: 80286 decoding * L{Decode32Bits}: IA-32 decoding * L{Decode64Bits}: AMD64 decoding @rtype: generator of TODO @return: Generator of TODO @raise ValueError: Invalid arguments. """ if not code: return if not codeOffset: codeOffset = 0 if dt not in (Decode16Bits, Decode32Bits, Decode64Bits): raise ValueError("Invalid decode type value: %r" % (dt,)) codeLen = len(code) code_buf = create_string_buffer(code) p_code = byref(code_buf) result = (_DInst * MAX_INSTRUCTIONS)() instruction_off = 0 while codeLen > 0: usedInstructionsCount = c_uint(0) codeInfo = _CodeInfo(_OffsetType(codeOffset), _OffsetType(0), cast(p_code, c_char_p), codeLen, dt, 0) status = internal_decompose(byref(codeInfo), byref(result), MAX_INSTRUCTIONS, byref(usedInstructionsCount)) if status == DECRES_INPUTERR: raise ValueError("Invalid arguments passed to distorm_decode()") used = usedInstructionsCount.value if not used: break delta = 0 for index in xrange(used): di = result[index] yield Instruction(di, code[instruction_off : instruction_off + di.size], dt) delta += di.size instruction_off += di.size if delta <= 0: break codeOffset = codeOffset + delta p_code = byref(create_string_buffer(code), instruction_off) codeLen = codeLen - delta	476,932
def DecomposeGenerator(codeOffset, code, dt): """ @type codeOffset: long @param codeOffset: Memory address where the code is located. This is B{not} an offset into the code! It's the actual memory address where it was read from. @type code: str @param code: Code to disassemble. @type dt: int @param dt: Disassembly type. Can be one of the following: * L{Decode16Bits}: 80286 decoding * L{Decode32Bits}: IA-32 decoding * L{Decode64Bits}: AMD64 decoding @rtype: generator of TODO @return: Generator of TODO @raise ValueError: Invalid arguments. """ if not code: return if not codeOffset: codeOffset = 0 if dt not in (Decode16Bits, Decode32Bits, Decode64Bits): raise ValueError("Invalid decode type value: %r" % (dt,)) codeLen = len(code) p_code = byref(create_string_buffer(code)) result = (_DInst * MAX_INSTRUCTIONS)() instruction_off = 0 while codeLen > 0: usedInstructionsCount = c_uint(0) codeInfo = _CodeInfo(_OffsetType(codeOffset), _OffsetType(0), cast(p_code, c_char_p), codeLen, dt, 0) status = internal_decompose(byref(codeInfo), byref(result), MAX_INSTRUCTIONS, byref(usedInstructionsCount)) if status == DECRES_INPUTERR: raise ValueError("Invalid arguments passed to distorm_decode()") used = usedInstructionsCount.value if not used: break delta = 0 for index in xrange(used): di = result[index] yield Instruction(di, code[instruction_off : instruction_off + di.size], dt) delta += di.size instruction_off += di.size if delta <= 0: break codeOffset = codeOffset + delta p_code = byref(create_string_buffer(code), instruction_off) codeLen = codeLen - delta	def DecomposeGenerator(codeOffset, code, dt): """ @type codeOffset: long @param codeOffset: Memory address where the code is located. This is B{not} an offset into the code! It's the actual memory address where it was read from. @type code: str @param code: Code to disassemble. @type dt: int @param dt: Disassembly type. Can be one of the following: * L{Decode16Bits}: 80286 decoding * L{Decode32Bits}: IA-32 decoding * L{Decode64Bits}: AMD64 decoding @rtype: generator of TODO @return: Generator of TODO @raise ValueError: Invalid arguments. """ if not code: return if not codeOffset: codeOffset = 0 if dt not in (Decode16Bits, Decode32Bits, Decode64Bits): raise ValueError("Invalid decode type value: %r" % (dt,)) codeLen = len(code) p_code = byref(create_string_buffer(code)) result = (_DInst * MAX_INSTRUCTIONS)() instruction_off = 0 while codeLen > 0: usedInstructionsCount = c_uint(0) codeInfo = _CodeInfo(_OffsetType(codeOffset), _OffsetType(0), cast(p_code, c_char_p), codeLen, dt, 0) status = internal_decompose(byref(codeInfo), byref(result), MAX_INSTRUCTIONS, byref(usedInstructionsCount)) if status == DECRES_INPUTERR: raise ValueError("Invalid arguments passed to distorm_decode()") used = usedInstructionsCount.value if not used: break delta = 0 for index in xrange(used): di = result[index] yield Instruction(di, code[instruction_off : instruction_off + di.size], dt) delta += di.size instruction_off += di.size if delta <= 0: break codeOffset = codeOffset + delta p_code = byref(code_buf, instruction_off) codeLen = codeLen - delta	476,933
def init_INTEGER(self): Set = lambda args: self.SetCallback(ISetClass.INTEGER, args)	def init_INTEGER(self): Set = lambda args: self.SetCallback(ISetClass.INTEGER, args)	476,934
def _toText(self): if self._type == OPERAND_IMMEDIATE: if self._value >= 0: return "0x%x" % self._value else: return "-0x%x" % abs(self._value) elif self._type == OPERAND_REGISTER: return self.GetName() elif self._type == OPERAND_ABSOLUTE_ADDRESS: return '[0x%x]' % self._disp elif self._type == OPERAND_FAR_MEMORY: return '%s:%s' % (hex(self._seg), hex(self._off)) elif (self._type == OPERAND_MEMORY): result = "[" if self._base != None: result += Registers[self._base] + "+" if self._index != None: result += Registers[self._index] if self._scale > 1: result += "*%d" % self._scale if self._disp >= 0: result += "+0x%x" % self._disp else: result += "-0x%x" % abs(self._disp) return result + "]"	def _toText(self): if self.type == OPERAND_IMMEDIATE: if self.value >= 0: return "0x%x" % self.value else: return "-0x%x" % abs(self._value) elif self._type == OPERAND_REGISTER: return self.GetName() elif self._type == OPERAND_ABSOLUTE_ADDRESS: return '[0x%x]' % self._disp elif self._type == OPERAND_FAR_MEMORY: return '%s:%s' % (hex(self._seg), hex(self._off)) elif (self._type == OPERAND_MEMORY): result = "[" if self._base != None: result += Registers[self._base] + "+" if self._index != None: result += Registers[self._index] if self._scale > 1: result += "*%d" % self._scale if self._disp >= 0: result += "+0x%x" % self._disp else: result += "-0x%x" % abs(self._disp) return result + "]"	476,935
def _toText(self): if self._type == OPERAND_IMMEDIATE: if self._value >= 0: return "0x%x" % self._value else: return "-0x%x" % abs(self._value) elif self._type == OPERAND_REGISTER: return self.GetName() elif self._type == OPERAND_ABSOLUTE_ADDRESS: return '[0x%x]' % self._disp elif self._type == OPERAND_FAR_MEMORY: return '%s:%s' % (hex(self._seg), hex(self._off)) elif (self._type == OPERAND_MEMORY): result = "[" if self._base != None: result += Registers[self._base] + "+" if self._index != None: result += Registers[self._index] if self._scale > 1: result += "*%d" % self._scale if self._disp >= 0: result += "+0x%x" % self._disp else: result += "-0x%x" % abs(self._disp) return result + "]"	def _toText(self): if self._type == OPERAND_IMMEDIATE: if self._value >= 0: return "0x%x" % self._value else: return "-0x%x" % abs(self.value) elif self.type == OPERAND_REGISTER: return self.GetName() elif self._type == OPERAND_ABSOLUTE_ADDRESS: return '[0x%x]' % self._disp elif self._type == OPERAND_FAR_MEMORY: return '%s:%s' % (hex(self._seg), hex(self._off)) elif (self._type == OPERAND_MEMORY): result = "[" if self._base != None: result += Registers[self._base] + "+" if self._index != None: result += Registers[self._index] if self._scale > 1: result += "*%d" % self._scale if self._disp >= 0: result += "+0x%x" % self._disp else: result += "-0x%x" % abs(self._disp) return result + "]"	476,936
def _toText(self): if self._type == OPERAND_IMMEDIATE: if self._value >= 0: return "0x%x" % self._value else: return "-0x%x" % abs(self._value) elif self._type == OPERAND_REGISTER: return self.GetName() elif self._type == OPERAND_ABSOLUTE_ADDRESS: return '[0x%x]' % self._disp elif self._type == OPERAND_FAR_MEMORY: return '%s:%s' % (hex(self._seg), hex(self._off)) elif (self._type == OPERAND_MEMORY): result = "[" if self._base != None: result += Registers[self._base] + "+" if self._index != None: result += Registers[self._index] if self._scale > 1: result += "*%d" % self._scale if self._disp >= 0: result += "+0x%x" % self._disp else: result += "-0x%x" % abs(self._disp) return result + "]"	def _toText(self): if self._type == OPERAND_IMMEDIATE: if self._value >= 0: return "0x%x" % self._value else: return "-0x%x" % abs(self._value) elif self._type == OPERAND_REGISTER: return self.GetName() elif self.type == OPERAND_ABSOLUTE_ADDRESS: return '[0x%x]' % self.disp elif self.type == OPERAND_FAR_MEMORY: return '%s:%s' % (hex(self.seg), hex(self.off)) elif (self.type == OPERAND_MEMORY): result = "[" if self._base != None: result += Registers[self._base] + "+" if self._index != None: result += Registers[self._index] if self._scale > 1: result += "*%d" % self._scale if self._disp >= 0: result += "+0x%x" % self._disp else: result += "-0x%x" % abs(self._disp) return result + "]"	476,937
def _toText(self): if self._type == OPERAND_IMMEDIATE: if self._value >= 0: return "0x%x" % self._value else: return "-0x%x" % abs(self._value) elif self._type == OPERAND_REGISTER: return self.GetName() elif self._type == OPERAND_ABSOLUTE_ADDRESS: return '[0x%x]' % self._disp elif self._type == OPERAND_FAR_MEMORY: return '%s:%s' % (hex(self._seg), hex(self._off)) elif (self._type == OPERAND_MEMORY): result = "[" if self._base != None: result += Registers[self._base] + "+" if self._index != None: result += Registers[self._index] if self._scale > 1: result += "*%d" % self._scale if self._disp >= 0: result += "+0x%x" % self._disp else: result += "-0x%x" % abs(self._disp) return result + "]"	def _toText(self): if self._type == OPERAND_IMMEDIATE: if self._value >= 0: return "0x%x" % self._value else: return "-0x%x" % abs(self._value) elif self._type == OPERAND_REGISTER: return self.GetName() elif self._type == OPERAND_ABSOLUTE_ADDRESS: return '[0x%x]' % self._disp elif self._type == OPERAND_FAR_MEMORY: return '%s:%s' % (hex(self._seg), hex(self._off)) elif (self._type == OPERAND_MEMORY): result = "[" if self.base != None: result += Registers[self.base] + "+" if self.index != None: result += Registers[self.index] if self.scale > 1: result += "*%d" % self.scale if self.disp >= 0: result += "+0x%x" % self.disp else: result += "-0x%x" % abs(self._disp) return result + "]"	476,938
def _toText(self): if self._type == OPERAND_IMMEDIATE: if self._value >= 0: return "0x%x" % self._value else: return "-0x%x" % abs(self._value) elif self._type == OPERAND_REGISTER: return self.GetName() elif self._type == OPERAND_ABSOLUTE_ADDRESS: return '[0x%x]' % self._disp elif self._type == OPERAND_FAR_MEMORY: return '%s:%s' % (hex(self._seg), hex(self._off)) elif (self._type == OPERAND_MEMORY): result = "[" if self._base != None: result += Registers[self._base] + "+" if self._index != None: result += Registers[self._index] if self._scale > 1: result += "*%d" % self._scale if self._disp >= 0: result += "+0x%x" % self._disp else: result += "-0x%x" % abs(self._disp) return result + "]"	def _toText(self): if self._type == OPERAND_IMMEDIATE: if self._value >= 0: return "0x%x" % self._value else: return "-0x%x" % abs(self._value) elif self._type == OPERAND_REGISTER: return self.GetName() elif self._type == OPERAND_ABSOLUTE_ADDRESS: return '[0x%x]' % self._disp elif self._type == OPERAND_FAR_MEMORY: return '%s:%s' % (hex(self._seg), hex(self._off)) elif (self._type == OPERAND_MEMORY): result = "[" if self._base != None: result += Registers[self._base] + "+" if self._index != None: result += Registers[self._index] if self._scale > 1: result += "*%d" % self._scale if self._disp >= 0: result += "+0x%x" % self._disp else: result += "-0x%x" % abs(self.disp) return result + "]"	476,939