def __setattr__(self, key, value): if "_flags" not in self.__dict__: object.__setattr__(self, key, value) elif key in self.__dict__: object.__setattr__(self, key, value) else: self.__setitem__(key, value)
def __setattr__(self, name, value): if name in self.__fields__: object.__setattr__(self, name, value) else: self.__values__[name] = value self.__flex_fields__.add(name) self.__changes__.add(name)
def __setattr__(self, attr, value): if attr == "playlist": self.clearPlaylist() [self.enqueueFile(item.filename) for item in value] else: object.__setattr__(self, attr, value)
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 __setattr__(self, name, value): if name in self.__fields__: object.__setattr__(self, name, value) else: self.__values__[name] = value self.__flex_fields__.add(name) self.__changes__.add(name)
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 _set_parent(self, parent): # We need to use directly the __setattr__ method because the normal self._children = ... will trigger # an exception, because of the __setattr__ method of the DualAccessClass which forbids changing # nodes. However, this might reassign the parent to a class object.__setattr__(self, "_parent", parent)
def __init__(self, ns, wdir=None, datatype=None): self.ns = ns if wdir == None: self.wdir = os.getcwd() + '/' else: self.wdir = wdir if datatype == None: datatype = 'dbl' self.ext = datatype if self.ext == 'dbl': self.extsize = 8 if self.ext == 'flt': self.extsize = 4 if self.ext == 'vtk': self.extsize = 4 self.Header = {} try: self.GetParticleDataFileName() except (IOError): print("!ERROR! - Particle Data file not found : %s" % self.fname) else: if self.ext == 'vtk': Part_Data_dict = self.GetParticleDataVTK() else: self.ReadParticleFile() Part_Data_dict = self.GetParticleData() self.partdata_keys = [] for keys in Part_Data_dict: self.partdata_keys.append(keys) object.__setattr__(self, keys, Part_Data_dict.get(keys))
def __del__(self): if '_destroy' not in self.__dict__ or not self._destroy: return if '_handle' not in self.__dict__ or not self._handle: return self._free() object.__setattr__(self, '_handle', None)
def __setattr__(self, key, value): if not key.startswith('_'): self._row[key] = value if self._auto_update: self._row.update() else: object.__setattr__(self, key, value)
def __init__(self, **values): # Where the actual values are stored object.__setattr__(self, '__values__', {}) # List of field names that have changed object.__setattr__(self, '__changes__', set([])) self.update(values)
def __setattr__(self, name, value): """ Don't allow setting attributes that haven't been defined as fields. """ if name in self.__fields__: object.__setattr__(self, name, value) else: raise AttributeError('Field %r not defined.' % name)
def whereValue(val): ''' returns the results of a Value function. ''' def where(objs): return val(objs) object.__setattr__(where, '__objquery__', True) return where
def booleanexprValue(value1, op, value2): ''' returns the function which computes the result of boolean (and or) operation ''' def where(objs): return op(value1, value2, objs) object.__setattr__(where, '__objquery__', True) return where
def __init__(self, **values): # Where the actual values are stored object.__setattr__(self, '__values__', {}) # List of field names that have changed object.__setattr__(self, '__changes__', set([])) self.update(values)
def __setattr__(self, key, value): if key == '_meta_attributes': object.__setattr__(self, key, value) return if self._meta_attributes is None: raise t.FileModeError("File not writable, attribute cannot be set!") self._meta_attributes[key] = value
def __setattr__(self, name, value): """ Don't allow setting attributes that haven't been defined as fields. """ if name in self.__fields__: object.__setattr__(self, name, value) else: raise AttributeError('Field %r not defined.' % name)
def dictValue(pairs): ''' creates a dictionary from the passed pairs after evaluation. ''' def dictval(objs): return dict((name(objs), value(objs)) for name, value in pairs) object.__setattr__(dictval, '__objquery__', True) return dictval
def listValue(values): ''' creates a list from the pass objs after evaluation. ''' def listval(objs): return list(value(objs) for value in values) object.__setattr__(listval, '__objquery__', True) return listval
def booleanValue(val): ''' returns the function which booleanizes the result of the Value function ''' def where(objs): return bool(val(objs)) object.__setattr__(where, '__objquery__', True) return where
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 setexprValue2(s1, op, s2): ''' Returns a where function which returns the result of a set op set operation ''' def where(objs): return op(s1(objs), s2(objs)) object.__setattr__(where, '__objquery__', True) return where
def unaryexprValue(op, val): ''' returns the function which computes the result of boolean not operation ''' def where(objs): return op(val(objs)) object.__setattr__(where, '__objquery__', True) return where
def setValue(s1, op, s2): ''' Returns a Query function for the result of set operations (difference, union etc..) ''' def query(glbls): return op(s1(glbls), s2(glbls)) object.__setattr__(query, '__objquery__', True) return query
def setexprValue1(val, op, s): ''' Returns a where function which returns the result of a value in set operation ''' def where(objs): return op(val(objs), s(objs)) object.__setattr__(where, '__objquery__', True) return where
def arithValue(value1, op, value2): ''' Returns a function which will calculate a where expression for a basic arithmetic operation. ''' def arith_value(objs): return op(value1(objs), value2(objs)) object.__setattr__(arith_value, '__objquery__', True) return arith_value
def comparisonValue(value1, op, value2): ''' Returns a function which will calculate a where expression for a basic comparison operation. ''' def where(objs): return op(value1(objs), value2(objs)) object.__setattr__(where, '__objquery__', True) return where
def __setattr__(self, attr, value): """ This prevents us from accidentally writing to a non-existant attribute. e.g. if the user tries to say components.fIlEnAmE = 'newfile.h5', raise an error. """ if hasattr(self, "_initialized"): # Attempt to get the old attribute first oldval = getattr(self, attr) object.__setattr__(self, attr, value)
def __setattr__(self, name, value): if name == "_d" or len(self._d) == 0 or name in self.__dict__: object.__setattr__(self, name, value) return if not self._is_owned(): raise AttributeError("%s: lock required for write access" % name) self._d[name] = value
def __setattr__(self, name, value): if name == "_d" or len(self._d) == 0 or name in self.__dict__: object.__setattr__(self, name, value) return if not self._is_owned(): raise AttributeError("%s: lock required for write access" % name) self._d[name] = value
def __setattr__(self, attr, value): """ This prevents us from accidentally writing to a non-existant attribute. e.g. if the user tries to say components.fIlEnAmE = 'newfile.h5', raise an error. """ if hasattr(self, '_initialized'): # Attempt to get the old attribute first oldval = getattr(self, attr) object.__setattr__(self, attr, value)
def queryValue(q): ''' Computes a path expression. The query (@q) is a list of attribute names and associated where expressions. The function returned computes the result when called. ''' attrs = q def query(objs): 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 return OrderedSet(select(objs, attrs)) object.__setattr__(query, '__objquery__', True) return query
def __setattr__(self, key, value): """ We want to prevent importers from adding invalid attributes (PWS-317) Rather fail hard in these cases. """ if not hasattr(self, key): raise TypeError( "Cannot create attribute %s, Data is a frozen class" % key) object.__setattr__(self, key, value)
def override_descriptor(name): def fn(self, *args, **kwargs): return self._descriptor_dict[name] # The first one is py2, the second py3 try: object.__setattr__(self, name, MethodType(fn, self, type(self))) except TypeError: object.__setattr__(self, name, MethodType(fn, self))
def __init__(self, conntrack, handle, msgtype=NFCT_T_UNKNOWN, destroy=True, attr=None): if not handle: raise RuntimeError("Empty entry handler") if not attr: attr = {} object.__setattr__(self, "_attr", attr) object.__setattr__(self, "_destroy", destroy) object.__setattr__(self, "_handle", handle) object.__setattr__(self, "_sub_system", conntrack) object.__setattr__(self, "_msgtype", msgtype)
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 __setattr__(self, name, value): if name is 'direction': if value not in (Gpio.GPIO_INPUT, Gpio.GPIO_OUTPUT, Gpio.GPIO_TRISTATE): raise ValueError("Attempt to set illegal direction {}".format(value)) if name is 'level': if value not in (True, False): raise ValueError("GPIO level must be true or false. Got {}".format(value)) if name is 'interrupt': if value not in (True, False): raise ValueError("GPIO interrupt must be true or false. Got {}".format(value)) object.__setattr__(self, name, value)
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)
def __initValue(self, at, label): """ if field.default is an instance of ConfigClass, custom construct _value with the correct values from default. otherwise call ConfigClass constructor """ name = _joinNamePath(self._config._name, self._field.name) if type(self._field.default) == self.ConfigClass: storage = self._field.default._storage else: storage = {} value = self._ConfigClass(__name=name, __at=at, __label=label, **storage) object.__setattr__(self, "_value", value)
def __setattr__(self, name, value): try: setattr(self._module, name, value) except AttributeError: if self._module is not None: raise import_name = 'pyglet.%s' % self._module_name __import__(import_name) module = sys.modules[import_name] object.__setattr__(self, '_module', module) globals()[self._module_name] = module setattr(module, name, value)
def __setattr__(self, name, value, at=None, label="assignment"): """ Pretend to be an isntance of ConfigClass. Attributes defined by ConfigurableInstance will shadow those defined in ConfigClass """ if self._config._frozen: raise FieldValidationError(self._field, self._config, "Cannot modify a frozen Config") if name in self.__dict__: # attribute exists in the ConfigurableInstance wrapper object.__setattr__(self, name, value) else: if at is None: at = getCallStack() self._value.__setattr__(name, value, at=at, label=label)
def __setattr__(self, name, value): if self.__is_relationship_attr("_rel_" + name): raise AttributeNotEditableException(name, value) api_attr = self.__get_api_attr(name) if api_attr is None: object.__setattr__(self, name, value) else: if not api_attr.editable: raise AttributeNotEditableException(name, value) else: if self._api_client._deferred_save: self.dirty[name] = True else: self.edit(**{name: value}) object.__setattr__(self, name, value)
def __setattr__(self, attr, value, at=None, label="assignment"): """!Regulate which attributes can be set Unlike normal python objects, Config objects are locked such that no additional attributes nor properties may be added to them dynamically. Although this is not the standard Python behavior, it helps to protect users from accidentally mispelling a field name, or trying to set a non-existent field. """ if attr in self._fields: if at is None: at = getCallStack() # This allows Field descriptors to work. self._fields[attr].__set__(self, value, at=at, label=label) elif hasattr(getattr(self.__class__, attr, None), '__set__'): # This allows properties and other non-Field descriptors to work. return object.__setattr__(self, attr, value) elif attr in self.__dict__ or attr in ("_name", "_history", "_storage", "_frozen", "_imports"): # This allows specific private attributes to work. self.__dict__[attr] = value else: # We throw everything else. raise AttributeError("%s has no attribute %s" % (_typeStr(self), attr))
def __setattr__(self, name, value): """ Sets function argument values. """ # Note - once self._args is created, no new attributes can # be added to self.__dict__. This is a good thing as it throws # an exception if you try to assign to an arg which is inappropriate # for the function in the solver. if "_args" in self.__dict__: if name in self._args: self._args[name] = value elif name in self.__dict__: self.__dict__[name] = value else: raise KeyError(name) else: object.__setattr__(self, name, value)
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 retarget(self, target, ConfigClass=None, at=None, label="retarget"): if self._config._frozen: raise FieldValidationError(self._field, self._config, "Cannot modify a frozen Config") try: ConfigClass = self._field.validateTarget(target, ConfigClass) except BaseException as e: raise FieldValidationError(self._field, self._config, e.message) if at is None: at = getCallStack() object.__setattr__(self, "_target", target) if ConfigClass != self.ConfigClass: object.__setattr__(self, "_ConfigClass", ConfigClass) self.__initValue(at, label) history = self._config._history.setdefault(self._field.name, []) msg = "retarget(target=%s, ConfigClass=%s)" % (_typeStr(target), _typeStr(ConfigClass)) history.append((msg, at, label))
def __setattr__(self, k, v): if k == "task": object.__setattr__(self, k, v) return # special attributes for internal use if k in ['_portnames']: object.__setattr__(self, k, v) return # special handling for setting port values if k in self._portnames and hasattr(self, k): # parse batch inputs vs regular batch_values = [] # if input type is of list, use batch workflows endpoint if isinstance(v, list): self.__getattribute__(k).value = "$batch_value:{0}".format( "batch_input_{0}".format(k)) batch_values.append({"name": "batch_input_{0}".format(k), "values": v}) else: port = self.__getattribute__(k) port.value = v return # set the batch values object if batch_values: self.task.batch_values = batch_values else: self.task.batch_values = None return # find out if this is a valid multiplex port, i.e. this portname is prefixed by a multiplex port mp_port = self.get_matching_multiplex_port(k) if mp_port: new_multiplex_port = Port( k, mp_port.type, mp_port.required, mp_port.description, value=v ) object.__setattr__(self, k, new_multiplex_port) self._portnames.update([k]) return # default for initially setting up ports if k in self._portnames: object.__setattr__(self, k, v) else: raise AttributeError('Task has no input port named %s.' % k)
def __setattr__(self, k, v): # special attributes for internal use if k in ['_portnames']: object.__setattr__(self, k, v) return # special handling for setting port values if k in self._portnames and hasattr(self, k): port = self.__getattribute__(k) port.value = v return # find out if this is a valid multiplex port, i.e. this portname is prefixed by a multiplex port mp_port = self.get_matching_multiplex_port(k) if mp_port: new_multiplex_port = Port( k, mp_port.type, mp_port.required, mp_port.description, value=v ) object.__setattr__(self, k, new_multiplex_port) self._portnames.update([k]) return # default for initially setting up ports if k in self._portnames: object.__setattr__(self, k, v) else: raise AttributeError('Task has no input port named %s.' % k)