def tuplewrap(value):
"""
INTENDED TO TURN lists INTO tuples FOR USE AS KEYS
"""
if is_many(value):
return tuple(tuplewrap(v) if is_sequence(v) else v for v in value)
return unwrap(value),
def hash_value(v):
if is_many(v):
return hash(tuple(hash_value(vv) for vv in v))
elif _get(v, CLASS) not in data_types:
return hash(v)
else:
return hash(tuple(sorted(hash_value(vv) for vv in v.values())))
def hash_value(v):
if is_many(v):
return hash(tuple(hash_value(vv) for vv in v))
elif _get(v, CLASS) not in data_types:
return hash(v)
else:
return hash(tuple(sorted(hash_value(vv) for vv in v.values())))
def __init__(self,
context=ERROR,
template=Null,
params=Null,
cause=Null,
trace=Null,
**_):
if context == None:
raise ValueError("expecting context to not be None")
if is_many(cause):
self.cause = unwraplist([Except.wrap(c) for c in cause])
else:
self.cause = Except.wrap(cause)
Exception.__init__(self)
LogItem.__init__(self,
context=context,
format=None,
template=template,
params=params)
if not trace:
self.trace = get_stacktrace(2)
else:
self.trace = trace
def is_expression(call):
if is_many(call):
return False
try:
output = getattr(call, ID, None) != None
except Exception:
output = False
# if output != isinstance(call, Expression):
# Log.error("programmer error")
return output
def listwrap(value):
"""
PERFORMS THE FOLLOWING TRANSLATION
None -> []
value -> [value]
[...] -> [...] (unchanged list)
## MOTIVATION ##
OFTEN IT IS NICE TO ALLOW FUNCTION PARAMETERS TO BE ASSIGNED A VALUE,
OR A list-OF-VALUES, OR NULL. CHECKING FOR WHICH THE CALLER USED IS
TEDIOUS. INSTEAD WE CAST FROM THOSE THREE CASES TO THE SINGLE CASE
OF A LIST
# BEFORE
def do_it(a):
if a is None:
return
if not isinstance(a, list):
a=[a]
for x in a:
# do something
# AFTER
def do_it(a):
for x in listwrap(a):
# do something
"""
if value == None:
return FlatList()
elif is_list(value):
if isinstance(value, list):
return list_to_data(value)
else:
return value
elif is_many(value):
return list_to_data(list(value))
else:
return list_to_data([from_data(value)])
