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 __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)])