galaxy_graph 0.0.2__py3-none-any.whl

galaxy_graph/__init__.py

@@ -0,0 +1,11 @@
+"""Graph creation and management library."""
+
+from .connection import Connection
+from .graph import Graph
+from .node import Node
+
+__all__ = [
+    "Connection",
+    "Graph",
+    "Node",
+]

galaxy_graph/connection.py

@@ -0,0 +1,38 @@
+"""Connection class container."""
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+from uuid import uuid4
+
+if TYPE_CHECKING:
+    from .node import Node
+
+
+@dataclass
+class Connection:
+    """Connection between two nodes from the same graph."""
+
+    source: Node  # First node on "node 1 connection node 2"
+    destination: Node  # Last node on "node 1 connection node 2"
+    data: Any = None  # Data attached to this connection
+    identifier: str = field(default_factory=lambda: str(uuid4()))
+
+    @classmethod
+    def make(
+        cls,
+        node_1: Node,
+        node_2: Node,
+        data: Any = None,
+    ) -> Connection:
+        """Build a connection from its type."""
+        return cls(source=node_1, destination=node_2, data=data)
+
+    def __eq__(self, value: object, /) -> bool:
+        """Check equality."""
+        if not isinstance(value, Connection):
+            raise TypeError
+        return self.identifier == value.identifier
+
+    def __hash__(self) -> int:
+        """For built-in function hash()."""
+        return hash(self.identifier)

galaxy_graph/exception/__init__.py

@@ -0,0 +1,9 @@
+"""Exception of this module."""
+
+from .node_already_in_graph import NodeAlreadyInGraphError
+from .node_not_found import NodeNotFoundError
+
+__all__ = [
+    "NodeAlreadyInGraphError",
+    "NodeNotFoundError",
+]

galaxy_graph/exception/node_already_in_graph.py

@@ -0,0 +1,17 @@
+"""NodeAlreadyInGraph class container."""
+
+
+class NodeAlreadyInGraphError(Exception):
+    """Node already in graph."""
+
+    def __init__(self, identifier: str) -> None:
+        """
+        Error initialization.
+
+        Parameters
+        ----------
+        identifier: str
+            Node identifier
+
+        """
+        super().__init__(f"Node {identifier} already in graph")

galaxy_graph/exception/node_not_found.py

@@ -0,0 +1,17 @@
+"""NodeNotFound class container."""
+
+
+class NodeNotFoundError(Exception):
+    """Node not found."""
+
+    def __init__(self, identifier: str) -> None:
+        """
+        Error initialization.
+
+        Parameters
+        ----------
+        identifier: str
+            Node identifier
+
+        """
+        super().__init__(f"Node {identifier} not found")

galaxy_graph/graph.py

@@ -0,0 +1,99 @@
+"""Graph class container."""
+
+from contextlib import suppress
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+from uuid import uuid4
+
+from .exception import NodeAlreadyInGraphError, NodeNotFoundError
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from .node import Node
+
+
+@dataclass
+class Graph:
+    """Set of nodes."""
+
+    directed: bool  # If false, connections will be shared by both nodes
+    nodes: set[Node] = field(default_factory=set)  # Nodes in this graph
+    data: Any = None  # Data attached to this graph
+
+    def add(
+        self,
+        class_: type[Node],
+        data: Any = None,
+        identifier: str | None = None,
+    ) -> Graph:
+        """
+        Add a node to this graph quickly.
+
+        Parameters
+        ----------
+        class_: type[Node]
+            Class of the Node to add
+        data: Any
+            Data of the Node to add
+        identifier: str | None
+            Identifier of the Node. Random identifier if None
+
+        """
+        if identifier is None:
+            identifier = str(uuid4())
+        return self.add_node(
+            class_(
+                graph=self,
+                data=data,
+                identifier=identifier,
+            ),
+        )
+
+    def add_node(self, node: Node) -> Graph:
+        """Add a node to the graph, with all of its connections."""
+        try:
+            self.get_by_id(node.identifier)
+            raise NodeAlreadyInGraphError(node.identifier)
+        except NodeNotFoundError:
+            self.nodes.add(node)
+            for neighboor in node.get_neighbors():
+                with suppress(NodeAlreadyInGraphError):
+                    self.add_node(neighboor)
+            return self
+
+    def get_by_id(self, node_id: str) -> Node:
+        """Get a node from its node identifier."""
+        for node in self.nodes:
+            if node.identifier == node_id:
+                return node
+        raise NodeNotFoundError(node_id)
+
+    def get_by_class(self, class_: type[Node]) -> set[Node]:
+        """Get all node of a given class."""
+        return {node for node in self.nodes if isinstance(node, class_)}
+
+    def get_by_data(self, filter_: Callable[[Any], bool]) -> set[Node]:
+        """
+        Get all node of the graph respecting a condition on its data.
+
+        Return every nodes for which applying the node's data to filter
+        return True.
+        """
+        return {node for node in self.nodes if filter_(node.data)}
+
+    def delete_node(self, node_id: str) -> Node:
+        """Delete a node and all of its connections to other nodes."""
+        node = self.get_by_id(node_id=node_id)
+
+        self.nodes = {
+            node for node in self.nodes if node.identifier != node_id
+        }
+        for node in self.nodes:
+            node.connections = {
+                connection
+                for connection in node.connections
+                if connection.destination != node_id
+            }
+
+        return node

