implica 0.3.1__tar.gz → 0.3.2__tar.gz

{implica-0.3.1 → implica-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: implica
-Version: 0.3.1
+Version: 0.3.2
 Summary: A package for working with graphs representing minimal implicational logic models
 Author: Carlos Fernandez
 Author-email: carlos.ferlo@outlook.com

{implica-0.3.1 → implica-0.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "implica"
-version = "0.3.1"
+version = "0.3.2"
 description = "A package for working with graphs representing minimal implicational logic models"
 authors = ["Carlos Fernandez <carlos.ferlo@outlook.com>"]
 readme = "README.md"

{implica-0.3.1 → implica-0.3.2}/src/implica/__init__.py

@@ -1,21 +1,21 @@
 """
-Guanciale - Implicational Logic Graph Library
+Implica - Implicational Logic Graph Library
 
 A Python package for working with graphs representing minimal implicational
 logic models. This library provides tools for constructing and manipulating
 type systems based on combinatory logic, with support for transactional
 graph operations.
 
-Import as 'gil' for a clean, concise API:
-    import guanciale as gil
+Import as 'imp' for a clean, concise API:
+    import implica as imp
 
-    graph = gil.Graph()
-    A = gil.var("A")
-    B = gil.var("B")
+    graph = imp.Graph()
+    A = imp.var("A")
+    B = imp.var("B")
 
     with graph.connect() as conn:
-        conn.add_node(gil.node(A))
-        conn.add_node(gil.node(B))
+        conn.add_node(imp.node(A))
+        conn.add_node(imp.node(B))
 """
 
 from .core import *
@@ -41,4 +41,4 @@ __all__ = [
     "mutations",
 ]
 
-__version__ = "0.3.1"
+__version__ = "0.3.2"

{implica-0.3.1 → implica-0.3.2}/src/implica/graph/connection.py

@@ -23,6 +23,10 @@ from ..mutations import (
     RemoveManyEdges,
     TryRemoveNode,
     TryRemoveEdge,
+    TryAddManyNodes,
+    TryAddManyEdges,
+    TryRemoveManyNodes,
+    TryRemoveManyEdges,
 )
 
 if TYPE_CHECKING:
@@ -225,6 +229,52 @@ class Connection:
         self.mutations.append(TryAddEdge(e))
         return self
 
+    def try_add_many_nodes(self, nodes: list[Node]) -> "Connection":
+        """
+        Add a mutation to create multiple nodes, or do nothing for nodes that already exist.
+
+        Args:
+            nodes: List of nodes to add
+
+        Returns:
+            Connection: Self for method chaining
+        """
+        self._check_state()
+        self.mutations.append(TryAddManyNodes(nodes))
+        return self
+
+    def try_add_many_edges(self, combinators: list[Combinator]) -> "Connection":
+        """
+        Add a mutation to create multiple edges from combinators, or do nothing for edges that already exist.
+
+        Args:
+            combinators: List of combinators for the edges
+
+        Returns:
+            Connection: Self for method chaining
+
+        Raises:
+            ValueError: If any combinator doesn't have an Application type
+        """
+        self._check_state()
+
+        # Import here to avoid circular import
+        from .elements import edge
+        from ..core.types import Application
+
+        # Validate all combinators and create edges
+        edges = []
+        for combinator in combinators:
+            if not isinstance(combinator.type, Application):
+                raise ValueError(
+                    f"Combinator must have an Application type to create an edge, "
+                    f"got {type(combinator.type).__name__}"
+                )
+            edges.append(edge(combinator))
+
+        self.mutations.append(TryAddManyEdges(edges))
+        return self
+
     def remove_many_nodes(self, node_uids: list[str]) -> "Connection":
         """
         Add a mutation to remove multiple nodes.
@@ -281,6 +331,34 @@ class Connection:
         self.mutations.append(TryRemoveEdge(edge_uid))
         return self
 
+    def try_remove_many_nodes(self, node_uids: list[str]) -> "Connection":
+        """
+        Add a mutation to remove multiple nodes, or do nothing for nodes that don't exist.
+
+        Args:
+            node_uids: List of node uids to remove
+
+        Returns:
+            Connection: Self for method chaining
+        """
+        self._check_state()
+        self.mutations.append(TryRemoveManyNodes(node_uids))
+        return self
+
+    def try_remove_many_edges(self, edge_uids: list[str]) -> "Connection":
+        """
+        Add a mutation to remove multiple edges, or do nothing for edges that don't exist.
+
+        Args:
+            edge_uids: List of edge uids to remove
+
+        Returns:
+            Connection: Self for method chaining
+        """
+        self._check_state()
+        self.mutations.append(TryRemoveManyEdges(edge_uids))
+        return self
+
     def commit(self) -> None:
         """
         Commit all mutations to the graph.

{implica-0.3.1 → implica-0.3.2}/src/implica/mutations/__init__.py

@@ -11,6 +11,10 @@ from .add_many_nodes import AddManyNodes
 from .add_many_edges import AddManyEdges
 from .remove_many_nodes import RemoveManyNodes
 from .remove_many_edges import RemoveManyEdges
+from .try_add_many_nodes import TryAddManyNodes
+from .try_add_many_edges import TryAddManyEdges
+from .try_remove_many_nodes import TryRemoveManyNodes
+from .try_remove_many_edges import TryRemoveManyEdges
 
 __all__ = [
     "Mutation",
@@ -26,4 +30,8 @@ __all__ = [
     "AddManyEdges",
     "RemoveManyNodes",
     "RemoveManyEdges",
+    "TryAddManyNodes",
+    "TryAddManyEdges",
+    "TryRemoveManyNodes",
+    "TryRemoveManyEdges",
 ]

implica-0.3.2/src/implica/mutations/try_add_many_edges.py

@@ -0,0 +1,63 @@
+from typing import TYPE_CHECKING
+
+from ..graph.elements import Edge
+from .base import Mutation
+
+if TYPE_CHECKING:
+    from ..graph.graph import Graph
+
+
+class TryAddManyEdges(Mutation):
+    """Mutation to add multiple edges to the graph, skipping edges that already exist."""
+
+    def __init__(self, edges: list[Edge]):
+        """
+        Initialize the TryAddManyEdges mutation.
+
+        Args:
+            edges: List of edges to add
+        """
+        self.edges = edges
+        self._added_edges: list[Edge] = []
+
+    def forward(self, graph: "Graph") -> None:
+        """
+        Try to add all edges to the graph.
+
+        Edges that already exist in the graph are skipped without raising an error.
+
+        Args:
+            graph: The graph to modify
+
+        Raises:
+            KeyError: If source or destination nodes don't exist for an edge
+        """
+        self._added_edges = []
+
+        try:
+            for edge in self.edges:
+                if not graph.has_edge(edge.uid):
+                    graph._add_edge(edge)
+                    self._added_edges.append(edge)
+        except Exception:
+            # Rollback: remove all edges that were added
+            for edge in self._added_edges:
+                graph._remove_edge(edge.uid)
+            self._added_edges = []
+            raise
+
+    def backward(self, graph: "Graph") -> None:
+        """
+        Remove all edges that were added.
+
+        Args:
+            graph: The graph to modify
+        """
+        for edge in reversed(self._added_edges):
+            graph._remove_edge(edge.uid)
+
+    def __str__(self) -> str:
+        """Return a string representation."""
+        return (
+            f"TryAddManyEdges(count={len(self.edges)}, added={len(self._added_edges)})"
+        )

implica-0.3.2/src/implica/mutations/try_add_many_nodes.py

@@ -0,0 +1,53 @@
+from typing import TYPE_CHECKING
+
+from ..graph.elements import Node
+from .base import Mutation
+
+if TYPE_CHECKING:
+    from ..graph.graph import Graph
+
+
+class TryAddManyNodes(Mutation):
+    """Mutation to add multiple nodes to the graph, skipping nodes that already exist."""
+
+    def __init__(self, nodes: list[Node]):
+        """
+        Initialize the TryAddManyNodes mutation.
+
+        Args:
+            nodes: List of nodes to add
+        """
+        self.nodes = nodes
+        self._added_nodes: list[Node] = []
+
+    def forward(self, graph: "Graph") -> None:
+        """
+        Try to add all nodes to the graph.
+
+        Nodes that already exist in the graph are skipped without raising an error.
+
+        Args:
+            graph: The graph to modify
+        """
+        self._added_nodes = []
+
+        for node in self.nodes:
+            if not graph.has_node(node.uid):
+                graph._add_node(node)
+                self._added_nodes.append(node)
+
+    def backward(self, graph: "Graph") -> None:
+        """
+        Remove all nodes that were added.
+
+        Args:
+            graph: The graph to modify
+        """
+        for node in reversed(self._added_nodes):
+            graph._remove_node(node.uid)
+
+    def __str__(self) -> str:
+        """Return a string representation."""
+        return (
+            f"TryAddManyNodes(count={len(self.nodes)}, added={len(self._added_nodes)})"
+        )

implica-0.3.2/src/implica/mutations/try_remove_many_edges.py

@@ -0,0 +1,55 @@
+from typing import TYPE_CHECKING
+
+from ..graph.elements import Edge
+from .base import Mutation
+
+if TYPE_CHECKING:
+    from ..graph.graph import Graph
+
+
+class TryRemoveManyEdges(Mutation):
+    """Mutation to remove multiple edges from the graph, skipping edges that don't exist."""
+
+    def __init__(self, edge_uids: list[str]):
+        """
+        Initialize the TryRemoveManyEdges mutation.
+
+        Args:
+            edge_uids: List of edge UIDs to remove
+        """
+        self.edge_uids = edge_uids
+        self._removed_edges: list[Edge] = []
+
+    def forward(self, graph: "Graph") -> None:
+        """
+        Try to remove all edges from the graph.
+
+        Edges that don't exist in the graph are skipped without raising an error.
+
+        Args:
+            graph: The graph to modify
+        """
+        self._removed_edges = []
+
+        for edge_uid in self.edge_uids:
+            if graph.has_edge(edge_uid):
+                # Store the edge for rollback
+                removed_edge = graph.get_edge(edge_uid)
+                self._removed_edges.append(removed_edge)
+
+                # Remove the edge
+                graph._remove_edge(edge_uid)
+
+    def backward(self, graph: "Graph") -> None:
+        """
+        Re-add all edges that were removed.
+
+        Args:
+            graph: The graph to modify
+        """
+        for edge in reversed(self._removed_edges):
+            graph._add_edge(edge)
+
+    def __str__(self) -> str:
+        """Return a string representation."""
+        return f"TryRemoveManyEdges(count={len(self.edge_uids)}, removed={len(self._removed_edges)})"

implica-0.3.2/src/implica/mutations/try_remove_many_nodes.py

@@ -0,0 +1,58 @@
+from typing import TYPE_CHECKING
+
+from ..graph import Edge, Node
+from .base import Mutation
+
+if TYPE_CHECKING:
+    from ..graph import Graph
+
+
+class TryRemoveManyNodes(Mutation):
+    """Mutation to remove multiple nodes from the graph, skipping nodes that don't exist."""
+
+    def __init__(self, node_uids: list[str]):
+        """
+        Initialize the TryRemoveManyNodes mutation.
+
+        Args:
+            node_uids: List of node UIDs to remove
+        """
+        self.node_uids = node_uids
+        self._removed_data: list[tuple[Node, list[Edge]]] = []
+
+    def forward(self, graph: "Graph") -> None:
+        """
+        Try to remove all nodes from the graph.
+
+        Nodes that don't exist in the graph are skipped without raising an error.
+
+        Args:
+            graph: The graph to modify
+        """
+        self._removed_data = []
+
+        for node_uid in self.node_uids:
+            if graph.has_node(node_uid):
+                # Store the node and its edges for rollback
+                removed_node = graph.get_node(node_uid)
+                removed_edges = graph.get_edges_for_node(node_uid)
+                self._removed_data.append((removed_node, removed_edges))
+
+                # Remove the node
+                graph._remove_node(node_uid)
+
+    def backward(self, graph: "Graph") -> None:
+        """
+        Re-add all nodes and edges that were removed.
+
+        Args:
+            graph: The graph to modify
+        """
+        for removed_node, removed_edges in reversed(self._removed_data):
+            graph._add_node(removed_node)
+            for edge in removed_edges:
+                graph._add_edge(edge)
+
+    def __str__(self) -> str:
+        """Return a string representation."""
+        return f"TryRemoveManyNodes(count={len(self.node_uids)}, removed={len(self._removed_data)})"