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):
"""
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, 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, 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 __setitem__(self, key, value):
self.__parent__.__dirty_classes__ = True
defaultdict.__setitem__(self, key, value)
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 __setitem__(self, key, value):
self.lock.acquire()
result = defaultdict.__setitem__(self, key, value)
self.lock.release()
return result
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):
defaultdict.__setitem__(self, (repr(key), key), value)
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):
defaultdict.__setitem__(self, str(key), val)
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 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, value):
self._check_key(key)
return defaultdict.__setitem__(self, key, value)
def __setitem__(self, key, val):
defaultdict.__setitem__(self, key, val)
with file(TRACE, 'wb') as f:
pickle.dump(self, f)
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)
