computation-graph 62__tar.gz → 64__tar.gz

{computation_graph-62 → computation_graph-64}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: computation-graph
-Version: 62
+Version: 64
 Requires-Python: >=3
 Description-Content-Type: text/markdown
 License-File: LICENSE.md

{computation_graph-62 → computation_graph-64}/computation_graph/base_types.py

@@ -4,7 +4,7 @@ import dataclasses
 import functools
 import os
 import typing
-from typing import Callable, Hashable, Optional, Tuple, Union
+from typing import Callable, FrozenSet, Hashable, Optional, Tuple, Union
 
 import gamla
 
@@ -125,7 +125,8 @@ def edge_sources(edge: ComputationEdge) -> Tuple[ComputationNode, ...]:
 
 is_computation_graph = gamla.alljuxt(
     # Note that this cannot be set to `GraphType` (due to `is_instance` limitation).
-    gamla.is_instance(tuple),
+    gamla.is_instance((tuple, set, frozenset)),
+    gamla.len_greater(0),
     gamla.allmap(gamla.is_instance(ComputationEdge)),
 )
 
@@ -158,18 +159,17 @@ def _assert_no_unwanted_ambiguity_when_debug_set(graph):
         assert_no_unwanted_ambiguity(graph)
 
 
-merge_graphs = gamla.compose_left(
-    gamla.pack,
-    gamla.concat,
-    gamla.unique,
-    tuple,
-    _assert_no_unwanted_ambiguity_when_debug_set,
-)
+def merge_graphs(*graphs):
+    s = frozenset({})
+    s = s.union(*graphs)
+
+    return _assert_no_unwanted_ambiguity_when_debug_set(s)
+
 
 # We use a tuple to generate a unique id for each node based on the order of edges.
-GraphType = Tuple[ComputationEdge, ...]
+GraphType = FrozenSet[ComputationEdge]
 GraphOrCallable = Union[Callable, GraphType]
 CallableOrNode = Union[Callable, ComputationNode]
 CallableOrNodeOrGraph = Union[CallableOrNode, GraphType]
 NodeOrGraph = Union[ComputationNode, GraphType]
-EMPTY_GRAPH = ()
+EMPTY_GRAPH: GraphType = frozenset()

{computation_graph-62 → computation_graph-64}/computation_graph/composers/__init__.py

@@ -12,7 +12,7 @@ class _ComputationError:
 
 
 _callable_or_graph_type_to_node_or_graph_type = gamla.unless(
-    gamla.is_instance(tuple), graph.make_computation_node
+    gamla.is_instance((tuple, set, frozenset)), graph.make_computation_node
 )
 
 
@@ -20,7 +20,7 @@ def _get_edges_from_node_or_graph(
     node_or_graph: base_types.NodeOrGraph,
 ) -> base_types.GraphType:
     if isinstance(node_or_graph, base_types.ComputationNode):
-        return ()
+        return base_types.EMPTY_GRAPH
     return node_or_graph
 
 
@@ -145,7 +145,7 @@ def _infer_sink(graph_or_node: base_types.NodeOrGraph) -> base_types.Computation
             return gamla.head(result)
 
     assert len(_destinations(graph_or_node)) == 1, graph_or_node
-    return base_types.edge_destination(graph_or_node[0])
+    return base_types.edge_destination(gamla.head(graph_or_node))
 
 
 def make_first(*graphs: base_types.CallableOrNodeOrGraph) -> base_types.GraphType:

{computation_graph-62 → computation_graph-64}/computation_graph/composers/debug.py

@@ -43,5 +43,6 @@ debug_log = _debug_with_frame(_debug_log_inner)
 
 
 def name_callable(f: Callable, name: str) -> Callable:
+    f.__code__ = f.__code__.replace(co_name=name)
     f.__name__ = name
     return f

{computation_graph-62 → computation_graph-64}/computation_graph/composers/duplication.py

@@ -6,6 +6,7 @@ from typing import Dict
 import gamla
 
 from computation_graph import base_types, graph
+from computation_graph.composers import debug
 
 
 def duplicate_function(func):
@@ -15,14 +16,13 @@ def duplicate_function(func):
         async def inner(*args, **kwargs):
             return await func(*args, **kwargs)
 
-        return inner
+    else:
 
-    @functools.wraps(func)
-    def inner(*args, **kwargs):
-        return func(*args, **kwargs)
+        @functools.wraps(func)
+        def inner(*args, **kwargs):
+            return func(*args, **kwargs)
 
-    inner.__name__ = f"duplicate of {inner.__name__}"
-    return inner
+    return debug.name_callable(inner, f"duplicate of {func.__name__}")
 
 
 def _duplicate_computation_edge(get_duplicated_node):
@@ -69,7 +69,7 @@ duplicate_graph = gamla.compose_left(
 )
 
 duplicate_function_or_graph = gamla.ternary(
-    gamla.is_instance(tuple), duplicate_graph, duplicate_function
+    gamla.is_instance((tuple, set, frozenset)), duplicate_graph, duplicate_function
 )
 
 
