computation-graph 63__tar.gz → 65__tar.gz

{computation_graph-63 → computation_graph-65}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: computation-graph
-Version: 63
+Version: 65
 Requires-Python: >=3
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
@@ -12,6 +12,12 @@ Requires-Dist: termcolor
 Provides-Extra: test
 Requires-Dist: pygraphviz; extra == "test"
 Requires-Dist: pytest>=5.4.0; extra == "test"
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
 
 [![Build Status](https://travis-ci.com/hyroai/computation-graph.svg?branch=master)](https://travis-ci.com/hyroai/computation-graph)
 

{computation_graph-63 → computation_graph-65}/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-63 → computation_graph-65}/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-63 → computation_graph-65}/computation_graph/composers/duplication.py

@@ -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-63 → computation_graph-65}/computation_graph/composers/lift.py

@@ -5,11 +5,19 @@ import gamla
 from computation_graph import base_types, composers
 
 
+def _short_name(x) -> str:
+    if x is None or isinstance(x, (int, float, str)):
+        return f"{x!s:.30}"
+    if isinstance(x, (dict, list, tuple, set, frozenset)):
+        return f"{type(x).__name__}[{len(x)}]"
+    return type(x).__name__
+
+
 def always(x):
     def always():
         return x
 
-    always.__name__ = f"always {x!s:.30}"
+    always.__name__ = f"always {_short_name(x)}"
     return always
 
 

computation_graph-65/computation_graph/composers/lift_test.py

@@ -0,0 +1,42 @@
+from computation_graph.composers import lift
+
+
+def test_always_returns_the_value():
+    assert lift.always(5)() == 5
+    obj = {"a": 1}
+    assert lift.always(obj)() is obj
+
+
+def test_always_name_keeps_scalars_readable():
+    assert lift.always(5).__name__ == "always 5"
+    assert lift.always(3.5).__name__ == "always 3.5"
+    assert lift.always("cardiology").__name__ == "always cardiology"
+    assert lift.always(None).__name__ == "always None"
+
+
+def test_always_name_summarizes_containers_by_type_and_length():
+    assert lift.always({"a": 1, "b": 2}).__name__ == "always dict[2]"
+    assert lift.always([1, 2, 3]).__name__ == "always list[3]"
+    assert lift.always((1, 2)).__name__ == "always tuple[2]"
+
+
+def test_always_name_does_not_render_large_container_contents():
+    # The point of the summary: naming a node must not stringify a huge value.
+    name = lift.always({i: i for i in range(10_000)}).__name__
+    assert name == "always dict[10000]"
+
+
+def test_always_name_falls_back_to_type_for_other_objects():
+    class Custom:
+        pass
+
+    assert lift.always(Custom()).__name__ == "always Custom"
+
+
+def test_distinct_always_calls_produce_distinct_nodes_despite_equal_names():
+    # Names are display-only; node identity is hash(func), and every always()
+    # call is a fresh function, so equal names must not collapse two nodes.
+    a, b = lift.always({"x": 1}), lift.always({"y": 2})
+    assert a.__name__ == b.__name__ == "always dict[1]"
+    assert a is not b
+    assert hash(a) != hash(b)

{computation_graph-63 → computation_graph-65}/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-63 → computation_graph-65}/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-63 → computation_graph-65}/computation_graph.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: computation-graph
-Version: 63
+Version: 65
 Requires-Python: >=3
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
@@ -12,6 +12,12 @@ Requires-Dist: termcolor
 Provides-Extra: test
 Requires-Dist: pygraphviz; extra == "test"
 Requires-Dist: pytest>=5.4.0; extra == "test"
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
 
 [![Build Status](https://travis-ci.com/hyroai/computation-graph.svg?branch=master)](https://travis-ci.com/hyroai/computation-graph)
 

{computation_graph-63 → computation_graph-65}/computation_graph.egg-info/SOURCES.txt

@@ -22,6 +22,7 @@ computation_graph/composers/condition_test.py
 computation_graph/composers/debug.py
 computation_graph/composers/duplication.py
 computation_graph/composers/lift.py
+computation_graph/composers/lift_test.py
 computation_graph/composers/logic.py
 computation_graph/composers/memory.py
 computation_graph/composers/memory_test.py

{computation_graph-63 → computation_graph-65}/setup.py

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