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 __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 = _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 = 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 __setitem__(self, key, value):
if key == "":
get_logger().error("key is empty string. Probably a bad idea")
if isinstance(key, str):
key = key.decode("utf8")
d=self
try:
value = unwrap(value)
if key.find(".") == -1:
if value is None:
dict.pop(d, key, None)
else:
dict.__setitem__(d, key, value)
return self
seq = _split_field(key)
for k in seq[:-1]:
d = _getdefault(d, k)
if value == None:
dict.pop(d, seq[-1], None)
else:
dict.__setitem__(d, seq[-1], value)
return self
except Exception as e:
raise e
def __setitem__(self, key, value):
if key == "":
get_logger().error("key is empty string. Probably a bad idea")
if isinstance(key, str):
key = key.decode("utf8")
d=self
try:
value = unwrap(value)
if key.find(".") == -1:
if value is None:
dict.pop(d, key, None)
else:
dict.__setitem__(d, key, value)
return self
seq = _split_field(key)
for k in seq[:-1]:
d = _getdefault(d, k)
if value == None:
dict.pop(d, seq[-1], None)
else:
dict.__setitem__(d, seq[-1], value)
return self
except Exception as e:
raise e
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 __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 __setitem__(self, key, value):
if key == "":
get_logger().error("key is empty string. Probably a bad idea")
if key == None:
return Null
if key == ".":
# SOMETHING TERRIBLE HAPPENS WHEN value IS NOT A Mapping;
# HOPEFULLY THE ONLY OTHER METHOD RUN ON self IS unwrap()
v = unwrap(value)
_set(self, SLOT, v)
return v
try:
d = self._internal_dict
value = unwrap(value)
if key.find(".") == -1:
if value is None:
d.pop(key, None)
else:
d[key] = value
return self
seq = _split_field(key)
for k in seq[:-1]:
d = _getdefault(d, k)
if value == None:
try:
d.pop(seq[-1], None)
except Exception as _:
pass
elif d == None:
d[literal_field(seq[-1])] = value
else:
d[seq[-1]] = value
return self
except Exception as e:
from mo_logs import Log
Log.error("can not set key={{key}}", key=key, cause=e)
def __setitem__(self, key, value):
if key == "":
get_logger().error("key is empty string. Probably a bad idea")
if key == None:
return Null
if key == ".":
# SOMETHING TERRIBLE HAPPENS WHEN value IS NOT A Mapping;
# HOPEFULLY THE ONLY OTHER METHOD RUN ON self IS unwrap()
v = unwrap(value)
_set(self, SLOT, v)
return v
try:
d = self._internal_dict
value = unwrap(value)
if key.find(".") == -1:
if value is None:
d.pop(key, None)
else:
d[key] = value
return self
seq = _split_field(key)
for k in seq[:-1]:
d = _getdefault(d, k)
if value == None:
try:
d.pop(seq[-1], None)
except Exception as _:
pass
elif d==None:
d[literal_field(seq[-1])] = value
else:
d[seq[-1]] = value
return self
except Exception as e:
raise e
def __setitem__(self, key, value):
if key == "":
get_logger().error("key is empty string. Probably a bad idea")
if key == None:
return Null
if key == ".":
# SOMETHING TERRIBLE HAPPENS WHEN value IS NOT A Mapping;
# HOPEFULLY THE ONLY OTHER METHOD RUN ON self IS unwrap()
v = unwrap(value)
_set(self, "_dict", v)
return v
if isinstance(key, str):
key = key.decode("utf8")
try:
d = _get(self, "_dict")
value = unwrap(value)
if key.find(".") == -1:
if value is None:
d.pop(key, None)
else:
d[key] = value
return self
seq = _split_field(key)
for k in seq[:-1]:
d = _getdefault(d, k)
if value == None:
d.pop(seq[-1], None)
elif d==None:
d[literal_field(seq[-1])] = value
else:
d[seq[-1]] = value
return self
except Exception as e:
raise e
def tuple(data, field_name):
"""
RETURN LIST OF TUPLES
"""
if isinstance(data, Cube):
Log.error("not supported yet")
if isinstance(data, FlatList):
Log.error("not supported yet")
if is_data(field_name) and "value" in field_name:
# SIMPLIFY {"value":value} AS STRING
field_name = field_name["value"]
# SIMPLE PYTHON ITERABLE ASSUMED
if is_text(field_name):
if len(split_field(field_name)) == 1:
return [(d[field_name], ) for d in data]
else:
path = split_field(field_name)
output = []
for d in data:
for p in path:
d = _getdefault(d, p)
output.append((d, ))
return output
elif is_list(field_name):
paths = [_select_a_field(f) for f in field_name]
output = FlatList()
_tuple((), unwrap(data), paths, 0, output)
return output
else:
paths = [_select_a_field(field_name)]
output = FlatList()
_tuple((), data, paths, 0, output)
return output
