def combine_lists(left, right, engine): """:yaql:operator + Returns two iterables concatenated. :signature: left + right :arg left: left list :argType left: iterable :arg right: right list :argType right: iterable :returnType: iterable .. code:: yaql> [1, 2] + [3] [1, 2, 3] """ if isinstance(left, tuple) and isinstance(right, tuple): utils.limit_memory_usage(engine, (1, left), (1, right)) return left + right elif isinstance(left, frozenset) and isinstance(right, frozenset): utils.limit_memory_usage(engine, (1, left), (1, right)) return left.union(right) return yaql.standard_library.queries.concat(left, right)
def call(name, context, args, kwargs, engine, receiver=utils.NO_VALUE, data_context=None, use_convention=False, function_filter=None): if data_context is None: data_context = context if function_filter is None: function_filter = lambda fd, ctx: True if receiver is utils.NO_VALUE: predicate = lambda fd, ctx: fd.is_function and function_filter(fd, ctx) else: predicate = lambda fd, ctx: fd.is_method and function_filter(fd, ctx) all_overloads = context.collect_functions( name, predicate, use_convention=use_convention) if not all_overloads: if receiver is utils.NO_VALUE: raise exceptions.NoFunctionRegisteredException(name) else: raise exceptions.NoMethodRegisteredException(name, receiver) else: delegate = choose_overload( name, all_overloads, engine, receiver, data_context, args, kwargs) try: result = delegate() utils.limit_memory_usage(engine, (1, result)) return result except StopIteration as e: six.reraise( exceptions.WrappedException, exceptions.WrappedException(e), sys.exc_info()[2])
def to_dict(collection, engine, key_selector, value_selector=None): """:yaql:dict Returns dict built on collection where keys are keySelector applied to collection elements and values are valueSelector applied to collection elements. :signature: collection.toDict(keySelector, valueSelector => null) :receiverArg collection: collection to build dict from :argType collection: iterable :arg keySelector: lambda function to get keys from collection elements :argType keySelector: lambda :arg valueSelector: lambda function to get values from collection elements. null by default, which means values to be collection items :argType valueSelector: lambda :returnType: dictionary .. code:: yaql> [1, 2].toDict($, $ + 1) {"1": 2, "2": 3} """ result = {} for t in collection: key = key_selector(t) value = t if value_selector is None else value_selector(t) result[key] = value utils.limit_memory_usage(engine, (1, result)) return result
def to_dict(collection, engine, key_selector, value_selector=None): result = {} for t in collection: key = key_selector(t) value = t if value_selector is None else value_selector(t) result[key] = value utils.limit_memory_usage(engine, (1, result)) return result
def distinct(engine, collection, key_selector=None): distinct_values = set() for t in collection: key = t if key_selector is None else key_selector(t) if key not in distinct_values: distinct_values.add(key) utils.limit_memory_usage(engine, (1, distinct_values)) yield t
def dict__(items, engine): result = {} for t in items: it = iter(t) key = next(it) value = next(it) result[key] = value utils.limit_memory_usage(engine, (1, result)) return utils.FrozenDict(result)
def combine_lists(left, right, engine): if isinstance(left, tuple) and isinstance(right, tuple): utils.limit_memory_usage(engine, (1, left), (1, right)) return left + right elif isinstance(left, frozenset) and isinstance(right, frozenset): utils.limit_memory_usage(engine, (1, left), (1, right)) return left.union(right) return yaql.standard_library.queries.concat(left, right)
def group_by(engine, collection, key_selector, value_selector=None, aggregator=None): groups = {} if aggregator is None: aggregator = lambda x: x for t in collection: value = t if value_selector is None else value_selector(t) groups.setdefault(key_selector(t), []).append(value) utils.limit_memory_usage(engine, (1, groups)) return select(six.iteritems(groups), aggregator)
def generate(engine, initial, predicate, producer, selector=None, decycle=False): past_items = None if not decycle else set() while predicate(initial): if past_items is not None: if initial in past_items: break past_items.add(initial) utils.limit_memory_usage(engine, (1, past_items)) if selector is None: yield initial else: yield selector(initial) initial = producer(initial)
def dict_(engine, *args): """:yaql:dict Returns dictionary of provided keyword values. :signature: dict([args]) :arg [args]: arguments to create a dictionary :argType [args]: mappings :returnType: dictionary .. code:: yaql> dict(a => 1, b => 2) { "a": 1, "b": 2} """ utils.limit_memory_usage(engine, *((1, arg) for arg in args)) return utils.FrozenDict((t.source, t.destination) for t in args)
def build_list(engine, *args): """:yaql:list Returns list of provided args. :signature: list([args]) :arg [args]: arguments to create a list :argType [args]: any types :returnType: list .. code:: yaql> list(1, "", 2) [1, "", 2] """ utils.limit_memory_usage(engine, *((1, t) for t in args)) return tuple(args)
def list_by_int(left, right, engine): """:yaql:operator * Returns sequence repeated count times. :signature: left * right :arg left: input sequence :argType left: sequence :arg right: multiplier :argType right: integer :returnType: sequence .. code:: yaql> [1, 2] * 2 [1, 2, 1, 2] """ utils.limit_memory_usage(engine, (-right + 1, []), (right, left)) return left * right
def dict_set_many(engine, d, replacements): """:yaql:set Returns dict with replacements keys set to replacements values. :signature: dict.set(replacements) :receiverArg dict: input dictionary :argType dict: dictionary :arg replacements: mapping with keys and values to be set on input dict :argType key: dictionary :returnType: dictionary .. code:: yaql> {"a" => 1, "b" => 2}.set({"b" => 3, "c" => 4}) {"a": 1, "c": 4, "b": 3} """ utils.limit_memory_usage(engine, (1, d), (1, replacements)) return utils.FrozenDict(itertools.chain(d.items(), replacements.items()))
def string_by_int(left, right, engine): """:yaql:operator * Returns string repeated count times. :signature: left * right :arg left: left operand :argType left: string :arg right: right operator, how many times repeat input string :argType right: integer :returnType: string .. code:: yaql> "ab" * 2 "abab" """ utils.limit_memory_usage(engine, (-right + 1, u''), (right, left)) return left * right
def dict_set_many_inline(engine, d, *args): """:yaql:set Returns dict with args keys set to args values. :signature: dict.set([args]) :receiverArg dict: input dictionary :argType dict: dictionary :arg [args]: key-values to be set on input dict :argType [args]: chain of mappings :returnType: dictionary .. code:: yaql> {"a" => 1, "b" => 2}.set("b" => 3, "c" => 4) {"a": 1, "c": 4, "b": 3} """ utils.limit_memory_usage(engine, (1, d), *((1, arg) for arg in args)) return utils.FrozenDict( itertools.chain(d.items(), ((t.source, t.destination) for t in args)))
def dict_set_many(engine, d, replacements): """:yaql:set Returns dict with replacements keys set to replacements values. :signature: dict.set(replacements) :receiverArg dict: input dictionary :argType dict: dictionary :arg replacements: mapping with keys and values to be set on input dict :argType key: dictionary :returnType: dictionary .. code:: yaql> {"a" => 1, "b" => 2}.set({"b" => 3, "c" => 4}) {"a": 1, "c": 4, "b": 3} """ utils.limit_memory_usage(engine, (1, d), (1, replacements)) return utils.FrozenDict(itertools.chain( six.iteritems(d), six.iteritems(replacements)))
def dict_set_many_inline(engine, d, *args): """:yaql:set Returns dict with args keys set to args values. :signature: dict.set([args]) :receiverArg dict: input dictionary :argType dict: dictionary :arg [args]: key-values to be set on input dict :argType [args]: chain of mappings :returnType: dictionary .. code:: yaql> {"a" => 1, "b" => 2}.set("b" => 3, "c" => 4) {"a": 1, "c": 4, "b": 3} """ utils.limit_memory_usage(engine, (1, d), *((1, arg) for arg in args)) return utils.FrozenDict(itertools.chain( six.iteritems(d), ((t.source, t.destination) for t in args)))
def combine_dicts(left, right, engine): """:yaql:operator + Returns combined left and right dictionaries. :signature: left + right :arg left: left dictionary :argType left: mapping :arg right: right dictionary :argType right: mapping :returnType: mapping .. code:: yaql> {"a" => 1, b => 2} + {"b" => 3, "c" => 4} {"a": 1, "c": 4, "b": 3} """ utils.limit_memory_usage(engine, (1, left), (1, right)) d = dict(left) d.update(right) return utils.FrozenDict(d)
def dict_set(engine, d, key, value): """:yaql:set Returns dict with provided key set to value. :signature: dict.set(key, value) :receiverArg dict: input dictionary :argType dict: dictionary :arg key: key :argType key: keyword :arg value: value to be set to input key :argType value: any :returnType: dictionary .. code:: yaql> {"a" => 1, "b" => 2}.set("c", 3) {"a": 1, "b": 2, "c": 3} yaql> {"a" => 1, "b" => 2}.set("b", 3) {"a": 1, "b": 3} """ utils.limit_memory_usage(engine, (1, d), (1, key), (1, value)) return utils.FrozenDict(itertools.chain(d.items(), ((key, value), )))
def dict__(items, engine): """:yaql:dict Returns dictionary with keys and values built on items pairs. :signature: dict(items) :arg items: list of pairs [key, value] for building dictionary :argType items: list :returnType: dictionary .. code:: yaql> dict([["a", 2], ["b", 4]]) {"a": 2, "b": 4} """ result = {} for t in items: it = iter(t) key = next(it) value = next(it) result[key] = value utils.limit_memory_usage(engine, (1, result)) return utils.FrozenDict(result)
def dict_set(engine, d, key, value): """:yaql:set Returns dict with provided key set to value. :signature: dict.set(key, value) :receiverArg dict: input dictionary :argType dict: dictionary :arg key: key :argType key: keyword :arg value: value to be set to input key :argType value: any :returnType: dictionary .. code:: yaql> {"a" => 1, "b" => 2}.set("c", 3) {"a": 1, "b": 2, "c": 3} yaql> {"a" => 1, "b" => 2}.set("b", 3) {"a": 1, "b": 3} """ utils.limit_memory_usage(engine, (1, d), (1, key), (1, value)) return utils.FrozenDict(itertools.chain(six.iteritems(d), ((key, value),)))
def generate_many(engine, initial, producer, selector=None, decycle=False, depth_first=False): past_items = None if not decycle else set() queue = utils.QueueType([initial]) while queue: item = queue.popleft() if past_items is not None: if item in past_items: continue else: past_items.add(item) utils.limit_memory_usage(engine, (1, past_items)) if selector is None: yield item else: yield selector(item) produced = producer(item) if depth_first: len_before = len(queue) queue.extend(produced) queue.rotate(len(queue) - len_before) else: queue.extend(produced) utils.limit_memory_usage(engine, (1, queue))
def combine_dicts(left, right, engine): utils.limit_memory_usage(engine, (1, left), (1, right)) d = dict(left) d.update(right) return utils.FrozenDict(d)
def dict_set(engine, d, key, value): utils.limit_memory_usage(engine, (1, d), (1, key), (1, value)) return utils.FrozenDict(itertools.chain(six.iteritems(d), ((key, value),)))
def list_by_int(left, right, engine): utils.limit_memory_usage(engine, (-right + 1, []), (right, left)) return left * right
def dict_set_many(engine, d, replacements): utils.limit_memory_usage(engine, (1, d), (1, replacements)) return utils.FrozenDict( itertools.chain(six.iteritems(d), six.iteritems(replacements)))
def dict_set_many_inline(engine, d, *args): utils.limit_memory_usage(engine, (1, d), *((1, arg) for arg in args)) return utils.FrozenDict( itertools.chain(six.iteritems(d), ((t.source, t.destination) for t in args)))
def string_by_int(left, right, engine): utils.limit_memory_usage(engine, (-right + 1, u''), (right, left)) return left * right
def dict_set(engine, d, key, value): utils.limit_memory_usage(engine, (1, d), (1, key), (1, value)) return utils.FrozenDict(itertools.chain(six.iteritems(d), ((key, value), )))
def convert(self, value, receiver, context, function_spec, engine, *args, **kwargs): if not self.check(value, context, engine, *args, **kwargs): raise exceptions.ArgumentValueException() utils.limit_memory_usage(engine, (1, value)) return value
def dict_set_many_inline(engine, d, *args): utils.limit_memory_usage(engine, (1, d), *((1, arg) for arg in args)) return utils.FrozenDict(itertools.chain( six.iteritems(d), ((t.source, t.destination) for t in args)))
def build_list(engine, *args): utils.limit_memory_usage(engine, *((1, t) for t in args)) return tuple(args)
def dict_(engine, *args): utils.limit_memory_usage(engine, *((1, arg) for arg in args)) return utils.FrozenDict((t.source, t.destination) for t in args)
def dict_set_many(engine, d, replacements): utils.limit_memory_usage(engine, (1, d), (1, replacements)) return utils.FrozenDict(itertools.chain( six.iteritems(d), six.iteritems(replacements)))