def test_empty_pipe():
with pytest.raises(functional_generic.PipeNotGivenAnyFunctions):
functional_generic.pipe([
1,
2,
3,
], )
async def _async_graph_traverse_many_inner(
seen: Set[_Node],
get_neighbors: Callable[[_Node], Awaitable[Iterable[_Node]]],
process_node: Callable[[_Node], None],
roots: Iterable[_Node],
):
assert set(roots).isdisjoint(seen)
functional_generic.pipe(
roots,
functional_generic.juxt(
seen.update,
functional_generic.compose_left(
functional_generic.curried_map(process_node),
tuple,
),
),
)
await functional_generic.pipe(
roots,
functional_generic.mapcat(get_neighbors),
functional_generic.remove(functional.contains(seen)),
frozenset,
functional_generic.unless(
functional.empty,
_async_graph_traverse_many_inner(seen, get_neighbors,
process_node),
),
)
def test_latency():
start_time = time.time()
for _ in range(1000):
functional_generic.pipe(
True,
functional_generic.juxt(functional.equals(True),
functional.equals(False)),
functional.head,
functional.just("bla"),
functional.attrgetter("lower"),
)
assert time.time() - start_time < 0.1
def groupby_many(f: Callable, it: Iterable) -> Dict[Text, Any]:
"""Return a mapping `{y: {x s.t. y in f(x)}}, where x in it. `
Parameters:
Key function (gets an object in collection and outputs tuple of keys).
A Collection.
Returns a dictionary where key has been computed by the `f` key function.
>>> names = ['alice', 'bob', 'charlie', 'dan', 'edith', 'frank']
>>> groupby_many(lambda name: (name[0], name[-1]), names)
{'a': frozenset({'alice'}),
'e': frozenset({'alice', 'charlie', 'edith'}),
'b': frozenset({'bob'}),
'c': frozenset({'charlie'}),
'd': frozenset({'dan'}),
'n': frozenset({'dan'}),
'h': frozenset({'edith'}),
'f': frozenset({'frank'}),
'k': frozenset({'frank'})}"""
return functional_generic.pipe(
it,
functional_generic.mapcat(
functional_generic.compose_left(
lambda element: (f(element), [element]),
sync.star(itertools.product),
), ),
edges_to_graph,
)
def _has_cycle(sourced, get_neighbors, visited, node):
if node in sourced:
return True
if node in visited:
return False
visited.add(node)
return functional_generic.pipe(
node,
get_neighbors,
functional_generic.anymap(
_has_cycle(sourced | {node}, get_neighbors, visited)),
)
def test_explode():
assert functional_generic.pipe(
[
"x",
[
"y1",
"y2",
"y3",
],
"z",
],
data.explode(1),
tuple,
) == (
("x", "y1", "z"),
("x", "y2", "z"),
("x", "y3", "z"),
)
def has_cycle(graph):
"""Gets a graph, returns True if it contains a cycle, False else.
>>> has_cycle({1: [2], 2: [3], 3: [1]})
True
>>> has_cycle({1: [2], 2: [3]})
False"""
return functional_generic.pipe(
graph,
dict.keys,
functional_generic.curried_map(
_has_cycle(
frozenset(),
dict_utils.dict_to_getter_with_default((), graph),
set(),
), ),
any,
)
def tuple_of_tuples_to_csv(
tuple_of_tuples: Tuple[Tuple[Any], ...],
separator: Text = "\t",
) -> Text:
"""Return a CSV formatted string given a tuple of tuples. Each element is separated by the character "separator" (default is \t).
>>> tuple_of_tuples_to_csv((("name", "age"), ("David", "23"), ("Itay", "26")))
'name\\tage\\nDavid\\t23\\nItay\\t26'
>>> tuple_of_tuples_to_csv((("name", "age"), ("David", "23"), ("Itay", "26")), " ")
'name age\\nDavid 23\\nItay 26'
"""
return functional_generic.pipe(
tuple_of_tuples,
functional_generic.curried_map(
functional_generic.compose_left(
functional_generic.curried_map(str),
tuple,
separator.join,
),
),
"\n".join,
)
def test_wrap_str():
assert functional_generic.pipe("john",
functional.wrap_str("hi {}")) == "hi john"
async def test_anymap_in_pipe():
assert not functional_generic.pipe(
[True, True, False],
functional_generic.allmap(operator.not_),
)