@@ -100,7 +100,7 @@ def safe_replace_sources(
 
     def update_edge(e: base_types.ComputationEdge) -> base_types.GraphType:
         dest = base_types.edge_destination(e)
-        g = graph.replace_node(dest, get_node_replacement(dest))((e,))
+        g = graph.replace_node(dest, get_node_replacement(dest))(frozenset((e,)))
         for source in base_types.edge_sources(e):
             g = graph.replace_source(source, get_node_replacement(source), g)
         return g

{computation_graph-62 → computation_graph-64}/computation_graph/graph.py

@@ -41,28 +41,22 @@ def make_computation_node(
 
 
 def get_leaves(edges: base_types.GraphType) -> FrozenSet[base_types.ComputationNode]:
-    return opt_gamla.pipe(
-        edges,
-        get_all_nodes,
-        opt_gamla.remove(
-            opt_gamla.pipe(
-                edges,
-                opt_gamla.mapcat(lambda edge: (edge.source, *edge.args)),
-                frozenset,
-                gamla.contains,
-            )
-        ),
-        frozenset,
+    all_nodes = get_all_nodes(edges)
+    all_destinations = frozenset(
+        gamla.concat((edge.source, *edge.args) for edge in edges)
     )
+    return all_nodes - all_destinations
 
 
-sink_excluding_terminals = opt_gamla.compose_left(
-    get_leaves,
-    opt_gamla.remove(base_types.node_is_terminal),
-    tuple,
-    gamla.assert_that(gamla.len_equals(1)),
-    gamla.head,
-)
+def sink_excluding_terminals(edges: base_types.GraphType) -> base_types.ComputationNode:
+    leaves_not_terminal = frozenset(
+        node for node in get_leaves(edges) if not node.is_terminal
+    )
+    assert (
+        len(leaves_not_terminal) == 1
+    ), f"Expected exactly one non-terminal sink, got {leaves_not_terminal}"
+    return gamla.head(leaves_not_terminal)
+
 
 get_incoming_edges_for_node = opt_gamla.compose_left(
     opt_gamla.groupby(base_types.edge_destination),
@@ -184,7 +178,7 @@ def replace_source(
     if base_types.is_computation_graph(replacement):
         return gamla.pipe(
             current_graph,
-            _replace_source_in_edges(original, sink_excluding_terminals(replacement)),
+            _replace_source_in_edges(original, sink_excluding_terminals(replacement)),  # type: ignore
             gamla.concat_with(replacement),
             tuple,
         )

{computation_graph-62 → computation_graph-64}/computation_graph/graph_test.py

@@ -834,30 +834,34 @@ def test_replace_source_with_args():
                 key="args",
             ),
         )
-    ) == (
-        base_types.ComputationEdge(
-            is_future=False,
-            priority=0,
-            source=None,
-            args=(
-                graph.make_computation_node(_node1_async),
-                graph.make_computation_node(_node2),
+    ) == frozenset(
+        (
+            base_types.ComputationEdge(
+                is_future=False,
+                priority=0,
+                source=None,
+                args=(
+                    graph.make_computation_node(_node1_async),
+                    graph.make_computation_node(_node2),
+                ),
+                destination=graph.make_computation_node(_merger),
+                key="args",
             ),
-            destination=graph.make_computation_node(_merger),
-            key="args",
-        ),
+        )
     )
 
 
 def test_replace_source_with_graph():
     a = graph.make_source()
 
-    assert graph.replace_source(
-        _node1, composers.compose_left_unary(_node1_async, _next_int)
-    )(
-        base_types.merge_graphs(
-            composers.compose_source_unary(_node1, a),
-            composers.compose_left_unary(_node1, _node2),
+    assert frozenset(
+        graph.replace_source(
+            _node1, composers.compose_left_unary(_node1_async, _next_int)
+        )(
+            base_types.merge_graphs(
+                composers.compose_source_unary(_node1, a),
+                composers.compose_left_unary(_node1, _node2),
+            )
         )
     ) == base_types.merge_graphs(
         composers.compose_source_unary(_node1, a),
@@ -970,12 +974,12 @@ def kuku():
 
 t = graph.make_terminal("t", lambda x: x)
 
-g = (
-    composers.compose_left(a, c)
-    + composers.compose_left(c, d, key="x")
-    + composers.compose_left(b, d, key="y")
-    + composers.compose_left_future(d, b, "x", "bla")
-    + composers.compose_left(a, t)
+g = base_types.merge_graphs(
+    composers.compose_left(a, c),
+    composers.compose_left(c, d, key="x"),
+    composers.compose_left(b, d, key="y"),
+    composers.compose_left_future(d, b, "x", "bla"),
+    composers.compose_left(a, t),
 )
 
 

{computation_graph-62 → computation_graph-64}/computation_graph.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: computation-graph
-Version: 62
+Version: 64
 Requires-Python: >=3
 Description-Content-Type: text/markdown
 License-File: LICENSE.md

{computation_graph-62 → computation_graph-64}/setup.py

@@ -7,7 +7,7 @@ with open("README.md", "r") as fh:
 setuptools.setup(
     name="computation-graph",
     python_requires=">=3",
-    version="62",
+    version="64",
     long_description=_LONG_DESCRIPTION,
     long_description_content_type="text/markdown",
     packages=setuptools.find_namespace_packages(),