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 isinstance(output, Mapping):
return self
else:
return output
key = text_type(key)
d = self._internal_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()