def __get__(self, obj, t = None): if t is None: raise NotImplementedError # I don't know what to do here if obj is None: return new.instancemethod(self.__func__, t, type(t)) else: return new.instancemethod(self.__func__, obj, t)
def shlaunchBackground(cmd, desc = None, progressFunc = None, endFunc = None): """ Follow backup process The progressFunc in param can follow processus via stdin and stdout. - progressFunc is called each time datas are emmited on stdout - shlaunchBackground drop process after 60 seconds on inactivity @param cmd: the shell command to launch @type cmd: str @param desc: description in "background action" (optional) @type desc: str @param progressFunc: callback function to follow processus evolution. @see: progressBackup for an example @type progressFunc: function """ logger = logging.getLogger() logger.info("support.mmctools.shlaunchBackground(\""+str(cmd)+"\")") shProcess = shSharedProcessProtocol(cmd) if desc == None: shProcess.desc = cmd else: shProcess.desc = desc ProcessScheduler().addProcess(shProcess.desc, shProcess) if progressFunc: shProcess.progressCalc = instancemethod(progressFunc, shProcess, shSharedProcessProtocol) if endFunc: shProcess.processEnded = instancemethod(endFunc, shProcess, shSharedProcessProtocol) reactor.spawnProcess(shProcess, "/bin/sh", ['/bin/sh','-c',cmd],env=os.environ)
def CommandLinePlugin(_name, _holderProject = None): """ Create a command line plugin project. """ _sourceRootFolder = csnUtility.NormalizePath(os.path.dirname(csnProject.FindFilename(1))) # command line lib projectLibName = "%sLib" % _name projectLib = csnProject.Project(projectLibName, "dll", _sourceRootFolder) #project = CilabModuleProject(projectName, "dll", _sourceRootFolder) projectLib.AddDefinitions(["-Dmain=ModuleEntryPoint"], _private = 1 ) projectLib.installSubFolder = "commandLinePlugins" projectLib.CMakeInsertBeforeTarget = new.instancemethod(CreateCMakeCLPPre, projectLib) projectLib.CMakeInsertAfterTarget = new.instancemethod(CreateCMakeCLPPost, projectLib) # command line executable projectAppName = _name projectApp = csnBuild.Project(projectAppName, "executable", _sourceRootFolder) projectApp.AddProjects( [projectLib] ) projectApp.installSubFolder = "commandLinePlugins" # wrapper for shared libraries wrapperSourceFile = None for thirdParty in csnProject.globalCurrentContext.GetThirdPartyFolders(): currentWrapperSourceFile = u'%s/SLICER/Slicer3/Applications/CLI/Templates/CommandLineSharedLibraryWrapper.cxx' % thirdParty if os.path.isfile(currentWrapperSourceFile): wrapperSourceFile = currentWrapperSourceFile if wrapperSourceFile is None: raise Exception("Could not find Slicer template in your thirdParty folders.") projectApp.AddSources( [wrapperSourceFile] ) # force the creation of the application project projectLib.AddProjects([projectApp], _dependency = 0) if not (_holderProject is None): _holderProject.AddProjects( [projectLib] ) return projectLib
def AddMethod(object, function, name = None): """ Adds either a bound method to an instance or an unbound method to a class. If name is ommited the name of the specified function is used by default. Example: a = A() def f(self, x, y): self.z = x + y AddMethod(f, A, "add") a.add(2, 4) print a.z AddMethod(lambda self, i: self.l[i], a, "listIndex") print a.listIndex(5) """ import new if name is None: name = function.func_name else: function = RenameFunction(function, name) try: klass = object.__class__ except AttributeError: # "object" is really a class, so it gets an unbound method. object.__dict__[name] = new.instancemethod(function, None, object) else: # "object" is really an instance, so it gets a bound method. object.__dict__[name] = new.instancemethod(function, object, klass)
def test_0020_static_file_url(self): with Transaction().start(DB_NAME, USER, CONTEXT): self.setup_defaults() file_buffer = buffer('test-content') file = self.create_static_file(file_buffer) self.assertFalse(file.url) app = self.get_app() static_file_obj = self.static_file_obj with app.test_client() as c: # Patch the home page method def home_func(self, file_id): return render_template( 'home.jinja', static_file_obj=static_file_obj, static_file_id=file_id, ) home_func = functools.partial(home_func, file_id=file.id) c.application.view_functions[ 'nereid.website.home'] = new.instancemethod( home_func, self.nereid_website_obj ) self.nereid_website_obj.home = new.instancemethod( home_func, self.nereid_website_obj ) rv = c.get('/en_US/') self.assertTrue('/en_US/static-file/test/test.png' in rv.data) self.assertEqual(rv.status_code, 200)
def setUp(self): class Model(object): _row_data = None _addition_rows = None _removal_rows = None def _get_row_data(self): return self._row_data def _set_row_data(self, _row_data, addition_rows=None, removal_rows=None): self._row_data = _row_data self._addition_rows = addition_rows self._removal_rows = removal_rows _sort_order = QtCore.Qt.SortOrder.AscendingOrder _sort_column1 = 0 _sort_column2 = 0 def _sort_list(self, _row_data): qtui.CustomItemModel._sort_list.im_func(self, _row_data) class DisassemblyModule(object): _next_uncertain_references = None def get_uncertain_references_by_address(self, program_data, address): result = self._next_uncertain_references self._next_uncertain_references = None return result class DisassemblyData(object): pass self.fake_disassembly_module = fake_disassembly_module = DisassemblyModule() self.disassembly_data = disassembly_data = DisassemblyData() if False: class EditorState(object): def get_uncertain_references_by_address(self, address): return fake_disassembly_module.get_uncertain_references_by_address(disassembly_data, address) class EditorClient(object): def reset_state(self): pass self.editor_client = EditorClient() self.editor_state = editor_state.EditorState() self.editor_state.register_client(self.editor_client) self.editor_state.get_uncertain_references_by_address.func_globals["disassembly"] = self.fake_disassembly_module self.uncertain_code_references_model = Model() self.uncertain_data_references_model = Model() self.code_rows = [ [1], [2], [5], [9], [10] ] self.uncertain_code_references_model._row_data = self.code_rows[:] self.data_rows = [ [3], [7], [8], [11] ] self.uncertain_data_references_model._row_data = self.data_rows[:] self.on_uncertain_reference_modification = qtui.MainWindow.on_uncertain_reference_modification.im_func self._remove_address_range_from_model = new.instancemethod(qtui.MainWindow._remove_address_range_from_model.im_func, self, self.__class__) self._add_rows_to_model = new.instancemethod(qtui.MainWindow._add_rows_to_model.im_func, self, self.__class__)
def unpickleMethod(im_name, im_self, im_class): 'support function for copy_reg to unpickle method refs' try: unbound = getattr(im_class,im_name) if im_self is None: return unbound bound=instancemethod(unbound.im_func, im_self, im_class) return bound except AttributeError: log.error("Method" + im_name + "not on class" + im_class) assert im_self is not None,"No recourse: no instance to guess from." # Attempt a common fix before bailing -- if classes have # changed around since we pickled this method, we may still be # able to get it by looking on the instance's current class. unbound = getattr(im_self.__class__,im_name) log.error("Attempting fixup with" + unbound) if im_self is None: return unbound bound=instancemethod(unbound.im_func, im_self, im_self.__class__) return bound
def make_simpleai(stage, node, timeout=1.0): """A stupid AI for enemies. Just moving around randomly. @type stage: stagescene.StageScene """ node.ai_timecount=timeout * random() node.ai_old_pos = (node.x, node.y) node.is_ai_stopped = False def on_tick(self, interval): if self.is_ai_stopped: return self.ai_timecount += interval # XXX #if (self.ai_timecount < timeout # and self.ai_old_pos != (self.x, self.y)): if (self.ai_timecount < timeout): return self.ai_timecount = 0.0 self.ai_old_pos = (node.x, node.y) dir = ['up', 'down', 'left', 'right'][int(random() * 4)] self.stop() self.move(dir) def stop_ai(self): self.is_ai_stopped = True node.on_tick = instancemethod(on_tick, node) node.stop_ai = instancemethod(stop_ai, node) return node
def __init__(self, app, gladefile, windowname) : self.appmanager = app self.imageDatabase = app.imageDatabase self.appmanager.register_window(self) self.widgets=gtk.glade.XML (gladefile,windowname) callbacks = {} #find and store methods as bound callbacks for c in self.__class__.__bases__ : class_methods = c.__dict__ for method_name in class_methods.keys(): method = class_methods[method_name] if type(method) == types.FunctionType: callbacks[method_name] = new.instancemethod( method, self, self.__class__) class_methods = self.__class__.__dict__ for method_name in class_methods.keys(): method = class_methods[method_name] if type(method) == types.FunctionType: callbacks[method_name] = new.instancemethod( method, self, self.__class__) self.widgets.signal_autoconnect(callbacks) self.window = self.widgets.get_widget(windowname) self.window.connect('delete-event', self.on_window_delete_event); self.window.connect('destroy-event', self.on_window_destroy_event);
def __getattr__(self, attr): # Allow the underlying interface to provide a better implementation if desired. if attr in _special_getattr_names: raise AttributeError, attr ret = getattr(self.__dict__['_comobj_'], attr, None) if ret is not None: return ret # Do the function thing first. unbound_method = self.__dict__['_methods_'].get(attr, None) if unbound_method is not None: return new.instancemethod(unbound_method, self, self.__class__) getters = self.__dict__['_property_getters_'] info = getters.get(attr) if info is not None: method_index, param_infos = info if len(param_infos)!=1: # Only expecting a retval raise RuntimeError, "Can't get properties with this many args!" args = ( param_infos, () ) return XPTC_InvokeByIndex(self._comobj_, method_index, args) # See if we have a method info waiting to be turned into a method. # Do this last as it is a one-off hit. method_info = self.__dict__['_method_infos_'].get(attr, None) if method_info is not None: unbound_method = BuildMethod(method_info, self._iid_) # Cache it locally self.__dict__['_methods_'][attr] = unbound_method return new.instancemethod(unbound_method, self, self.__class__) raise AttributeError, "XPCOM component '%s' has no attribute '%s'" % (self._object_name_, attr)
def _configFeature(self, ftr, obj): global loadedFeatures if type(ftr) == str: modName, ftrName = ftr.split('.') ftrClsName = "%s_Feature" % ftrName mod = __import__('indico.tests.python.unit.%s' % modName, globals(), locals(), [ftrClsName]) ftr = mod.__dict__[ftrClsName] else: pass for name, func in ftr.__dict__.iteritems(): if name.startswith('_action_'): setattr(obj, name[7:], new.instancemethod(func, obj, obj.__class__)) elif name.startswith('_context_'): setattr(obj, name, new.instancemethod(func, obj, obj.__class__)) ftrObj = ftr() if ftr not in loadedFeatures: ftrObj.start(obj) loadedFeatures.append(ftr) return ftrObj
def test_request_exception_signal(self): with Transaction().start(DB_NAME, USER, CONTEXT): self.setup_defaults() app = self.get_app() app.config['DEBUG'] = False recorded = [] # Patch the home page method def home_func(self): 1 // 0 app.view_functions['nereid.website.home'] = \ new.instancemethod( home_func, self.nereid_website_obj ) self.nereid_website_obj.home = new.instancemethod( home_func, self.nereid_website_obj ) def record(sender, exception): recorded.append(exception) flask.got_request_exception.connect(record, app) try: self.assertEqual( app.test_client().get('/').status_code, 500 ) self.assertEqual(len(recorded), 1) assert isinstance(recorded[0], ZeroDivisionError) finally: flask.got_request_exception.disconnect(record, app)
def test_template_rendered(self): with Transaction().start(DB_NAME, USER, CONTEXT): self.setup_defaults() app = self.get_app() # Patch the home page method def home_func(self): return nereid.render_template( 'home.jinja', whiskey=42 ) app.view_functions['nereid.website.home'] = \ new.instancemethod( home_func, self.nereid_website_obj ) self.nereid_website_obj.home = new.instancemethod( home_func, self.nereid_website_obj ) recorded = [] def record(sender, template, context): recorded.append((template, context)) flask.template_rendered.connect(record, app) try: app.test_client().get('/') self.assertEqual(len(recorded), 1) template, context = recorded[0] self.assertEqual(template.name, 'home.jinja') self.assertEqual(context['whiskey'], 42) finally: flask.template_rendered.disconnect(record, app)
def test_0020_static_file_url(self): with Transaction().start(testing_proxy.db_name, 1, None) as txn: file_id, = self.static_file_obj.search([], limit=1) file = self.static_file_obj.browse(file_id) self.assertFalse(file.url) app = self.get_app() with app.test_client() as c: # Patch the home page method def home_func(self, file_id): static_file_obj = Pool().get('nereid.static.file') return render_template( 'home.jinja', static_file_obj=static_file_obj, static_file_id=file_id, ) home_func = functools.partial(home_func, file_id=file_id) c.application.view_functions[ 'nereid.website.home'] = new.instancemethod( home_func, self.website_obj ) self.website_obj.home = new.instancemethod( home_func, self.website_obj ) rv = c.get('/en_US/') self.assertTrue('/en_US/static-file/test/test.png' in rv.data) self.assertEqual(rv.status_code, 200)
def __init__(cls, name, bases, cls_dict): cls.use_metaclass = 1 def fake_method(self): pass new.instancemethod(fake_method, None, cls)
def override_replace(target, name, func, combiner=replacement, reverse=False): obj = target cls = target.__class__ is_derived = False # The function is defined in the superclass (which we don't override) if not name in cls.__dict__: is_derived = True # Bind the call to the superclass function orig_func = new.instancemethod(lambda self, *args, **named: getattr(super(cls, self), name).__call__(*args,**named), obj, cls) else: orig_func = getattr(obj, name) if not hasattr(orig_func, "stacked"): stacked_func = stacked_function(orig_func, combiner=combiner, reverse=reverse) setattr(target, name, stacked_func) else: stacked_func = orig_func # Add the replacement effect along with the card name (in case of multiple effects) new_func = [new.instancemethod(func, obj, cls), name, False] #card.name, False] stacked_func.add_func(new_func) def restore(stacked_func=stacked_func): stacked_func.remove_func(new_func) if not stacked_func.stacking(): setattr(target, name, stacked_func.funcs[0]) del stacked_func func.expire = restore return restore
def seek_gzip_factory(f): """Use this factory to produce the class so that we can do a lazy import on gzip. """ import gzip, new def seek(self, offset, whence=0): # figure out new position (we can only seek forwards) if whence == 1: offset = self.offset + offset if whence not in [0, 1]: raise IOError, "Illegal argument" if offset < self.offset: # for negative seek, rewind and do positive seek self.rewind() count = offset - self.offset for i in range(count // 1024): self.read(1024) self.read(count % 1024) def tell(self): return self.offset if isinstance(f, str): f = gzip.GzipFile(f) f.seek = new.instancemethod(seek, f) f.tell = new.instancemethod(tell, f) return f
def enable_router_hints(): import new from django.db import DEFAULT_DB_ALIAS, router from landlord.conf import settings def _router_func(action): def _route_db(self, model, **hints): from landlord import landlord hints.update({settings.LANDLORD_DEFAULT_NAMESPACE_KEY: landlord.get_current_namespace()}) chosen_db = None for router in self.routers: try: method = getattr(router, action) except AttributeError: # If the router doesn't have a method, skip to the next one. pass else: chosen_db = method(model, **hints) if chosen_db: return chosen_db try: return hints["instance"]._state.db or DEFAULT_DB_ALIAS except KeyError: return DEFAULT_DB_ALIAS return _route_db router.db_for_read = new.instancemethod(_router_func("db_for_read"), router, None) router.db_for_write = new.instancemethod(_router_func("db_for_write"), router, None)
def decorator(orig): if isinstance(orig, (new.classobj, type)): cls2 = orig class Before(object): pass b = Before() setattr(cls, "Before" + cls2.__name__, b) setattr(cls2, "super", b) for k, v in cls2.__dict__.items(): if isinstance(v, new.function): f = decorator(v) setattr(b, f.func_name, f.__original__) v.__original__ = f.__original__ return cls2 else: f = orig func_name = f.func_name replacement_method = new.instancemethod(f, None, cls) def monkeypatch(*a, **k): return replacement_method(*a, **k) f = monkeypatch f.func_name = func_name method = getattr(cls, func_name, None) f.__original__ = method setattr(cls, func_name, new.instancemethod(f, None, cls)) return f
def __init__(self, link, flash_type): self.stopped = False self.status = '' self.link = link self.flash_type = flash_type self._waiting_for_callback = False self._read_callback_data = [] self.link.add_callback(ids.FLASH_DONE, self._done_callback) self.link.add_callback(ids.FLASH_READ, self._read_callback) self.ihx_elapsed_ops = 0 # N operations finished in self.write_ihx self.ihx_total_ops = None # Total operations in self.write_ihx call if self.flash_type == "STM": self.flash_type_byte = 0 self.addr_sector_map = stm_addr_sector_map # Add STM-specific functions. self.__dict__['lock_sector'] = \ new.instancemethod(_stm_lock_sector, self, Flash) self.__dict__['unlock_sector'] = \ new.instancemethod(_stm_unlock_sector, self, Flash) self.n_sectors = STM_N_SECTORS self.restricted_sectors = STM_RESTRICTED_SECTORS elif self.flash_type == "M25": self.flash_type_byte = 1 self.addr_sector_map = m25_addr_sector_map # Add M25-specific functions. self.__dict__['write_status'] = \ new.instancemethod(_m25_write_status, self, Flash) self.n_sectors = M25_N_SECTORS self.restricted_sectors = M25_RESTRICTED_SECTORS else: raise ValueError("flash_type must be \"STM\" or \"M25\"")
def setup (self): logging.getLogger('').handlers = [] logging.addLevelName(TRACE, 'TRACE') logging.addLevelName(MOREINFO, 'MOREINFO') if self.enabled == True: # setup root logger self.root_logger = logging.getLogger('') if self.file is not None: formatter = logging.Formatter(self.format, self.datefmt) handler = MyFileHandler(self.file, 'a') handler.setFormatter(formatter) self.root_logger.addHandler(handler) else: self.root_logger.addHandler(DevnullHandler()) self.root_logger.setLevel(logging._levelNames[self.level]) self.root_logger.trace = new.instancemethod(trace_method, self.root_logger, self.root_logger.__class__) self.root_logger.moreinfo = new.instancemethod(moreinfo_method, self.root_logger, self.root_logger.__class__) self.root_logger.__repr__ = new.instancemethod(repr_method, self.root_logger, self.root_logger.__class__) # setup a console logger, if enabled if self.console == True: console_fmtr = logging.Formatter(self.console_format, self.console_datefmt) console_hdlr = logging.StreamHandler() console_hdlr.setFormatter(console_fmtr) console_hdlr.setLevel(logging._levelNames[self.console_level]) self.root_logger.addHandler(console_hdlr) self.is_setup = True
def __init__(self, category_algorithm, rank_by, frequency_bins = None): if category_algorithm == "frequency-ifos-oninstruments": self.category_func = lambda self, on_instruments, participating_instruments, frequency: (on_instruments, participating_instruments, self.frequency_bins[frequency]) elif category_algorithm == "oninstruments": self.category_func = lambda self, on_instruments, participating_instruments, frequency: on_instruments else: raise ValueError, category_algorithm self.category_func = instancemethod(self.category_func, self, self.__class__) if rank_by == "snr": self.reputation_func = lambda self, snr, uncombined_ifar, likelihood: snr elif rank_by == "uncombined-ifar": # cast to float so this does the right thing when # we get "inf" as a string self.reputation_func = lambda self, snr, uncombined_ifar, likelihood: float(uncombined_ifar) elif rank_by == "likelihood": self.reputation_func = lambda self, snr, uncombined_ifar, likelihood: likelihood else: raise ValueError, rank_by self.rank_by = rank_by self.reputation_func = instancemethod(self.reputation_func, self, self.__class__) self.frequency_bins = frequency_bins self.reputations = {} self.cached_livetime = {} self.extrapolate = False self.extrapolation_coeffs = {} self.categories = []
def setup_logging(increase_padding=False): """ Setup overall logging engine and add 2 more levels of logging lower than DEBUG, TRACE and GARBAGE. """ import logging if increase_padding and logging.getLoggerClass() is not Logging: logging.setLoggerClass(Logging) if not hasattr(LoggingLoggerClass, 'trace'): def trace(cls, msg, *args, **kwargs): return cls.log(5, msg, *args, **kwargs) logging.addLevelName(5, 'TRACE') LoggingLoggerClass.trace = new.instancemethod( trace, None, LoggingLoggerClass ) if not hasattr(LoggingLoggerClass, 'garbage'): def garbage(cls, msg, *args, **kwargs): return cls.log(1, msg, *args, **kwargs) logging.addLevelName(1, 'GARBAGE') LoggingLoggerClass.garbage = new.instancemethod( garbage, None, LoggingLoggerClass ) # Set the root logger at the lowest level possible logging.getLogger().setLevel(1)
def __init__(self, filename=None, mirror=False): if filename: self.load(filename) self.mirror = mirror self.plot_stretch = new.instancemethod(_make_plotting_func(self.stretch_density, "Stretching"), self) self.plot_bend = new.instancemethod(_make_plotting_func(self.bend_density, "Bending"), self) self.plot_height = new.instancemethod(_make_plotting_func(lambda: self.f_z, "Height"), self)
def __init__(self, link, flash_type, sbp_version, max_queued_ops=1): """ Object representing either of the two flashes (STM/M25) on the Piksi, including methods to erase, program, and read. Parameters ---------- link : sbp.client.handler.Handler Handler to send messages to Piksi over and register callbacks with. flash_type : string Which Piksi flash to interact with ("M25" or "STM"). sbp_version : (int, int) SBP protocol version, used to select messages to send. max_queued_ops : int Maximum number of Flash read/program operations to queue in device flash. (0.5 * ADDRS_PER_OP + SBP packet overhead) * max_queued_ops is how much of the device UART RX buffer will be filled by the program/read callback messages. A higher value will significantly speed up flashing, but can result in RX buffer overflows in other UARTs if the device is receiving data on other UARTs. Returns ------- out : Flash instance """ self._n_queued_ops = 0 self.max_queued_ops = max_queued_ops self.nqo_lock = Lock() self.stopped = False self.status = '' self.link = link self.flash_type = flash_type self.sbp_version = sbp_version # IntelHex object to store read flash data in that was read from device. self._read_callback_ihx = IntelHex() self.link.add_callback(self._done_callback, SBP_MSG_FLASH_DONE) self.link.add_callback(self._read_callback, SBP_MSG_FLASH_READ_RESP) self.ihx_elapsed_ops = 0 # N operations finished in self.write_ihx if self.flash_type == "STM": self.flash_type_byte = 0 self.addr_sector_map = stm_addr_sector_map # Add STM-specific functions. self.__dict__['lock_sector'] = \ new.instancemethod(_stm_lock_sector, self, Flash) self.__dict__['unlock_sector'] = \ new.instancemethod(_stm_unlock_sector, self, Flash) self.n_sectors = STM_N_SECTORS self.restricted_sectors = STM_RESTRICTED_SECTORS elif self.flash_type == "M25": self.flash_type_byte = 1 self.addr_sector_map = m25_addr_sector_map # Add M25-specific functions. self.__dict__['write_status'] = \ new.instancemethod(_m25_write_status, self, Flash) self.n_sectors = M25_N_SECTORS self.restricted_sectors = M25_RESTRICTED_SECTORS else: raise ValueError( "flash_type must be \"STM\" or \"M25\", got \"%s\"" % flash_type)
def __call__( cls, *args, **kwargs ): instance = cls.__new__( cls ) instance.__init__( *args, **kwargs ) setUpMethods = [] tearDownMethods = [] for _cls in reversed( cls.__mro__ ): setUp = getattr( _cls, 'setUp', None ) tearDown = getattr( _cls, 'tearDown', None ) if setUp: if not len( setUpMethods ) or setUp != setUpMethods[-1]: setUpMethods.append( setUp ) if tearDown: if not len( tearDownMethods ) or tearDown != tearDownMethods[0]: tearDownMethods.insert( 0, tearDown ) def chain( methods ): def fun( self ): for method in methods: method( self ) return fun instance.setUp = new.instancemethod( chain( setUpMethods ), instance, cls ) instance.tearDown = new.instancemethod( chain( tearDownMethods ), instance, cls ) return instance
def setup_wiki_handlers(self): """ Have the MoinMoin formatter handle markup when it makes sense. These are portions of the document that do not contain reST specific markup. This allows these portions of the document to look consistent with other wiki pages. Setup dispatch routines to handle basic document markup. The hanlders dict is the html4css1 handler name followed by the wiki handler name. """ handlers = { # Text Markup 'emphasis': 'emphasis', 'strong': 'strong', 'literal': 'code', # Blocks 'literal_block': 'preformatted', # Simple Lists # bullet-lists are handled completely by docutils because it uses # the node context to decide when to make a compact list # (no <p> tags). 'list_item': 'listitem', # Definition List 'definition_list': 'definition_list', } for rest_func, moin_func in handlers.items(): visit_func, depart_func = self.create_wiki_functor(moin_func) visit_func = new.instancemethod(visit_func, self, MoinTranslator) depart_func = new.instancemethod(depart_func, self, MoinTranslator) setattr(self, 'visit_%s' % (rest_func), visit_func) setattr(self, 'depart_%s' % (rest_func), depart_func)
def __init__(self, api_token, endpoint="https://shreddr.captricity.com/api/backbone/schema", version=None): """ endpoint must be the full url to the API schema document, like `http://127.0.0.1:8000/api/backbone/schema' api_token is the unique string associated with your account's profile which allows API access """ self.api_token = api_token self.endpoint = endpoint self.parsed_endpoint = urlparse.urlparse(self.endpoint) self.api_version = version schema_url = self.parsed_endpoint.path if version: schema_url = schema_url + '?version=' + version self.schema = self._get_data(schema_url) self.api_version = self.schema['version'] for resource in self.schema['resources']: if "GET" in resource['allowed_request_methods']: read_callable = _generate_read_callable(resource['name'], resource['display_name'], resource['arguments'], resource['regex'], resource['doc'], resource['supported']) setattr(self, read_callable.__name__, new.instancemethod(read_callable, self, self.__class__)) if "PUT" in resource['allowed_request_methods']: update_callable = _generate_update_callable(resource['name'], resource['display_name'], resource['arguments'], resource['regex'], resource['doc'], resource['supported'], resource['put_syntaxes']) setattr(self, update_callable.__name__, new.instancemethod(update_callable, self, self.__class__)) if "POST" in resource['allowed_request_methods']: create_callable = _generate_create_callable(resource['name'], resource['display_name'], resource['arguments'], resource['regex'], resource['doc'], resource['supported'], resource['post_syntaxes'], resource['is_action']) setattr(self, create_callable.__name__, new.instancemethod(create_callable, self, self.__class__)) if "DELETE" in resource['allowed_request_methods']: delete_callable = _generate_delete_callable(resource['name'], resource['display_name'], resource['arguments'], resource['regex'], resource['doc'], resource['supported']) setattr(self, delete_callable.__name__, new.instancemethod(delete_callable, self, self.__class__))
def __init__(self, hardware_obj): QObject.__init__(self) self.setIn = new.instancemethod(lambda self: None, self) self.setOut = self.setIn self.getState = new.instancemethod(lambda self: "unknown", self) self.dev = hardware_obj try: sClass = str(self.dev.__class__) i, j = re.search("'.*'", sClass).span() except BaseException: dev_class = sClass else: dev_class = sClass[i + 1 : j - 1] self.devClass = dev_class.split(".")[-1] # print "Type is",self.devClass if self.devClass == "Device": self.devClass = "Procedure" if not self.devClass in ( "WagoPneu", "Shutter", "SpecMotorWSpecPositions", "Procedure", ): self.devClass = "WagoPneu" initFunc = getattr(self, "init%s" % self.devClass) initFunc() self.setIn = getattr(self, "setIn%s" % self.devClass) self.setOut = getattr(self, "setOut%s" % self.devClass) self.getState = getattr(self, "getState%s" % self.devClass)
def add_filters(): """Add filters for every choice in ItemToPush.STATUS. This filters are mostly useless except if you do a lot of management from command line""" constants = [c for c in dir(models.ITEM_TO_PUSH_STATUS) if c.isupper() and c not in NOT_CONSTANTS] for current_constant in constants: method_name = current_constant.lower() def get_filter_function(constant): def filter_by_status(self): value = getattr(models.ITEM_TO_PUSH_STATUS, constant) return self.filter(status=value) return filter_by_status filter_by_status = get_filter_function(current_constant) filter_by_status_method = instancemethod(filter_by_status, None, BaseQuerySet) setattr(BaseQuerySet, method_name, filter_by_status_method) def get_query_function(name): def query_by_status(self): method = getattr(self.get_query_set(), name) return method() return query_by_status query_by_status = get_query_function(method_name) query_by_status_method = instancemethod(query_by_status, None, BaseManager) setattr(BaseManager, method_name, query_by_status_method)
def get_parser(document=None, namespaces=0, validate=0, external_ges=1, logfile=None, doc_factory=POM.new_document): import xml if hasattr(xml, "use_pyxml"): xml.use_pyxml() import xml.sax.sax2exts import xml.sax.handler import new handler = ContentHandler(document, doc_factory=doc_factory, logfile=logfile) errorhandler = ErrorHandler(logfile) # create parser parser = xml.sax.sax2exts.XMLParserFactory.make_parser() parser.setFeature(xml.sax.handler.feature_namespaces, namespaces) parser.setFeature(xml.sax.handler.feature_validation, validate) parser.setFeature(xml.sax.handler.feature_external_ges, external_ges) parser.setFeature(xml.sax.handler.feature_external_pes, 0) parser.setFeature(xml.sax.handler.feature_string_interning, 1) # set handlers parser.setContentHandler(handler) parser.setDTDHandler(handler) parser.setEntityResolver(handler) parser.setErrorHandler(errorhandler) # since the xml API provides some generic parser I can't just # subclass I have to "patch" the object in-place with this trick. # This is to a) make the API compatible with the HTMLParser, and b) # allow specifing the encoding and other headers in the request. parser.parse_orig = parser.parse def parse(self, url, data=None, encoding=POM.DEFAULT_ENCODING, useragent=None, accept=None): from pycopia.WWW import urllibplus fo = urllibplus.urlopen(url, data, encoding, useragent=useragent, accept=accept) if logfile: from pycopia import UserFile fo = UserFile.FileWrapper(fo, logfile=logfile) return self.parse_orig(fo) parser.parse = new.instancemethod(parse, parser, parser.__class__) return parser
def init_app(self): # TODO: ideally, this should be done by hooking body with an "onLoad". from __pyjamas__ import pygwt_processMetas, set_main_frame from __pyjamas__ import set_gtk_module set_gtk_module(gtk) main_frame = self._browser.getMainFrame() main_frame._callbacks = [] main_frame.gobject_wrap = webkit.gobject_wrap main_frame.platform = 'webkit' main_frame.addEventListener = addEventListener main_frame.getUri = self.getUri main_frame.getDomDocument = new.instancemethod(getDomDocument, main_frame) main_frame._addXMLHttpRequestEventListener = addXMLHttpRequestEventListener main_frame._addWindowEventListener = new.instancemethod( addWindowEventListener, main_frame) main_frame._alert = new.instancemethod(_alert, main_frame) main_frame.mash_attrib = mash_attrib set_main_frame(main_frame)
def __init__(self, parent_scope_ref): self._scope = parent_scope_ref def generatePrimitive(type_, self, text, **kwargs): return type_(self._scope(), text, **kwargs) # generate all the type factories import new for fname, type_ in self.types.iteritems(): func = functools.partial(generatePrimitive, type_) setattr(self, fname, new.instancemethod(func, self, PrimitiveFactory))
def as(self, pName): """ obtain a representation of self with respect to some personality """ cls = self.__class__ err = 'illegal personality for '+str(cls) + ': ' + pName assert pName in cls.personalities, err out = cls.personalities[pName] P = proxy() for funcname in out: func = out[funcname] func = new.instancemethod(func,self,cls) setattr(P, funcname, func) return P
def install(self, methodIdentifier): """Install myself on my instance in place of this method. """ oldMethod = getattr(self.instance, methodIdentifier, None) # XXX: this conditional probably isn't effective. if oldMethod is not self: # avoid triggering __setattr__ self.instance.__dict__[methodIdentifier] = ( new.instancemethod(self, self.instance, self.instance.__class__)) self.oldMethod = (methodIdentifier, oldMethod)
def build_model(self): self.model = get_model(**self.model_args) ln.info("Using RMSprop with %s" % dict(lr=float(self.config["learning_rate"]), rho=0.9, epsilon=1e-08, decay=0.0)) optimizer = RMSprop(lr=float(self.config["learning_rate"]), rho=0.9, epsilon=1e-08, decay=0.0) self.model.compile(optimizer=optimizer, loss='categorical_crossentropy', metrics=["accuracy"]) self.model.summary() # hot-patch saving and loading TODO remove once this is fixed in seq2seq def save_weights(_self, fname, overwrite=True): if not overwrite and os.path.isfile(fname): proceed = ask_to_proceed_with_overwrite(fname) if not proceed: return outf = h5py.File(fname, 'w') weight = _self.get_weights() for i in range(len(weight)): outf.create_dataset('weight' + str(i), data=weight[i]) outf.close() def load_weights(_self, fname): infile = h5py.File(fname, 'r') weight = [] for i in range(len(infile.keys())): weight.append(infile['weight' + str(i)][:]) _self.set_weights(weight) self.model.save_weights = new.instancemethod(save_weights, self.model, None) self.model.load_weights = new.instancemethod(load_weights, self.model, None)
def CommandLinePlugin(_name, _holderProject=None): """ Create a command line plugin project. """ _sourceRootFolder = csnUtility.NormalizePath( os.path.dirname(csnProject.FindFilename(1))) # command line lib projectLibName = "%sLib" % _name projectLib = csnProject.Project(projectLibName, "dll", _sourceRootFolder) #project = CilabModuleProject(projectName, "dll", _sourceRootFolder) projectLib.AddDefinitions(["-Dmain=ModuleEntryPoint"], _private=1) projectLib.installSubFolder = "commandLinePlugins" projectLib.CMakeInsertBeforeTarget = new.instancemethod( CreateCMakeCLPPre, projectLib) projectLib.CMakeInsertAfterTarget = new.instancemethod( CreateCMakeCLPPost, projectLib) # command line executable projectAppName = _name projectApp = csnBuild.Project(projectAppName, "executable", _sourceRootFolder) projectApp.AddProjects([projectLib]) projectApp.installSubFolder = "commandLinePlugins" # wrapper for shared libraries wrapperSourceFile = None for thirdParty in csnProject.globalCurrentContext.GetThirdPartyFolders(): currentWrapperSourceFile = u'%s/SLICER/Slicer3/Applications/CLI/Templates/CommandLineSharedLibraryWrapper.cxx' % thirdParty if os.path.isfile(currentWrapperSourceFile): wrapperSourceFile = currentWrapperSourceFile if wrapperSourceFile is None: raise Exception( "Could not find Slicer template in your thirdParty folders.") projectApp.AddSources([wrapperSourceFile]) # force the creation of the application project projectLib.AddProjects([projectApp], _dependency=0) if not (_holderProject is None): _holderProject.AddProjects([projectLib]) return projectLib
def patch_b3_admin_plugin(self): """ Monkey patches the admin plugin """ def new_cmd_kick(this, data, client=None, cmd=None): """ <name> [<reason>] - kick a player <fullexactname> [<reason>] - kick an incompletely authed player """ m = this.parseUserCmd(data) if not m: client.message('^7Invalid parameters') return False cid, keyword = m reason = this.getReason(keyword) if not reason and client.maxLevel < this._noreason_level: client.message('^1ERROR: ^7You must supply a reason') return False sclient = this.findClientPrompt(cid, client) if sclient: if sclient.cid == client.cid: this.console.say( self.getMessage('kick_self', client.exactName)) return True elif sclient.maxLevel >= client.maxLevel: if sclient.maskGroup: client.message( '^7%s ^7is a masked higher level player, can\'t kick' % sclient.exactName) else: message = this.getMessage('kick_denied', sclient.exactName, client.exactName, sclient.exactName) this.console.say(message) return True else: sclient.kick(reason, keyword, client) return True elif re.match('^[0-9]+$', cid): # failsafe, do a manual client id kick this.console.kick(cid, reason, client) else: this.console.kickbyfullname(cid, reason, client) admin_plugin = self.getPlugin('admin') command = admin_plugin._commands['kick'] command.func = new.instancemethod(new_cmd_kick, admin_plugin) command.help = new_cmd_kick.__doc__.strip()
def __getattr__(self, name): if name in self._symbols: raise AttributeError(name) if name in ('__members__', '__methods__'): raise AttributeError(name) if name == 'constructor': return PyV8.JSClassConstructor(self.__class__) if name == 'prototype': return PyV8.JSClassPrototype(self.__class__) prop = self.__dict__.setdefault('__properties__', {}).get(name, None) if prop and isinstance(prop[0], collections.Callable): return prop[0]() context = self.__class__.__dict__['context'].__get__(self, Window) try: self._symbols.add(name) symbol = context.eval(name) except: raise AttributeError(name) finally: self._symbols.discard(name) if isinstance(symbol, PyV8.JSFunction): _method = None if symbol in self._methods: _method = symbol.clone() if _method is None: _method = new.instancemethod(symbol, self, Window) #_method = symbol.__get__(self, Window) setattr(self, name, _method) context.locals[name] = _method return _method if isinstance(symbol, (thug_string, bool, numbers.Number, datetime.datetime, PyV8.JSObject)): setattr(self, name, symbol) context.locals[name] = symbol return symbol raise AttributeError(name)
def __call__(self, *args, **kwargs): # @DontTrace ''' Calls every registered function with the given args and kwargs. ''' callbacks = self._callbacks if not callbacks: return # Note: There's a copy of this code in the _calculate_to_call method below. It's a copy # because we don't want to had a function call overhead here. to_call = [] for key, info in compat.items(callbacks): # iterate in a copy func_obj = info[0] if func_obj is not None: # Ok, we have a self. func_obj = func_obj() if func_obj is None: # self is dead del callbacks[key] else: func_func = info[1] if func_func is None: to_call.append(func_obj) else: if compat.PY2: to_call.append( new.instancemethod(func_func, func_obj, info[2])) else: to_call.append(new.MethodType(func_func, func_obj)) else: func_func = info[1] # No self: either classmethod or just callable to_call.append(func_func) # let's keep the 'if' outside of the iteration... if not is_in_main_thread(): for func in to_call: if not getattr(func, '__call_out_of_main_thread__', False): raise AssertionError( 'Call: %s out of the main thread (and it is not marked as @not_main_thread_callback)!' % (func, )) for func in to_call: try: func(*args, **kwargs) except Exception: # Show it but don't propagate. sys.excepthook(*sys.exc_info())
def replaceMethod(self, oldMethod, newFunction): foundIt = 0 import new for cdc in self.number2cdc.values(): for cdu in cdc.allCDU: method = cdu.func if method and method.im_func == oldMethod: newMethod = new.instancemethod(newFunction, method.im_self, method.im_class) cdu.func = newMethod foundIt = 1 return foundIt
def loadepg(self, result, retval, extra_args): if retval is 0: epgcache = new.instancemethod(_enigma.eEPGCache_load, None, eEPGCache) epgcache = eEPGCache.getInstance().load() self.mbox = self.session.open(MessageBox, (_("EPG downloaded")), MessageBox.TYPE_INFO, timeout=4) else: self.mbox = self.session.open(MessageBox, (_("Sorry, the EPG download error")), MessageBox.TYPE_INFO, timeout=4)
def boundNewCommand(self, cmdName): """ At construction, all existing commands are bound directly in the class. This method enables to bound new commands dynamically. These new bounds are not made with the class, but directly with the object instance. """ if (cmdName in self.__dict__) | (cmdName in self.__class__.__dict__): print("Warning: command ", cmdName, " will overwrite an object attribute.") docstring = wrap.entity_get_command_docstring(self.obj, cmdName) cmd = Entity.createCommandBind(cmdName, docstring) # Limitation (todo): does not handle for path attribute name (see setattrpath). setattr(self, cmdName, new.instancemethod(cmd, self, self.__class__))
def create_merger(self): if isinstance(self.merge_strategy, type): merge_strategy = object.__new__(self.merge_strategy) merge_strategy.__init__() else: merge_strategy = self.merge_strategy merger = merge_strategy.create_merger() merger.log = self.log wrapped_merge_func = self.create_handle_module_func( merger.handle_module) setattr(merger, 'handle_module', new.instancemethod(wrapped_merge_func, merger, None)) return merger
def _test(self, tocheck): if INFO_TEST_RGX.match(self.module): self.linter.enable_message_category('I') else: self.linter.disable_message_category('I') try: self.linter.check(tocheck) except Exception, ex: # need finalization to restore a correct state self.linter.reporter.finalize() ex.file = tocheck ex.__str__ = new.instancemethod(exception_str, ex, None) raise
def new(uri): """ constructor """ uri = quote(URIRef(uri)) name = getLocalName(uri) cls = OWLDatatypeProperty(name, (), {'uri': uri, 'name': name}) #add the appropriate class method cls.getURI = instancemethod(getURI, cls) return cls
def _enable_autopx(self): """Enable %autopx mode by saving the original runsource and installing pxrunsource. """ try: activeController = __IPYTHON__.activeController except AttributeError: print "No active RemoteController found, use RemoteController.activate()." else: self._original_runsource = self.runsource self.runsource = new.instancemethod(pxrunsource, self, self.__class__) self.autopx = True print "Auto Parallel Enabled\nType %autopx to disable"
def _monkeypatchWCS(wcsObj, naxis, wcsFields): """monkeypatches pywcs instances for DaCHS' purposes. """ wcsObj._dachs_header = wcsFields wcsObj.longAxis = naxis[0] if len(naxis) > 1: wcsObj.latAxis = naxis[1] wcsObj._monkey_naxis_lengths = [ wcsFields.get("NAXIS%d" % i) for i in naxis ] wcsObj.origCalcFootprint = wcsObj.calcFootprint wcsObj.calcFootprint = new.instancemethod(_calcFootprintMonkeypatch, wcsObj, wcsObj.__class__)
def __call__(self, *args, **kwArgs): s = self.instance() if s is None: if "fallbackResult" in self.__kw: return self.__kw["fallbackResult"] else: raise ReferenceError( "Instance referenced by WeakMethod %s.%s() no longer exists" % (self.__method.__module__, self.__method.__name__)) m = new.instancemethod(self.__method, s, s.__class__) return m(*args, **kwArgs)
def setup_admonitions_handlers(self): """ Admonitions are handled here... We basically surround admonitions in a div with class admonition_{name of the admonition}. """ handled_admonitions = [ 'attention', 'caution', 'danger', 'error', 'hint', 'important', 'note', 'tip', 'warning', ] for adm in handled_admonitions: visit_func, depart_func = self.create_admonition_functor(adm) visit_func = new.instancemethod(visit_func, self, MoinTranslator) depart_func = new.instancemethod(depart_func, self, MoinTranslator) setattr(self, 'visit_%s' % (adm), visit_func) setattr(self, 'depart_%s' % (adm), depart_func)
def __getattr__(self, aname): if self.debug: print "Waiting on future" self.event.wait() if self.exception is not None: raise FutureException, self.exception[0], self.exception[1] target = self.target f = getattr(target, aname) if isinstance(f, MethodType): # Rebind the method to the target. return new.instancemethod(f.im_func, self, target.__class__) else: return f
def __call__(self): '''Return a new bound-method like the original, or the original function if it was just a function or unbound method. Returns None if the original object doesn't exist. ''' if self.is_dead(): return None if self._obj is not None: return new.instancemethod(self._func, self._obj(), self._class) else: # we don't have an instance: return just the function return self._func
def setup_overrides(self, f_name, f_class): if not f_name in f_class.__dict__: # If the function is defined in a parent, bind a call to function in the superclass self.original = new.instancemethod( lambda self, *args, **named: getattr(super( f_class, self), f_name).__call__(*args, **named), None, f_class) self.is_derived = True else: self.original = getattr(f_class, f_name) self.is_derived = False # Install the stacked function setattr(f_class, f_name, self)
def _utc(self): UTC = FixedOffsetTimezone(0, 'UTC') def fake_localize(self, dt, is_dst=False): raise NotImplementedError() try: import new UTC.localize = new.instancemethod(fake_localize, UTC, UTC.__class__) except ImportError: import functools UTC.localize = functools.partial(fake_localize, UTC) # This is important to trigger the actual bug (#257) self.assertEqual(False, hasattr(UTC, 'normalize')) return UTC
def _add_unpickler(self, klass, module, name): """ Modifies the specified class so that our 'modify_state' method is called when its next instance is unpickled. """ logger.debug('Adding unpickler hook to [%s]', klass) # Replace the existing setstate method with ours. self._backup_setstate(klass) m = new.instancemethod(__replacement_setstate__, None, klass) setattr(klass, _SETSTATE_NAME, m) # Add the information necessary to allow this unpickler to run setattr(klass, _UNPICKLER_DATA, (self, module, name))
def _makeOrder(self): #emsg, asFix = IntegrityTester._makeOrder(self) msg = makeOrder(fix) import new # Slot in a new compile method for one invocation oldCompiler = self.initiatorSession.compile_message self.initiatorSession.compile_message = new.instancemethod( compileMessageOmitSequenceNumber, self.initiatorSession) strMsg = self.initiatorSession.compile_message(msg, disableValidation=True) # Return to original state self.initiatorSession.compile_message = oldCompiler return msg, strMsg
def __fill_callbacks(handlers, kind, callbacks): members = kind.__dict__ for name in members: if name.startswith('on_') and not name in callbacks: value = members[name] import types if type(value) == types.FunctionType: import new callbacks[name] = new.instancemethod(value, handlers, handlers.__class__) for base in kind.__bases__: __fill_callbacks(handlers, base, callbacks)
def go_continue(self, ret): try: if os.path.exists('/usr/bin/enigma2.sh'): content = open('/usr/bin/enigma2.sh', 'r').read() m = re.search('epg.dat', content) if not m: os.system( "cp /usr/bin/enigma2.sh /usr/bin/enigma2.sh.xmltvbak") line_number = 2 with open('/usr/bin/enigma2.sh') as f: lines = f.readlines() lines.insert( line_number, '[ -f /media/hdd/epg_new.dat ] && cp /media/hdd/epg_new.dat /media/hdd/epg.dat\n' ) with open('/usr/bin/enigma2.sh', 'w') as f: f.writelines(lines) lang = self["menu"].l.getCurrentSelection()[1] ret = os.system( "wget -q http://linux-sat.tv/epg/epg_%s.dat.gz -O /hdd/epg_new.dat.gz" % (lang)) if ret: self.mbox = self.session.open(MessageBox, (_( "Sorry, the EPG download error. Try again later or check your internet connection" )), MessageBox.TYPE_INFO, timeout=6) return os.system("gzip -df /hdd/epg_new.dat.gz") os.system("cp -f /hdd/epg_new.dat /hdd/epg.dat") os.system("rm -f epg_new.dat.gz") self.mbox = self.session.open(MessageBox, (_("the EPG download is complete")), MessageBox.TYPE_INFO, timeout=4) except: self.mbox = self.session.open(MessageBox, (_("Error")), MessageBox.TYPE_INFO, timeout=4) try: epgcache = new.instancemethod(_enigma.eEPGCache_load, None, eEPGCache) epgcache = eEPGCache.getInstance().load() self.close() except: restartbox = self.session.openWithCallback(self.restartGUI, MessageBox, _("Restart GUI now?"), MessageBox.TYPE_YESNO) restartbox.setTitle(_("Restart GUI now?"))
def save(self): config.misc.epgcache_filename.value = '%sepg.dat' % config.misc.epgcachepath.value config.misc.epgcache_filename.save() config.misc.epgcachepath.save() epgcache = new.instancemethod(_enigma.eEPGCache_save, None, eEPGCache) epgcache = eEPGCache.getInstance().save() config.plugins.ldteam.epgmhw2wait.save() config.epg.save() config.epg.maxdays.save() configfile.save() self.mbox = self.session.open(MessageBox, _('configuration is saved'), MessageBox.TYPE_INFO, timeout=4)
def watchObject(self, object, identifier, callback): """Watch the given object. Whenever I think the object might have changed, I'll send an ObjectLink of it to the callback. The identifier argument is used to generate identifiers for objects which are members of this one. """ if type(object) is not types.InstanceType: raise TypeError, "Sorry, can only place a watch on Instances." # uninstallers = [] dct = {} reflect.addMethodNamesToDict(object.__class__, dct, '') for k in object.__dict__.keys(): dct[k] = 1 members = dct.keys() clazzNS = {} clazz = new.classobj( 'Watching%s%X' % (object.__class__.__name__, id(object)), ( _MonkeysSetattrMixin, object.__class__, ), clazzNS) clazzNS['_watchEmitChanged'] = new.instancemethod( lambda slf, i=identifier, b=self, cb=callback: cb( b.browseObject(slf, i)), None, clazz) # orig_class = object.__class__ object.__class__ = clazz for name in members: m = getattr(object, name) # Only hook bound methods. if ((type(m) is types.MethodType) and (m.im_self is not None)): # What's the use of putting watch monkeys on methods # in addition to __setattr__? Well, um, uh, if the # methods modify their attributes (i.e. add a key to # a dictionary) instead of [re]setting them, then # we wouldn't know about it unless we did this. # (Is that convincing?) monkey = _WatchMonkey(object) monkey.install(name)