def incr(self, item, value):
"""Increment a key by the given amount."""
if item in self:
old = UserDict.__getitem__(self, item)
else:
old = 0.0
self[item] = old + value
def __getitem__(self, key):
if key == 'start_time':
return self.get_start_time()
elif key == 'end_time':
return self.get_end_time()
else:
return UserDict.__getitem__(self, key)
def __getitem__(self, name):
problem = UserDict.__getitem__(self, name)
lines = [[int(s) for s in s_.split(',')]
for s_ in problem['lines'].split(' ')]
columns = [[int(s) for s in s_.split(',')]
for s_ in problem['columns'].split(' ')]
return lines, columns
def __getitem__(self, key): # print '__getitem__', key # Handle boolean special since they are not in the # environment if key.lower() == 'true': return True if key.lower() == 'false': return False try: val = UserDict.__getitem__(self, key) except: return None # undefined vars are None try: if val.lower() in [ 'on', 'true', 'yes', 'y' ]: return True if val.lower() in [ 'off', 'false', 'no', 'n' ]: return False except: pass # Everything else is returned as a string return val
def dictize(obj):
"""A helper method, to make namedtuple-like object accessible as dict.
If the object is namedtuple-like, its _asdict() form is returned,
but in the returned object __getitem__ method is wrapped
to dictize also any items returned.
If the object does not have _asdict, it will be returned without any change.
Integer keys still access the object as tuple.
A more useful version would be to keep obj mostly as a namedtuple,
just add getitem for string keys. Unfortunately, namedtuple inherits
from tuple, including its read-only __getitem__ attribute,
so we cannot monkey-patch it.
TODO: Create a proxy for named tuple to allow that.
:param obj: Arbitrary object to dictize.
:type obj: object
:returns: Dictized object.
:rtype: same as obj type or collections.OrderedDict
"""
if not hasattr(obj, u"_asdict"):
return obj
overriden = UserDict(obj._asdict())
old_get = overriden.__getitem__
new_get = lambda self, key: dictize(old_get(self, key))
overriden.__getitem__ = new_get
return overriden
def __getitem__(self, key):
# print '__getitem__', key
# Handle boolean special since they are not in the
# environment
if key.lower() == 'true':
return True
if key.lower() == 'false':
return False
try:
val = UserDict.__getitem__(self, key)
except:
return None # undefined vars are None
try:
if val.lower() in ['on', 'true', 'yes', 'y']:
return True
if val.lower() in ['off', 'false', 'no', 'n']:
return False
except:
pass
# Everything else is returned as a string
return val
def __getitem__(self, key):
""" overrides the error messages of missing params[$key] """
try:
return IterableUserDict.__getitem__(self, key)
except KeyError:
raise ParamNotFound("Mandatory parameter '%s' is missing. "
"Check your cfg files for typos/mistakes" %
key)
def __getitem__(self, key):
if self.owner is not None and key in self.data and isinstance(self.data[key], list):
if key in self.obj_map:
_dat = [self.obj_map[key](self, _) for _ in self.data[key]]
else:
_dat = self.data[key]
return Filterable(self.owner['id'], _dat)
else:
return UserDict.__getitem__(self, key)
def __getitem__(self, item):
if item in self:
value = UserDict.__getitem__(self, item)
else:
value = 0.0
if item is not None and item == self.parent.state:
return value + (time.time() - self.parent.time)
else:
return value
def __getitem__(self, key):
if self.owner is not None and key in self.data and isinstance(
self.data[key], list):
if key in self.obj_map:
_dat = [self.obj_map[key](self, _) for _ in self.data[key]]
else:
_dat = self.data[key]
return Filterable(self.owner['id'], _dat)
else:
return UserDict.__getitem__(self, key)
def __getitem__(self, key):
"""
Retrieve an item from attributes (by name or id).
"""
for k in self.__getkeys(key):
try:
return UserDict.__getitem__(self, k)
except KeyError:
continue
raise KeyError(key)
def __getitem__(self, key):
# Select rows using an integer pdarray
if isinstance(key, ak.pdarray):
result = {}
for k in self._columns:
result[k] = UserDict.__getitem__(self, k)[key]
return DataFrame(initialdata=result)
# Select rows or columns using a list
if isinstance(key, list):
result = DataFrame()
if len(key) <= 0:
return result
if len({type(x) for x in key}) > 1:
raise TypeError("Invalid selector: too many types in list.")
if type(key[0]) == int:
rows = ak.array(key)
for k in self.data.keys():
result.data[k] = UserDict.__getitem__(self, k)[rows]
result._columns.append(k)
result._empty = False
return result
elif type(key[0]) == str:
# Grab the index column as well.
result.data['index'] = UserDict.__getitem__(self, 'index')
for k in key:
result.data[k] = UserDict.__getitem__(self, k)
result._columns.append(k)
result._empty = False
return result
# Select a single row using an integer
if isinstance(key, int):
result = {}
row = ak.array([key])
for k in self.data.keys():
result[k] = (UserDict.__getitem__(self, k)[row])[0]
return aku.Row(result)
# Select a single column using a string
elif isinstance(key, str):
if key not in self.keys():
raise KeyError("Invalid column name '{}'.".format(key))
return UserDict.__getitem__(self, key)
# Select rows using a slice
elif isinstance(key, slice):
# result = DataFrame()
data = {}
s = key
for k in self._columns:
data[k] = UserDict.__getitem__(self, k)[s.start:s.stop:s.step]
# result._columns.append(k)
# result._empty = False
return DataFrame(initialdata=data)
else:
raise IndexError("Invalid selector: unknown error.")
def __getitem__(self, key):
"""
Retrieve an item from attributes (by name or id).
"""
for k in self.__getkeys(key):
try:
return UserDict.__getitem__(self, k)
except KeyError:
continue
raise KeyError(key)
def __getitem__(self, name: str) -> tuple[list[list[int]], list[list[int]]]:
problem = UserDict.__getitem__(self, name)
lines = [
[int(s) for s in s_.split(",")]
for s_ in problem["lines"].split(" ")
]
columns = [
[int(s) for s in s_.split(",")]
for s_ in problem["columns"].split(" ")
]
return lines, columns
def __getitem__(self, item):
"""
Parameters
----------
item : (Interface, Interface)
"""
item = self._get_key(*item)
# old-style class, no super
res = UserDict.__getitem__(self, item)
return res
def __getitem__(self, key):
'''This method "implements" row inheritance: if the current row does
not have an element with p_key, it looks in the parent row of this row,
via the parent table self.table.'''
keyError = False
t = self.table
if key in self:
res = UserDict.__getitem__(self, key)
else:
# Get the parent row
if t.parent:
if isinstance(t.parentRow, int):
if t.parentRow < len(t.parent):
try:
res = t.parent[t.parentRow][key]
except KeyError:
keyError = True
else:
raise ParserError(PARENT_ROW_NOT_FOUND %
(t.name, t.parent.name, t.parentRow,
t.parent.name, len(t.parent)))
else:
tColumn, tValue = t.parentRow
# Get the 1st row having tColumn = tValue
rowFound = False
for row in t.parent:
try:
curVal = row[tColumn]
except KeyError:
raise ParserError(PARENT_COLUMN_NOT_FOUND %
(t.name, t.parent.name, tColumn,
t.parent.name))
if curVal == tValue:
rowFound = True
try:
res = row[key]
except KeyError:
keyError = True
break
if not rowFound:
raise ParserError(PARENT_ROW_COL_NOT_FOUND %
(t.name, t.parent.name, tColumn,
tValue, t.parent.name))
else:
keyError = True
if keyError:
raise KeyError(TABLE_KEY_ERROR % (t.name, key, t.name))
return res
def __getitem__(self, key):
'''This method "implements" row inheritance: if the current row does
not have an element with p_key, it looks in the parent row of this row,
via the parent table self.table.'''
keyError = False
t = self.table
if key in self:
res = UserDict.__getitem__(self, key)
else:
# Get the parent row
if t.parent:
if isinstance(t.parentRow, int):
if t.parentRow < len(t.parent):
try:
res = t.parent[t.parentRow][key]
except KeyError:
keyError = True
else:
raise ParserError(PARENT_ROW_NOT_FOUND %
(t.name, t.parent.name, t.parentRow,
t.parent.name, len(t.parent)))
else:
tColumn, tValue = t.parentRow
# Get the 1st row having tColumn = tValue
rowFound = False
for row in t.parent:
try:
curVal = row[tColumn]
except KeyError:
raise ParserError(PARENT_COLUMN_NOT_FOUND %
(t.name, t.parent.name, tColumn,
t.parent.name))
if curVal == tValue:
rowFound = True
try:
res = row[key]
except KeyError:
keyError = True
break
if not rowFound:
raise ParserError(PARENT_ROW_COL_NOT_FOUND %
(t.name, t.parent.name, tColumn,
tValue, t.parent.name))
else:
keyError = True
if keyError:
raise KeyError(TABLE_KEY_ERROR % (t.name, key, t.name))
return res
def __getitem__(self, key):
data = UserDict.__getitem__(self, key)
return pickle.loads(base64.b64decode(data.encode('ascii')))
def __getitem__(self, key):
try:
return UserDict.__getitem__(self, key)
except KeyError as e:
return key
def __getitem__(self, item):
if item in self:
return UserDict.__getitem__(self, item)
else:
return 0.0
def getOption(self, key):
return UserDict.__getitem__(self, key)
def __getitem__(self, item):
if item not in self:
value = PmfStatDict()
UserDict.__setitem__(self, item, value)
return UserDict.__getitem__(self, item)
