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, 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): 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)