galaxy_graph/node.py

@@ -0,0 +1,99 @@
+"""Node class container."""
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+from uuid import uuid4
+
+from .exception import NodeNotFoundError
+
+if TYPE_CHECKING:
+    from .connection import Connection
+    from .graph import Graph
+
+
+@dataclass
+class Node:
+    """Singular element storing data."""
+
+    graph: Graph  # Graph containing this Node
+    data: Any = None  # Data attached to this node
+    identifier: str = field(default_factory=lambda: str(uuid4()))
+    connections: set[Connection] = field(default_factory=set)
+
+    def connect(
+        self,
+        connection: type[Connection],
+        node: Node,
+        data: Any = None,
+    ) -> Connection:
+        """
+        Connect this node to another one with a specific connection.
+
+        If the graph of the node is not directed, the other node will
+        have the same connection.
+
+        Parameters
+        ----------
+        connection: type[Connection]
+            Type of the connection
+        node: Node
+            Node to connect to
+        data: Any
+            Data of the connection
+
+        """
+        try:
+            _ = self.graph.get_by_id(node_id=self.identifier)
+        except NodeNotFoundError:
+            self.graph.add_node(node=self)
+
+        try:
+            _ = self.graph.get_by_id(node_id=node.identifier)
+        except NodeNotFoundError:
+            self.graph.add_node(node=node)
+
+        new_connection = connection.make(self, node, data)
+
+        self.connections.add(new_connection)
+
+        if not self.graph.directed:
+            node.connections.add(connection.make(node, self, data))
+
+        return new_connection
+
+    def get_neighbors(
+        self,
+        connection_type: type[Connection] | None = None,
+    ) -> set[Node]:
+        """
+        Get nodes linked to this node by at least one connection.
+
+        This can be filtered by the type of the connection, if
+        connection_type is not None.
+
+        Parameters
+        ----------
+        connection_type: type[Connection] | None
+            Type on the connection to filter. Every connections if None
+
+        """
+        if connection_type is None:
+            return {
+                connection.destination
+                for connection in self.connections
+            }
+        return {
+            connection.destination
+            for connection in self.connections
+            if isinstance(connection, connection_type)
+        }
+
+    def __eq__(self, value: object, /) -> bool:
+        """Check equality."""
+        if not isinstance(value, Node):
+            raise TypeError
+        return self.identifier == value.identifier
+
+    def __hash__(self) -> int:
+        """For built-in function hash()."""
+        return hash(self.identifier)

galaxy_graph-0.0.2.dist-info/METADATA

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: galaxy_graph
+Version: 0.0.2
+Summary: Graph creation and management
+Author-email: linarphy <linarphy@linarphy.net>
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.14

galaxy_graph-0.0.2.dist-info/RECORD

@@ -0,0 +1,10 @@
+galaxy_graph/__init__.py,sha256=Et8GkiD5I_dcdjFgd2X4jNZMOHiJnD9feiZCS8Ajixw,187
+galaxy_graph/connection.py,sha256=gNQN1Br0vo4rt89iRQ5tb-KouHAHFx5DPzv4bLGxsD4,1090
+galaxy_graph/graph.py,sha256=1N-kF0SNCZTu5zV3pCVILWvgjsKL8cnTksKTUdMuqCs,2987
+galaxy_graph/node.py,sha256=tgVRKTpNYTCb2cPvKbhdxFVOm_lnBShKSZQ_xiuFmCk,2753
+galaxy_graph/exception/__init__.py,sha256=MASGYxthFcmAeL5tGBNP6L3duMN0i51gZTVjew3FZec,209
+galaxy_graph/exception/node_already_in_graph.py,sha256=k5sNKbmb9bM5GT3O3P-Ss7yr2KfqXlsqHCMP6MW5yig,379
+galaxy_graph/exception/node_not_found.py,sha256=9wWzizelv3kG4tFqjeKy3Ni0su6sjnO7aArXCnhB8QA,353
+galaxy_graph-0.0.2.dist-info/METADATA,sha256=k29ARaVxDzVza5rPBP9bC9NHyKqarg9fQdU_k1YJntY,392
+galaxy_graph-0.0.2.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+galaxy_graph-0.0.2.dist-info/RECORD,,

galaxy_graph-0.0.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any