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 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 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):
""":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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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_(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 string_by_int(left, right, engine):
utils.limit_memory_usage(engine, (-right + 1, u''), (right, left))
return left * right
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)))
