def __getattribute__(self, k): """ Overwride getattribute for multiplex ports. If we try to get a port for which a multiplex port is a prefix, create the port object and then return it. """ # handle regular properties or internal methods normally if k in ['_portnames', '_task_name', 'get_matching_multiplex_port'] or k.startswith('__'): return object.__getattribute__(self, k) # if this port already exists, retrieve it if k in self._portnames: return object.__getattribute__(self, k) # determine if we're trying to get the value for a multiplex output port if not k in self._portnames: mp_port = self.get_matching_multiplex_port(k) if mp_port: self.__setattr__( k, Port( mp_port.name, mp_port.type, mp_port.required, mp_port.description, value="source:" + self._task_name + ":" + k, is_input_port=False, is_multiplex=False ) ) self._portnames.update([k]) return object.__getattribute__(self, k)
def _resolve(self): """Return the real object for which this is a placeholder""" name = object.__getattribute__(self, '_name') real_obj = object.__getattribute__(self, '_real_obj') if real_obj is None: # No obj generated previously, so generate from factory and scope. factory = object.__getattribute__(self, '_factory') scope = object.__getattribute__(self, '_scope') obj = factory(self, scope, name) if obj is self: raise errors.IllegalUseOfScopeReplacer(name, msg="Object tried" " to replace itself, check it's not using its own scope.") # Check if another thread has jumped in while obj was generated. real_obj = object.__getattribute__(self, '_real_obj') if real_obj is None: # Still no prexisting obj, so go ahead and assign to scope and # return. There is still a small window here where races will # not be detected, but safest to avoid additional locking. object.__setattr__(self, '_real_obj', obj) scope[name] = obj return obj # Raise if proxying is disabled as obj has already been generated. if not ScopeReplacer._should_proxy: raise errors.IllegalUseOfScopeReplacer( name, msg="Object already replaced, did you assign it" " to another variable?") return real_obj
def _resolve(self): """Return the real object for which this is a placeholder""" name = object.__getattribute__(self, '_name') real_obj = object.__getattribute__(self, '_real_obj') if real_obj is None: # No obj generated previously, so generate from factory and scope. factory = object.__getattribute__(self, '_factory') scope = object.__getattribute__(self, '_scope') obj = factory(self, scope, name) if obj is self: raise ValueError(name, msg="Object tried" " to replace itself, check it's not using its own scope.") # Check if another thread has jumped in while obj was generated. real_obj = object.__getattribute__(self, '_real_obj') if real_obj is None: # Still no preexisting obj, so go ahead and assign to scope and # return. There is still a small window here where races will # not be detected, but safest to avoid additional locking. object.__setattr__(self, '_real_obj', obj) scope[name] = obj return obj # Raise if proxying is disabled as obj has already been generated. if not ScopeReplacer._should_proxy: raise ValueError( name, msg="Object already replaced, did you assign it" " to another variable?") return real_obj
def _import(self, scope, name): children = object.__getattribute__(self, '_import_replacer_children') member = object.__getattribute__(self, '_member') module_path = object.__getattribute__(self, '_module_path') module_python_path = '.'.join(module_path) if member is not None: module = __import__(module_python_path, scope, scope, [member], level=0) return getattr(module, member) else: module = __import__(module_python_path, scope, scope, [], level=0) for path in module_path[1:]: module = getattr(module, path) # Prepare the children to be imported for child_name, (child_path, child_member, grandchildren) in \ children.items(): # Using self.__class__, so that children get children classes # instantiated. (This helps with instrumented tests) cls = object.__getattribute__(self, '__class__') cls(module.__dict__, name=child_name, module_path=child_path, member=child_member, children=grandchildren) return module
def __getattr__(self, name): if TASK_SERVER.ENABLED.get() and hasattr(ntasks, name): attr = object.__getattribute__(ntasks, name) def _method(*args, **kwargs): return attr(*args, **dict(kwargs, postdict=self.request.POST, user_id=self.request.user.id)) return _method else: return object.__getattribute__(self.api, name)
def __setattr__(self, attr, value): try: # Check that the object itself has this attribute. object.__getattribute__(self, attr) return object.__setattr__(self, attr, value) except AttributeError: self.Set(attr, value)
def __setattr__(self, key, value): try: object.__getattribute__(self, key) object.__setattr__(self, key, value) except AttributeError: if not self.cfg.has_section(self.section): self.cfg.add_section(self.section) self.cfg.set(self.section, key, value)
def __getattribute__(self, name): """ 2012.11.24 """ try: returnAttr = object.__getattribute__(self, name) except AttributeError: attributeName2Index = object.__getattribute__(self, 'attributeName2Index') index = attributeName2Index.get(name, None) if index is not None: returnAttr = self.__getitem__(index) else: returnAttr = None return returnAttr
def __getattr__(self, val): if val == "Attributes": attrs = {} #materializing dynamic properties and adding them to main dictionary for attr in self.__attributes__: if type( self.__attributes__[attr] ) == types.NoneType: #skipping all attributes that are empty pass elif type(self.__attributes__[attr]) in [ types.MethodType, types.FunctionType ]: try: attrs[attr] = self.__attributes__[attr]() except: #in case function relies on external object that has not been initialized yet pass else: attrs[attr] = self.__attributes__[attr] return attrs elif val in self.__attributes__: if type(self.__attributes__[val]) in [ types.MethodType, types.FunctionType ]: return self.__attributes__[val]() else: return self.__attributes__[val] else: return object.__getattribute__(self, val) raise AttributeError("Property: %s does not exist" % val)
def __getattribute__(self, name): if name == "_d" or len(self._d) == 0 or name not in self._d: return object.__getattribute__(self, name) if self._lockOnRead and not self._is_owned(): raise AttributeError("%s: lock required for read access" % name) return self._d[name]
def __getattribute__(self, item): # White list of available attributes if item in ["__deepcopy__", "to_pandas"]: return object.__getattribute__(self, item) raise InvalidPSFError("Trying to use an invalid PSF")
def __getattr__(self, bandname): """ Override _gettattr__() for bandnames in self.bandlabels. """ if bandname in self.bandlabels: return self.dataobj['All_Data/' + self.bandlabels[bandname]] else: return object.__getattribute__(self, bandname)
def __getattr__(self, name): # Special methods which may be accessed before the object is # fully constructed (e.g. in unpickling). if name[:2] == name[-2:] == '__': return object.__getattribute__(self, name) elif name in self._visible_option_list(): return self._all_options[name] else: raise AttributeError("'%s' object has no attribute '%s'" % (type(self).__name__, name))
def __setattr__(self, name, value): """ 2012.11.24 """ try: attributeName2Index = object.__getattribute__(self, 'attributeName2Index') attributeName2Index[name] = len(self) self.append(value) except AttributeError: object.__setattr__(self, name, value)
def __getattr__(self, name): # Special methods which may be accessed before the object is # fully constructed (e.g. in unpickling). if name[:2] == name[-2:] == '__': return object.__getattribute__(self, name) elif name in self._visible_option_list(): return self._all_options.get(name, getattr(self._visible_options, name)) else: raise AttributeError("'%s' object has no attribute '%s'" % (type(self).__name__, name))
def __getattribute__(self, name): attr = object.__getattribute__(self, name) if name.startswith('_') or not callable(attr): return attr @lock def wrapper(*args, **kwargs): return attr(*args[1:], **kwargs) return wrapper
def __getattribute__(self, key): common = object.__getattribute__(self, 'common_keys') mapped = object.__getattribute__(self, 'mapped_keys') if key in mapped: lk, maker = mapped[key] if self._legacy: if lk is None: result = None if maker is None else maker() else: result = self._legacy.get(lk) else: value = None if maker is None else maker() if key not in ('commands', 'exports', 'modules', 'namespaces', 'classifiers'): result = self._data.get(key, value) else: # special cases for PEP 459 sentinel = object() result = sentinel d = self._data.get('extensions') if d: if key == 'commands': result = d.get('python.commands', value) elif key == 'classifiers': d = d.get('python.details') if d: result = d.get(key, value) else: d = d.get('python.exports') if not d: d = self._data.get('python.exports') if d: result = d.get(key, value) if result is sentinel: result = value elif key not in common: result = object.__getattribute__(self, key) elif self._legacy: result = self._legacy.get(key) else: result = self._data.get(key) return result
def __getattribute__(self, name): try: # If we have this attr, use it. # (e.g. self.mp_file, self._internal_path, etc.) return object.__getattribute__(self, name) except: # Briefly open the file and read the attribute directly from h5py with h5py.File(self.mp_file._filepath, "r") as f: val = getattr(f[self._internal_path], name) assert not callable(val), "MultiprocessingHdf5File Groups cannot provide access to callable items." return copy.copy(val)
def __getattribute__(self, name): try: # If we have this attr, use it. # (e.g. self.mp_file, self._internal_path, etc.) return object.__getattribute__(self, name) except: # Briefly open the file and read the attribute directly from h5py with h5py.File(self.mp_file._filepath) as f: val = getattr(f[self._internal_path], name) assert not callable(val), "MultiprocessingHdf5File Groups cannot provide access to callable items." return copy.copy(val)
def __getattribute__(self, item): if '.' in item: parts = item.split('.') field = Entity.__getattribute__(self, parts[0]) if isinstance(field, list): array = field return [getattr(a, parts[1]) for a in array] else: return getattr(field, parts[1]) else: return object.__getattribute__(self, item)
def __init__(self, *args, **kwargs): """ Sets up the objects' internal column. Tests for the presence of a primary key, and attempts to load a description using it. """ if 'config' in kwargs: config = kwargs['config'] del (kwargs['config']) else: config = None if 'handle' in kwargs: handle = kwargs['handle'] del (kwargs['handle']) else: handle = None if args or kwargs: d_out("SimpleModel.__init__: Got args of %s" % repr(args)) d_out("SimpleModel.__init__: Got kwargs of %s" % repr(kwargs)) # # If the type defines a base type, the base instance will be # passed in the 'base_' kwarg: merge the base attrs into # kwargs and hand over to superclass. # SimpleModel.merge_base_attrs(kwargs) # # Initialize table attrs by copying from keyword arguments. # # This makes sure the objects not loaded from DB has at least # the None values in attrs and access to them doesn't raise. # if hasattr(self, 'table'): for name in self.table: self.__dict__[name] = kwargs.get(name, None) # should automatically pick up config= and handle= super(SimpleModel, self).__init__(config, handle, *args, **kwargs) if hasattr(self, 'loaded_indicator') and self.__dict__.get( object.__getattribute__(self, 'loaded_indicator')) is not None: self._loaded = True else: self._loaded = False # config and handle have been dealt with, now. if not self._loaded and hasattr(self, '__load__'): if args or kwargs: self.__load_by_key__(*args, **kwargs)
def __init__(self, *args, **kwargs): """ Sets up the objects' internal column. Tests for the presence of a primary key, and attempts to load a description using it. """ if 'config' in kwargs: config = kwargs['config'] del(kwargs['config']) else: config = None if 'handle' in kwargs: handle = kwargs['handle'] del(kwargs['handle']) else: handle = None if args or kwargs: d_out("SimpleModel.__init__: Got args of %s" % repr(args)) d_out("SimpleModel.__init__: Got kwargs of %s" % repr(kwargs)) # # If the type defines a base type, the base instance will be # passed in the 'base_' kwarg: merge the base attrs into # kwargs and hand over to superclass. # SimpleModel.merge_base_attrs(kwargs) # # Initialize table attrs by copying from keyword arguments. # # This makes sure the objects not loaded from DB has at least # the None values in attrs and access to them doesn't raise. # if hasattr(self, 'table'): for name in self.table: self.__dict__[name] = kwargs.get(name, None) # should automatically pick up config= and handle= super(SimpleModel, self).__init__(config, handle, *args, **kwargs) if hasattr(self, 'loaded_indicator') and self.__dict__.get(object.__getattribute__(self, 'loaded_indicator')) is not None: self._loaded = True else: self._loaded = False # config and handle have been dealt with, now. if not self._loaded and hasattr(self, '__load__'): if args or kwargs: self.__load_by_key__(*args, **kwargs)
def __delattr__(self, name): """ 2012.11.24 """ try: attributeName2Index = object.__getattribute__(self, 'attributeName2Index') index = attributeName2Index.get(name, None) if index is not None: del attributeName2Index[name] list.__delitem__(self, index) #self.pop(index) except AttributeError: object.__delattr__(self, name)
def __getitem__(self, index_or_key): """ 2012.12.20 enable it to retrieve item using either index or attributeName (like a dictionary). i.e. pdata[0] or pdata['chromosome'] is equivalent if attribute 0 is chromosome. """ if type(index_or_key)==int: return list.__getitem__(self, index_or_key) else: attributeName2Index = object.__getattribute__(self, 'attributeName2Index') index = attributeName2Index.get(index_or_key, None) return list.__getitem__(self, index)
def section_(self, sectionName): """ _section_ Get a section by name, create it if not present, returns a ConfigSection instance """ if sectionName in self.__dict__: return self.__dict__[sectionName] newSection = ConfigSection(sectionName) self.__setattr__(sectionName, newSection) return object.__getattribute__(self, sectionName)
def __setattr__(self, key, value): self._validate_value(key, value) common = object.__getattribute__(self, 'common_keys') mapped = object.__getattribute__(self, 'mapped_keys') if key in mapped: lk, _ = mapped[key] if self._legacy: if lk is None: raise NotImplementedError self._legacy[lk] = value elif key not in ('commands', 'exports', 'modules', 'namespaces', 'classifiers'): self._data[key] = value else: # special cases for PEP 459 d = self._data.setdefault('extensions', {}) if key == 'commands': d['python.commands'] = value elif key == 'classifiers': d = d.setdefault('python.details', {}) d[key] = value else: d = d.setdefault('python.exports', {}) d[key] = value elif key not in common: object.__setattr__(self, key, value) else: if key == 'keywords': if isinstance(value, string_types): value = value.strip() if value: value = value.split() else: value = [] if self._legacy: self._legacy[key] = value else: self._data[key] = value
def __getattribute__(self, name): try: methods = object.__getattribute__(self, 'methods') except AttributeError: pass else: if name in methods: f = lambda *args, **kwargs: self._scrape(name, *args, **kwargs) f.__name__ = name f.__doc__ = getattr(next(self.iterscrapers(name)), name).__doc__ return f return super(Scrape, self).__getattribute__(name)
def __getattribute__(self, name): try: # If we have this attr, use it. # (e.g. self.mp_file, self._internal_path, etc.) return object.__getattribute__(self, name) except: # Briefly open the file and read the attribute directly from h5py with h5py.File(self.mp_file._filepath, "r") as f: val = getattr(f[self._internal_path], name) assert not callable(val), "MultiprocessingHdf5File Datasets cannot provide access to callable items." # Special case: copy hdf5 dataset attrs into a dict if name == "attrs": val = dict(list(val.items())) return val
def __getattribute__(self, name): try: # If we have this attr, use it. # (e.g. self.mp_file, self._internal_path, etc.) return object.__getattribute__(self, name) except: # Briefly open the file and read the attribute directly from h5py with h5py.File(self.mp_file._filepath) as f: val = getattr(f[self._internal_path], name) assert not callable(val), "MultiprocessingHdf5File Datasets cannot provide access to callable items." # Special case: copy hdf5 dataset attrs into a dict if name == "attrs": val = dict(list(val.items())) return val
def __delitem__(self, indexToDelete): """ 2012.11.24 """ list.__delitem__(self, indexToDelete) try: attributeName2Index = object.__getattribute__(self, 'attributeName2Index') attributeToBeDeleted = None for attributeName, index in attributeName2Index.items(): if index==indexToDelete: attributeToBeDeleted = attributeName break if attributeToBeDeleted is not None: del attributeName2Index[attributeToBeDeleted] except AttributeError: pass
def select(objs, attrs): '''a generator which computes the actual results''' def add(queue, u, v, i): '''adds the object v to the queue. It looks like u isn't necessary anymore. I should fix that...''' args = (v, '_objquery__i', i+1) try: object.__setattr__(*args) except TypeError: setattr(*args) except: raise queue.appendleft(v) queue = deque() add(queue, None, type('base', (object,), objs), -1) while len(queue) > 0: u = queue.pop() i = object.__getattribute__(u, '_objquery__i') attrname, where = attrs[i] if hasattr(u, attrname): # the current object has the attr v = getattr(u, attrname) #it is iterable if not isinstance(v, str) and hasattr(v, '__iter__'): for z in v: # add each child into the processing queue if isinstance(v, dict): next = KeyValuePair(z, v[z]) else: next = z # but only if its where condition is satisfied if where != None: cobjs = dict(objs) cobjs.update({'self':next}) if not where(cobjs): continue # if this is the last attribute yield the obj if i+1 == len(attrs): yield next else: add(queue, u, next, i) # otherwise add to the queue else: #it is not iterable if where != None: cobjs = dict(objs) cobjs.update({'self':v}) if not where(cobjs): continue # if this is the last attribute yield the obj if i+1 == len(attrs): yield v else: add(queue, u, v, i) # otherwise add to the queue
def __init__(self, scope, name, module_path, member=None, children={}): """Upon request import 'module_path' as the name 'module_name'. When imported, prepare children to also be imported. :param scope: The scope that objects should be imported into. Typically this is globals() :param name: The variable name. Often this is the same as the module_path. 'bzrlib' :param module_path: A list for the fully specified module path ['bzrlib', 'foo', 'bar'] :param member: The member inside the module to import, often this is None, indicating the module is being imported. :param children: Children entries to be imported later. This should be a map of children specifications. :: {'foo':(['bzrlib', 'foo'], None, {'bar':(['bzrlib', 'foo', 'bar'], None {})}) } Examples:: import foo => name='foo' module_path='foo', member=None, children={} import foo.bar => name='foo' module_path='foo', member=None, children={'bar':(['foo', 'bar'], None, {}} from foo import bar => name='bar' module_path='foo', member='bar' children={} from foo import bar, baz would get translated into 2 import requests. On for 'name=bar' and one for 'name=baz' """ if (member is not None) and children: raise ValueError('Cannot supply both a member and children') object.__setattr__(self, '_import_replacer_children', children) object.__setattr__(self, '_member', member) object.__setattr__(self, '_module_path', module_path) # Indirecting through __class__ so that children can # override _import (especially our instrumented version) cls = object.__getattribute__(self, '__class__') ScopeReplacer.__init__(self, scope=scope, name=name, factory=cls._import)
def __setattr__(self, attr, value): obj = object.__getattribute__(self, '_resolve')() return setattr(obj, attr, value)
def __call__(self, *args, **kwargs): obj = object.__getattribute__(self, '_resolve')() return obj(*args, **kwargs)
def __getattribute__(self, attr): if attr in ['from_file', 'from_string']: return self.__get_wrapped_with_postprocessors( object.__getattribute__(self, attr)) return object.__getattribute__(self, attr)
def __getattr__(self, name): # Any enchant we haven't assigned a value to, we don't have. if name in self.allowed_melee_enchants: return False object.__getattribute__(self, name)
def __getattribute__(self, attr): if attr in ['from_file', 'from_string']: return self.__get_wrapped_with_postprocessors(object.__getattribute__(self, attr)) return object.__getattribute__(self, attr)
def __getattr__(self, item): return getattr(object.__getattribute__(self, "_default_fs"), item)
def __getattr__(self, name): object.__getattribute__(self, name)
def __getattr__(self, name): # Any racial we haven't assigned a value to, we don't have. if name in self.allowed_racials: return False else: object.__getattribute__(self, name)
def __getattribute__(self, attr): obj = object.__getattribute__(self, '_resolve')() return getattr(obj, attr)
def __getattribute__(self,name): """ Private method. This function tests all attributes of the *SimpleModel* if they are instances of *meta_query*. If they are a *meta_query*, columns from the Model are mapped to the InstanceMethods' arguments, as appropriate. """ attr = object.__getattribute__(self,name) if name == '__load__': d_out("skipping: %s" % name) return attr if attr is None and name in object.__getattribute__(self, 'table') and not object.__getattribute__(self,'_loaded'): should_lazyload = hasattr(self,'__lazyload__') else: should_lazyload = False if should_lazyload: d_out("lazyloading {0} on {1}".format(self.__class__, name)) attrs = object.__getattribute__(self, '__dict__') attrs['_loaded'] = True rs = self.__lazyload__(options={'handle':self.handle}) if not rs: raise NotFoundError("__lazyload__ returned: {0}".format(rs)) if isinstance(rs, psycopg2.extras.DictRow): loaded_attrs = dict(rs) elif isinstance(rs, SimpleModel): #python 2.7+: #loaded_attrs = {_ for _ in rs.__dict__.iteritems() if _[0] in self.table} loaded_attrs = {} for col in self.table: loaded_attrs[col] = rs.__dict__[col] else: raise Exception("__lazyload__ returned unexpected type: {0}".format(type(rs))) SimpleModel.merge_base_attrs(loaded_attrs) attrs.update(loaded_attrs) return attrs[name] if isinstance(attr, meta_query): d_out("SimpleModel.__getattribute__: Found meta_query %s" % name) def instance(*args,**kwargs): if args: raise FunctionError("This function can only take keyword arguments.") my_args = kwargs.copy() d_out("SimpleModel.__getattribute__ InstanceMethod: kwargs: %s" % repr(kwargs)) d_out("SimpleModel.__getattribute__ InstanceMethod: self.__dict__: %s" % self.__dict__) for arg in attr.args: d_out("SimpleModel.__getattribute__ InstanceMethod: checking arg %s" % arg) if arg not in kwargs: d_out("not in my_args") if hasattr(self, arg): d_out("SimpleModel.__getattribute__ InstanceMethod: found %s in col.." % arg) my_args[arg] = getattr(self, arg) else: my_args[arg] = None if 'options' not in kwargs: d_out("SimpleModel.__getattribute__ InstanceMethod: Didn't find options.") my_args['options'] = {} # pass self to the query object my_args['options']['model'] = self d_out("SimpleModel.__getattribute__: InstanceMethod: Setting handle.") my_args['options']['handle'] = self.handle rs = attr(*args, **my_args) d_out("SimpleModel.__getattribute__: InstanceMethod: model :{model} attrib name: {name} (attrib value: {value}) constructor returned {rs}".format(model=self, name=name, value=attr, rs=rs)) return rs if attr.is_property: return instance() else: return instance else: return attr
def __getattr__(self, proc): # Any proc we haven't assigned a value to, we don't have. if proc in self.allowed_procs: return False object.__getattribute__(self, proc)
def __getattr__(self, name): # If someone tries to access a talent not initialized (the talent # string was shorter than 6) we return False if name in self.allowed_talents: return False object.__getattribute__(self, name)
def __getattr__(self, name): # Any gear buff we haven't assigned a value to, we don't have. if name in self.allowed_buffs: return False object.__getattribute__(self, name)
def __getattr__(self, key): if key in self: return self[key] else: return object.__getattribute__(self, key)
def __getattribute__(self, name): return object.__getattribute__(self, name)
def __getattribute__(self, name): if name in _StandaloneSSLConnection._OVERRIDDEN_ATTRIBUTES: return object.__getattribute__(self, name) return self._connection.__getattribute__(name)
def __getattribute__(self, name): return evernote_wait_try_again( getattr(object.__getattribute__(self, "_obj"), name))