def __setitem__(self, key, value, dict_setitem=dict.__setitem__): if isinstance(key, basestring): for k, v in self._legacymapping.iteritems(): if key == k: key = v if isinstance(value, str): value = KVDICT(None, self._string_to_dict(value)) if key in self and "pt" in dir(self[key]): return defaultdict.__setitem__( self, key, type(self[key])(value, units=self[key].units, pt=self[key].pt)) if key in self and "withunits" in str(type(self[key])): return defaultdict.__setitem__( self, key, type(self[key])(value, units=self[key].units)) if value is None and key in self: if "_isstring" in dir(self[key]): self[key].invalidate() return # what to return here? if "_isstring" in dir(value): value._isstr = key in _stringdicts value._notstr = key in _notstringdicts if self._isstring() and isinstance( value, dict) and key not in ['_comments', '_orders']: raise TypeError("Can't add kv entry as subset of string " + str(key) + ' ' + str(value)) return defaultdict.__setitem__(self, key, value)
def __setitem__(self, key, value): """ called when the value of some item in dictionary is set make sure dict is now un-normalised after this happens """ defaultdict.__setitem__(self, key, value) self.is_normalised = False
def __setitem__(self, key, value): """This method is where all new item assignation is performed, new items should always be list, tuple or Locator instance All values is casted to Locator, this way we ensure nodes are all Locator types. This method manages `obj.foo.bar = blaz` and also `obj['foo.bar'] = blaz` forms of item assignation. if assignation is performed in to an existing Locator, all the values are merged. """ if not isinstance(value, (list, tuple, Locator)): raise ValueError('Value must be iterable or Locator') if not isinstance(value, Locator): value = Locator(*value) keys = key.split('.') if len(keys) > 1: obj_key = keys.pop(-1) obj = reduce(getattr, keys, self) setattr(obj, obj_key, value) else: if key not in self: defaultdict.__setitem__(self, key, value) else: # if exists, should be merged self[key]._store = value._store for k, v in value.items(): self[key][k] = v
def union(self, new_files): """ Combine this object with another of the same type """ if type(new_files) != self.__class__: raise TypeError('Only ' + self.__class__.__name__ + ' objects can be unioned together.') for date, file_paths in new_files.iteritems(): for file_path in file_paths: defaultdict.__setitem__(self, date, defaultdict.__getitem__(self, date) + [file_path])
def add_table(self, table): """ Combine this EmissionsTable object with another """ for eic, eic_data in table.iteritems(): if not defaultdict.__contains__(self, eic): defaultdict.__setitem__(self, eic, eic_data) else: for poll, value in eic_data.iteritems(): eic_dict = defaultdict.__getitem__(self, eic) eic_dict[poll] += value
def __setitem__(self, key, val): """ Setter method for emissions table """ if type(val) != defaultdict: raise TypeError( 'The emissions table must be two levels deep: EIC and pollutant.' ) for value in val.values(): if type(value) != np.float32: raise TypeError('Emissions values must be of type np.float32.') defaultdict.__setitem__(self, key, val)
def __setitem__(self, k, v): if k in self: raise KeyError('Cannot assign to ListMap entry; use replace() or append()') else: self._keys.append(k) self._key_value.extend([(k,vv) for vv in v]) return defaultdict.__setitem__(self, k, v)
def __setitem__(self, key, val): check.inst_param(key, 'key', SolidInputHandle) if not (isinstance(val, SolidOutputHandle) or isinstance(val, list)): check.failed( 'Value must be SolidOutoutHandle or List[SolidOutputHandle], got {val}' .format(val=type(val))) return defaultdict.__setitem__(self, key, val)
def __setitem__(self, key, value): """Set a key equal to a value. The dict is locked for other writes while doing so. """ self.lock.acquire() result = defaultdict.__setitem__(self, key, value) self.lock.release() return result
def __setitem__(self, key: SolidInputHandle, val: Union[SolidOutputHandle, List[SolidOutputHandle]]): check.inst_param(key, "key", SolidInputHandle) if not (isinstance(val, SolidOutputHandle) or isinstance(val, list)): check.failed( "Value must be SolidOutputHandle or List[SolidOutputHandle], got {val}" .format(val=type(val))) return defaultdict.__setitem__(self, key, val)
def __setitem__(self, key, value): defaultdict.__setitem__(self, (repr(key), key), value)
def __setitem__(self, key, value): assert isinstance(value, RelevanceInterface) key = MaybeCompressedString(key) child_pointer = self.pointer_to_me.copy().get_by_index(key) value.pointer_to_me = child_pointer defaultdict.__setitem__(self, key, value)
def __setitem__(self, k, v): if k in self: raise KeyError('Cannot assign to ListMap entry; use replace() or append()') return defaultdict.__setitem__(self, k, v)
def __setitem__(self, key, value): self.lock.acquire() result = defaultdict.__setitem__(self, key, value) self.lock.release() return result
def __setitem__(self, item, value): return defaultdict.__setitem__( self, self.data_source._determine_fields(item)[0], value)
def __setitem__(self, key, value): self.__parent__.__dirty_classes__ = True defaultdict.__setitem__(self, key, value)
def __setitem__(self, key, value): fname = self.fname(key) pickle.dump((key, value), open(fname, 'wb')) defaultdict.__setitem__(self, key, value)
def __setitem__(self, key, val): defaultdict.__setitem__(self, str(key), val)
def __setitem__(self, key, val): check.inst_param(key, 'key', SolidInputHandle) check.list_param(val, 'val', of_type=SolidOutputHandle) return defaultdict.__setitem__(self, key, val)
def replace(self, k, v): defaultdict.__setitem__(self, k, [v])
def __setitem__(self, key, rules): if hasattr(rules, '_match'): rules = RuleList([rules]) elif not hasattr(rules, '_matches'): rules = RuleList(rules) return defaultdict.__setitem__(self, key, rules)
def _set(key, value, subdict): keys = key.split('.', 1) if len(keys) == 1: defaultdict.__setitem__(subdict, key, value) else: _set(keys[1], value, subdict[keys[0]])
def __setitem__(self, key, value): fname = self.fname(key) pickle.dump((key, value), open(fname, "wb")) defaultdict.__setitem__(self, key, value)
def replace(self, k, v): defaultdict.__setitem__(self, k, [v]) for i,(m,n) in enumerate(self._key_value): if m == k: self._key_value[i] = (k,v)
def __setitem__(self, key, val): defaultdict.__setitem__(self, key, val) with file(TRACE, 'wb') as f: pickle.dump(self, f)
def __setitem__(self, key, value): keys = key.split('.') for key in keys[:-1]: self = self[key] defaultdict.__setitem__(self, keys[-1], value)
def __setitem__(self, key, val): """ Setter method """ if type(key) != str or type(val) != list: raise TypeError('The key of the OutputFiles object must be a date string ' + 'and value must be a file path.') defaultdict.__setitem__(self, key, val)
def __setitem__(self, key, value): keys = key.split(".") for key in keys[:-1]: self = self[key] defaultdict.__setitem__(self, keys[-1], value)
def __setitem__(self, key, value): self._check_key(key) return defaultdict.__setitem__(self, key, value)
def __setitem__(self, key, i): if 'tostring' in dir(key): key = key.tostring() return defaultdict.__setitem__(self, key, i)
def __setitem__(self, key, value): """also update parent if given""" if self.parent is not None: self.parent[key] += value - defaultdict.get(self, key, 0) defaultdict.__setitem__(self, key, value)