def __getitem__(self, key): if key == None: return Null if key == ".": output = _get(self, "_dict") if isinstance(output, Mapping): return self else: return output key = text_type(key) d = _get(self, "_dict") if key.find(".") >= 0: seq = _split_field(key) for n in seq: if isinstance(d, NullType): d = NullType( d, n) # OH DEAR, Null TREATS n AS PATH, NOT LITERAL elif isinstance(d, list): d = [_getdefault(dd, n) for dd in d] else: d = _getdefault(d, n) # EVERYTHING ELSE TREATS n AS LITERAL return wrap(d) else: o = d.get(key) if o == None: return NullType(d, key) return wrap(o)
def __getitem__(self, key): if key == None: return Null if key == ".": output = _get(self, "_dict") if isinstance(output, Mapping): return self else: return output if isinstance(key, str): key = key.decode("utf8") elif not isinstance(key, unicode): get_logger().error("only string keys are supported") d = _get(self, "_dict") if key.find(".") >= 0: seq = _split_field(key) for n in seq: if isinstance(d, NullType): d = NullType(d, n) # OH DEAR, Null TREATS n AS PATH, NOT LITERAL elif isinstance(d, list): d = [_getdefault(dd, n) for dd in d] else: d = _getdefault(d, n) # EVERYTHING ELSE TREATS n AS LITERAL return wrap(d) else: o = d.get(key) if o == None: return NullType(d, key) return wrap(o)
def __getitem__(self, key): if key == None: return Null if key == ".": output = self._internal_dict if _get(output, CLASS) in data_types: return self else: return output key = text(key) d = self._internal_dict if key.find(".") >= 0: seq = _split_field(key) for n in seq: if _get(d, CLASS) is NullType: d = NullType( d, n) # OH DEAR, Null TREATS n AS PATH, NOT LITERAL elif is_list(d): d = [_getdefault(dd, n) for dd in d] else: d = _getdefault(d, n) # EVERYTHING ELSE TREATS n AS LITERAL return wrap(d) else: o = d.get(key) if o == None: return NullType(d, key) return wrap(o)
def pop(self, key, default=Null): if key == None: return Null if key == ".": raise NotImplemented() key = text(key) d = self._internal_dict if key.find(".") >= 0: seq = _split_field(key) for n in seq[:-1]: if _get(d, CLASS) is NullType: d = NullType( d, n) # OH DEAR, Null TREATS n AS PATH, NOT LITERAL elif is_list(d): d = [_getdefault(dd, n) for dd in d] else: d = _getdefault(d, n) # EVERYTHING ELSE TREATS n AS LITERAL key = seq[-1] o = d.get(key) if o == None: if default is Null: return NullType(d, key) return default d[key] = None return to_data(o)
def _getdefault(obj, key): """ obj ANY OBJECT key IS EXPECTED TO BE LITERAL (NO ESCAPING) TRY BOTH ATTRIBUTE AND ITEM ACCESS, OR RETURN Null """ try: return obj[key] except Exception as f: pass try: if obj.__class__ is not dict: return getattr(obj, key) except Exception as f: pass try: if float(key) == round(float(key), 0): return obj[int(key)] except Exception as f: pass # TODO: FIGURE OUT WHY THIS WAS EVER HERE (AND MAKE A TEST) # try: # return eval("obj."+text(key)) # except Exception as f: # pass return NullType(obj, key)
def get(self, key, default=Null): v = self[key] if _get(v, CLASS) == NullType: if default is Null: return NullType(self, key) return default return v
def __getattr__(self, key): if isinstance(key, str): ukey = key.decode("utf8") else: ukey = key d = self o = dict.get(d, ukey, None) if o == None: return NullType(d, ukey) return wrap(o)
def __getattr__(self, key): d = self._internal_dict v = d.get(key) t = _get(v, CLASS) # OPTIMIZED to_data() if t is dict: return dict_to_data(v) elif t in (none_type, NullType): return NullType(d, key) elif t is list: return list_to_data(v) elif t in generator_types: return FlatList(list(from_data(vv) for vv in v)) else: return v
def _get_dict_default(obj, key): """ obj MUST BE A DICT key IS EXPECTED TO BE LITERAL (NO ESCAPING) TRY BOTH ATTRIBUTE AND ITEM ACCESS, OR RETURN Null """ try: return obj[key] except Exception as f: pass try: if float(key) == round(float(key), 0): return obj[int(key)] except Exception as f: pass return NullType(obj, key)
def __getitem__(self, key): if key == None: return Null if isinstance(key, str): key = key.decode("utf8") d=self if key.find(".") >= 0: seq = _split_field(key) for n in seq: d = _getdefault(self, n) return wrap(d) else: o = dict.get(d, None) if o == None: return NullType(d, key) return wrap(o)
def __getattr__(self, key): d = _get(self, SLOT) v = d.get(key) t = _get(v, CLASS) # OPTIMIZED wrap() if t is dict: m = object.__new__(Data) _set(m, SLOT, v) return m elif t in (none_type, NullType): return NullType(d, key) elif t is list: return FlatList(v) elif t in generator_types: return FlatList(list(unwrap(vv) for vv in v)) else: return v
def __getattr__(self, key): d = _get(self, "_dict") o = d.get(key) if o == None: return NullType(d, key) return wrap(o)
return getattr(obj, key) except Exception, f: pass try: if float(key) == round(float(key), 0): return obj[int(key)] except Exception, f: pass # TODO: FIGURE OUT WHY THIS WAS EVER HERE (AND MAKE A TEST) # try: # return eval("obj."+unicode(key)) # except Exception, f: # pass return NullType(obj, key) PATH_NOT_FOUND = "Path not found" AMBIGUOUS_PATH_FOUND = "Path is ambiguous" def set_attr(obj, path, value): """ SAME AS object.__setattr__(), BUT USES DOT-DELIMITED path RETURN OLD VALUE """ try: return _set_attr(obj, split_field(path), value) except Exception as e: Log = get_logger()