core-data-structures 1.4.0__tar.gz → 1.4.1__tar.gz

{core_data_structures-1.4.0 → core_data_structures-1.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: core-data-structures
-Version: 1.4.0
+Version: 1.4.1
 Summary: This project/library contains commons data structures...
 Author-email: Alejandro Cora González <alek.cora.glez@gmail.com>
 Maintainer: Alejandro Cora González
@@ -22,6 +22,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Typing :: Typed
 Requires-Python: >=3.9
 Description-Content-Type: text/x-rst
 License-File: LICENSE
@@ -29,7 +30,7 @@ Requires-Dist: core-mixins>=3.2.0
 Requires-Dist: typing-extensions>=4.8.0
 Provides-Extra: dev
 Requires-Dist: core-dev-tools>=2.1.0; extra == "dev"
-Requires-Dist: core-tests>=2.1.0; extra == "dev"
+Requires-Dist: core-tests>=2.3.0; extra == "dev"
 Dynamic: license-file
 
 core-data-structures

{core_data_structures-1.4.0 → core_data_structures-1.4.1}/core_data_structures.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: core-data-structures
-Version: 1.4.0
+Version: 1.4.1
 Summary: This project/library contains commons data structures...
 Author-email: Alejandro Cora González <alek.cora.glez@gmail.com>
 Maintainer: Alejandro Cora González
@@ -22,6 +22,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Typing :: Typed
 Requires-Python: >=3.9
 Description-Content-Type: text/x-rst
 License-File: LICENSE
@@ -29,7 +30,7 @@ Requires-Dist: core-mixins>=3.2.0
 Requires-Dist: typing-extensions>=4.8.0
 Provides-Extra: dev
 Requires-Dist: core-dev-tools>=2.1.0; extra == "dev"
-Requires-Dist: core-tests>=2.1.0; extra == "dev"
+Requires-Dist: core-tests>=2.3.0; extra == "dev"
 Dynamic: license-file
 
 core-data-structures

{core_data_structures-1.4.0 → core_data_structures-1.4.1}/core_data_structures.egg-info/requires.txt

@@ -3,4 +3,4 @@ typing-extensions>=4.8.0
 
 [dev]
 core-dev-tools>=2.1.0
-core-tests>=2.1.0
+core-tests>=2.3.0

{core_data_structures-1.4.0 → core_data_structures-1.4.1}/data_structures/__init__.py

@@ -1,10 +1,6 @@
-# -*- coding: utf-8 -*-
-
 """Core data structures package."""
 
-from importlib.metadata import PackageNotFoundError
-from importlib.metadata import version
-
+from importlib.metadata import PackageNotFoundError, version
 
 try:
     __version__ = version("core-data-structures")

{core_data_structures-1.4.0 → core_data_structures-1.4.1}/data_structures/base.py

@@ -1,11 +1,8 @@
-# -*- coding: utf-8 -*-
-
 """Base node used as a building block across data structures."""
 
-from typing import Generic
-from typing import Optional
-from typing import TypeVar
+from __future__ import annotations
 
+from typing import Generic, TypeVar
 
 __all__ = [
     "Node",
@@ -21,15 +18,15 @@ class Node(Generic[T]):  # pylint: disable=too-few-public-methods
     subclassed by concrete node types.
     """
 
-    def __init__(self, value: Optional[T] = None) -> None:
+    def __init__(self, value: T | None = None) -> None:
         self._value = value
 
     def __repr__(self):
         return f"[{self._value}]"
 
     @property
-    def value(self) -> Optional[T]:
-        """ The value held by the node. """
+    def value(self) -> T | None:
+        """The value held by the node."""
         return self._value
 
     @value.setter

{core_data_structures-1.4.0 → core_data_structures-1.4.1}/data_structures/graphs/__init__.py

@@ -1,10 +1,7 @@
-# -*- coding: utf-8 -*-
-
 """Graph data structures package."""
 
 from .graphs import Graph
-from . vertex import Vertex
-
+from .vertex import Vertex
 
 __all__ = [
     "Graph",

{core_data_structures-1.4.0 → core_data_structures-1.4.1}/data_structures/graphs/graphs.py

@@ -1,10 +1,10 @@
-# -*- coding: utf-8 -*-
-
 """Graph data structure with common traversal and path-finding algorithms."""
 
+from __future__ import annotations
+
 import json
 from queue import Queue
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 from .vertex import Vertex
 
@@ -29,13 +29,9 @@ class Graph:
                  E --- F
         """
 
-        return cls.build_graph({
-            "A": ["B", "C"],
-            "B": ["C", "D"],
-            "C": ["D"],
-            "D": ["E", "F"],
-            "E": ["F"]
-        })
+        return cls.build_graph(
+            {"A": ["B", "C"], "B": ["C", "D"], "C": ["D"], "D": ["E", "F"], "E": ["F"]}
+        )
 
     def __iter__(self):
         return iter(self.vertices.values())
@@ -44,19 +40,23 @@ class Graph:
         return key in self.vertices
 
     def __str__(self):
-        return json.dumps({
-            key: list(vertex.get_connections_ids())
-            for key, vertex in self.vertices.items()
-        })
+        return json.dumps(
+            {
+                key: list(vertex.get_connections_ids())
+                for key, vertex in self.vertices.items()
+            }
+        )
 
     def __repr__(self):
-        return json.dumps({
-            key: list(vertex.get_connections_ids())
-            for key, vertex in self.vertices.items()
-        })
+        return json.dumps(
+            {
+                key: list(vertex.get_connections_ids())
+                for key, vertex in self.vertices.items()
+            }
+        )
 
     @classmethod
-    def build_graph(cls, graph_definition: Dict[Any, List]):
+    def build_graph(cls, graph_definition: dict[Any, list]):
         """
         Create a Graph
 
@@ -75,23 +75,23 @@ class Graph:
         return graph
 
     def add_vertex(self, key) -> Vertex:
-        """ Add a vertex for the given key if it does not already exist and return it. """
+        """Add a vertex for the given key if it does not already exist and return it."""
 
         if key not in self.vertices:
             self.vertices[key] = Vertex(key)
 
         return self.vertices[key]
 
-    def get_vertex(self, key) -> Optional[Vertex]:
-        """ Return a vertex by key """
+    def get_vertex(self, key) -> Vertex | None:
+        """Return a vertex by key"""
         return self.vertices.get(key, None)
 
-    def get_vertices(self) -> Dict:
-        """ Return all vertices """
+    def get_vertices(self) -> dict:
+        """Return all vertices"""
         return self.vertices
 
     def add_edge(self, key_vertex1, key_vertex2, weight=0):
-        """ Add a directed edge from key_vertex1 to key_vertex2 with an optional weight. """
+        """Add a directed edge from key_vertex1 to key_vertex2 with an optional weight."""
 
         if key_vertex1 not in self.vertices:
             self.add_vertex(key_vertex1)
@@ -124,7 +124,7 @@ class Graph:
 
         return visited
 
-    def depth_first_search(self, node_id, visited: Optional[List] = None):
+    def depth_first_search(self, node_id, visited: list | None = None):
         """
         Depth First Traversal Algorithm...
 
@@ -147,7 +147,7 @@ class Graph:
 
         return visited
 
-    def find_path(self, start, end, path: Optional[List] = None):
+    def find_path(self, start, end, path: list | None = None):
         """
         Determine a path between two nodes...
 
@@ -178,7 +178,7 @@ class Graph:
 
         return None
 
-    def find_all_paths(self, start, end, path: Optional[List] = None):
+    def find_all_paths(self, start, end, path: list | None = None):
         """
         Determine all paths between two nodes...
 

{core_data_structures-1.4.0 → core_data_structures-1.4.1}/data_structures/graphs/vertex.py

@@ -1,11 +1,8 @@
-# -*- coding: utf-8 -*-
-
 """Vertex node used within graph data structures."""
 
 import sys
-from typing import Dict, List
 
-if sys.version_info >= (3, 11):
+if sys.version_info >= (3, 11):  # pragma: no cover
     from typing import Self
 else:  # pragma: no cover
     from typing_extensions import Self
@@ -15,7 +12,7 @@ class Vertex:
     """Represents a node in a graph with weighted connections to neighbors."""
 
     def __init__(self, key):
-        """ Initialize the vertex with a key and no connections. """
+        """Initialize the vertex with a key and no connections."""
 
         self._id = key
         self._connections = {}
@@ -25,7 +22,7 @@ class Vertex:
 
     @property
     def id(self):
-        """ The vertex identifier. """
+        """The vertex identifier."""
         return self._id
 
     @id.setter
@@ -33,17 +30,17 @@ class Vertex:
         self._id = value
 
     def get_weight(self, vertex: Self):
-        """ Retrieve the weight to reach the neighbor """
+        """Retrieve the weight to reach the neighbor"""
         return self._connections[vertex]
 
-    def get_connections(self) -> Dict:
-        """ Return the connections """
+    def get_connections(self) -> dict:
+        """Return the connections"""
         return self._connections
 
-    def get_connections_ids(self) -> List:
-        """ Return the connections ids """
+    def get_connections_ids(self) -> list:
+        """Return the connections ids"""
         return [vertex.id for vertex in self.get_connections()]
 
     def add_neighbor(self, vertex: Self, weight=0):
-        """ Add or update a connection """
+        """Add or update a connection"""
         self._connections[vertex] = weight

{core_data_structures-1.4.0 → core_data_structures-1.4.1}/data_structures/lists/base.py

@@ -1,11 +1,11 @@
-# -*- coding: utf-8 -*-
-
 """Abstract interface shared by every list implementation in this package."""
 
-from abc import ABC
-from abc import abstractmethod
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from collections.abc import Iterator
 from contextlib import suppress
-from typing import Generic, Iterator, Optional, TypeVar, cast
+from typing import Generic, TypeVar, cast
 
 from core_mixins.compatibility import Self
 
@@ -18,26 +18,26 @@ class Node(BaseNode[T]):
 
     def __init__(
         self,
-        value: Optional[T] = None,
-        next_node: Optional[Self] = None,
+        value: T | None = None,
+        next_node: Self | None = None,
     ) -> None:
         super().__init__(value=value)
         self._next = next_node
 
     @property
-    def next(self) -> Optional[Self]:
+    def next(self) -> Self | None:
         """The next node in the list, if any."""
         return self._next
 
     @next.setter
-    def next(self, next_node: Optional[Self]) -> None:
+    def next(self, next_node: Self | None) -> None:
         self._next = next_node
 
 
 NodeT = TypeVar("NodeT", bound=Node)
 
 
-class IList(Generic[T], ABC):
+class IList(ABC, Generic[T]):
     """Abstract base class (interface) for all list implementations."""
 
     def __init__(self, length: int = 0):
@@ -177,13 +177,11 @@ class IList(Generic[T], ABC):
         """Reverses the list in place."""
 
 
-class ILinkedList(IList[T], Generic[T, NodeT], ABC):
+class ILinkedList(IList[T], ABC, Generic[T, NodeT]):
     """Interface for linked list implementations, parametrized by their node type."""
 
-    def __init__(self, value: Optional[T] = None) -> None:
-        self._head: Optional[NodeT] = (
-            None if value is None else self._create_node(value)
-        )
+    def __init__(self, value: T | None = None) -> None:
+        self._head: NodeT | None = None if value is None else self._create_node(value)
 
         super().__init__(0 if value is None else 1)
         self._end = self._head
@@ -202,12 +200,12 @@ class ILinkedList(IList[T], Generic[T, NodeT], ABC):
         """Creates a new, unlinked node of the concrete node type used by this list."""
 
     @property
-    def head(self) -> Optional[NodeT]:
+    def head(self) -> NodeT | None:
         """The first node in the list."""
         return self._head
 
     @property
-    def end(self) -> Optional[NodeT]:
+    def end(self) -> NodeT | None:
         """The end node in the list."""
         return self._end
 

{core_data_structures-1.4.0 → core_data_structures-1.4.1}/data_structures/lists/double_linked_list.py

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 """
 A doubly linked list is a linear data structure composed of a sequence
 of nodes where each node contains data and pointers (or references) to
@@ -12,7 +10,8 @@ direction.
 # ILinkedList rather than parent/child, so their mutators intentionally
 # don't share an implementation, even where the resulting code overlaps.
 
-from typing import Optional
+from __future__ import annotations
+
 from typing import cast
 
 from core_mixins.compatibility import Self
@@ -30,20 +29,20 @@ class Node(LinkedNode[T]):
 
     def __init__(
         self,
-        value: Optional[T] = None,
-        next_node: Optional[Self] = None,
-        prev_node: Optional[Self] = None,
+        value: T | None = None,
+        next_node: Self | None = None,
+        prev_node: Self | None = None,
     ) -> None:
         super().__init__(value=value, next_node=next_node)
         self._prev = prev_node
 
     @property
-    def prev(self) -> Optional[Self]:
+    def prev(self) -> Self | None:
         """The previous node in the list, if any."""
         return self._prev
 
     @prev.setter
-    def prev(self, prev_node: Optional[Self]) -> None:
+    def prev(self, prev_node: Self | None) -> None:
         self._prev = prev_node
 
 

{core_data_structures-1.4.0 → core_data_structures-1.4.1}/data_structures/lists/singly_linked_list.py

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 """
 A linked list is a linear data structure composed of a sequence
 of nodes where each node contains data and a pointer (or reference)
@@ -11,8 +9,7 @@ across your system's RAM.
 from typing import cast
 
 from data_structures.base import T
-from data_structures.lists.base import ILinkedList
-from data_structures.lists.base import Node
+from data_structures.lists.base import ILinkedList, Node
 
 
 class SinglyLinkedList(ILinkedList[T, Node[T]]):

{core_data_structures-1.4.0 → core_data_structures-1.4.1}/data_structures/trees/__init__.py

@@ -1,11 +1,8 @@
-# -*- coding: utf-8 -*-
-
 """Tree data structures package."""
 
 from .binary_tree import BinaryTree
 from .simple_tree import Tree
 
-
 __all__ = [
     "BinaryTree",
     "Tree",

{core_data_structures-1.4.0 → core_data_structures-1.4.1}/data_structures/trees/base.py

@@ -1,8 +1,6 @@
-# -*- coding: utf-8 -*-
-
 """Node with left/right child references, shared by every binary tree."""
 
-from typing import Optional
+from __future__ import annotations
 
 from core_mixins.compatibility import Self
 
@@ -19,28 +17,28 @@ class Node(BaseNode[T]):
 
     def __init__(
         self,
-        value: Optional[T] = None,
-        left: Optional[Self] = None,
-        right: Optional[Self] = None,
+        value: T | None = None,
+        left: Self | None = None,
+        right: Self | None = None,
     ) -> None:
         super().__init__(value=value)
         self._left = left
         self._right = right
 
     @property
-    def left(self) -> Optional[Self]:
+    def left(self) -> Self | None:
         """The left child of the node, if any."""
         return self._left
 
     @left.setter
-    def left(self, node: Optional[Self]) -> None:
+    def left(self, node: Self | None) -> None:
         self._left = node
 
     @property
-    def right(self) -> Optional[Self]:
+    def right(self) -> Self | None:
         """The right child of the node, if any."""
         return self._right
 
     @right.setter
-    def right(self, node: Optional[Self]) -> None:
+    def right(self, node: Self | None) -> None:
         self._right = node

{core_data_structures-1.4.0 → core_data_structures-1.4.1}/data_structures/trees/binary_tree.py

@@ -1,9 +1,10 @@
-# -*- coding: utf-8 -*-
-
 """Binary tree data structure with recursive and iterative traversal algorithms."""
 
+from __future__ import annotations
+
+from collections.abc import Iterator
 from queue import Queue
-from typing import Generic, Iterator, List, Optional, cast
+from typing import Generic, cast
 
 from data_structures.base import T
 from data_structures.trees.base import Node
@@ -16,14 +17,14 @@ class BinaryTree(Generic[T]):
     and the right child.
     """
 
-    def __init__(self, value: Optional[T] = None) -> None:
-        self._root: Optional[Node[T]] = None if value is None else Node(value)
+    def __init__(self, value: T | None = None) -> None:
+        self._root: Node[T] | None = None if value is None else Node(value)
 
     def __iter__(self) -> Iterator[T]:
         yield from self._iter(self._root)
 
     @classmethod
-    def _iter(cls, node: Optional[Node[T]]) -> Iterator[T]:
+    def _iter(cls, node: Node[T] | None) -> Iterator[T]:
         if node is None:
             return
 
@@ -35,7 +36,7 @@ class BinaryTree(Generic[T]):
         return self._count(self._root)
 
     @classmethod
-    def _count(cls, node: Optional[Node[T]]) -> int:
+    def _count(cls, node: Node[T] | None) -> int:
         if node is None:
             return 0
 
@@ -48,11 +49,11 @@ class BinaryTree(Generic[T]):
         return f"{type(self).__name__}({self.level_order()!r})"
 
     @property
-    def root(self) -> Optional[Node[T]]:
+    def root(self) -> Node[T] | None:
         """The root node of the tree."""
         return self._root
 
-    def pre_order(self) -> List[T]:
+    def pre_order(self) -> list[T]:
         """
         >>> tree = create_example_tree()
         >>> tree.pre_order()
@@ -62,7 +63,7 @@ class BinaryTree(Generic[T]):
         return self._pre_order(self._root)
 
     @classmethod
-    def _pre_order(cls, node: Optional[Node[T]]) -> List[T]:
+    def _pre_order(cls, node: Node[T] | None) -> list[T]:
         if node is None:
             return []
 
@@ -71,16 +72,16 @@ class BinaryTree(Generic[T]):
         res.extend(cls._pre_order(node.right))
         return res
 
-    def pre_order_iterative(self) -> List[T]:
+    def pre_order_iterative(self) -> list[T]:
         """
         >>> tree = create_example_tree()
         >>> tree.pre_order_iterative()
         [1, 2, 4, 8, 9, 5, 10, 11, 3, 6, 12, 13, 7, 14, 15]
         """
 
-        stack: List[Node[T]] = []
-        node: Optional[Node[T]] = self._root
-        res: List[T] = []
+        stack: list[Node[T]] = []
+        node: Node[T] | None = self._root
+        res: list[T] = []
 
         while stack or node:
             while node:
@@ -93,7 +94,7 @@ class BinaryTree(Generic[T]):
 
         return res
 
-    def in_order(self) -> List[T]:
+    def in_order(self) -> list[T]:
         """
         >>> tree = create_example_tree()
         >>> tree.in_order()
@@ -103,7 +104,7 @@ class BinaryTree(Generic[T]):
         return self._in_order(self._root)
 
     @classmethod
-    def _in_order(cls, node: Optional[Node[T]]) -> List[T]:
+    def _in_order(cls, node: Node[T] | None) -> list[T]:
         if node is None:
             return []
 
@@ -112,16 +113,16 @@ class BinaryTree(Generic[T]):
         res.extend(cls._in_order(node.right))
         return res
 
-    def in_order_iterative(self) -> List[T]:
+    def in_order_iterative(self) -> list[T]:
         """
         >>> tree = create_example_tree()
         >>> tree.in_order_iterative()
         [8, 4, 9, 2, 10, 5, 11, 1, 12, 6, 13, 3, 14, 7, 15]
         """
 
-        res: List[T] = []
-        stack: List[Node[T]] = []
-        node: Optional[Node[T]] = self._root
+        res: list[T] = []
+        stack: list[Node[T]] = []
+        node: Node[T] | None = self._root
 
         while stack or node:
             while node:
@@ -134,7 +135,7 @@ class BinaryTree(Generic[T]):
 
         return res
 
-    def post_order(self) -> List[T]:
+    def post_order(self) -> list[T]:
         """
         >>> tree = create_example_tree()
         >>> tree.post_order()
@@ -144,7 +145,7 @@ class BinaryTree(Generic[T]):
         return self._post_order(self._root)
 
     @classmethod
-    def _post_order(cls, node: Optional[Node[T]]) -> List[T]:
+    def _post_order(cls, node: Node[T] | None) -> list[T]:
         if node is None:
             return []
 
@@ -153,7 +154,7 @@ class BinaryTree(Generic[T]):
         res.append(cast(T, node.value))
         return res
 
-    def post_order_iterative(self) -> List[T]:
+    def post_order_iterative(self) -> list[T]:
         """
         >>> tree = create_example_tree()
         >>> tree.post_order_iterative()
@@ -163,8 +164,8 @@ class BinaryTree(Generic[T]):
         if self._root is None:
             return []
 
-        stack: List[Node[T]] = [self._root]
-        stack_tmp: List[Node[T]] = []
+        stack: list[Node[T]] = [self._root]
+        stack_tmp: list[Node[T]] = []
 
         while stack:
             node = stack.pop()
@@ -176,20 +177,20 @@ class BinaryTree(Generic[T]):
 
             stack_tmp.append(node)
 
-        res: List[T] = []
+        res: list[T] = []
         while stack_tmp:
             res.append(cast(T, stack_tmp.pop().value))
 
         return res
 
-    def level_order(self) -> List[T]:
+    def level_order(self) -> list[T]:
         """
         >>> tree = create_example_tree()
         >>> tree.level_order()
         [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
         """
 
-        res: List[T] = []
+        res: list[T] = []
         if self._root is None:
             return res
 
@@ -222,7 +223,7 @@ class BinaryTree(Generic[T]):
         return self._depth(self._root)
 
     @classmethod
-    def _depth(cls, node: Optional[Node[T]]) -> int:
+    def _depth(cls, node: Node[T] | None) -> int:
         if node is None:
             return 0
 
@@ -230,7 +231,7 @@ class BinaryTree(Generic[T]):
 
 
 def create_example_tree() -> BinaryTree[int]:
-    """ Build and return a complete binary tree with 15 nodes for testing. """
+    """Build and return a complete binary tree with 15 nodes for testing."""
 
     tree = BinaryTree(1)
     root = cast(Node[int], tree.root)

{core_data_structures-1.4.0 → core_data_structures-1.4.1}/data_structures/trees/simple_tree.py

@@ -1,12 +1,8 @@
-# -*- coding: utf-8 -*-
-
 """Simple tree data structure backed by a nested dictionary."""
 
-from typing import Dict
-
 
-class Tree(Dict):
-    """ Basic implementation based on Dictionary """
+class Tree(dict):
+    """Basic implementation based on Dictionary"""
 
     def __missing__(self, key):
         value = self[key] = type(self)()

{core_data_structures-1.4.0 → core_data_structures-1.4.1}/pyproject.toml

@@ -9,7 +9,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "core-data-structures"
 description = "This project/library contains commons data structures..."
-version = "1.4.0"
+version = "1.4.1"
 
 authors = [
     {name = "Alejandro Cora González", email = "alek.cora.glez@gmail.com"}
@@ -37,6 +37,7 @@ classifiers = [
     "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3.14",
     "Programming Language :: Python :: Implementation :: PyPy",
+    "Typing :: Typed",
 ]
 
 dependencies = [
@@ -47,7 +48,7 @@ dependencies = [
 [project.optional-dependencies]
 dev = [
     "core-dev-tools>=2.1.0",
-    "core-tests>=2.1.0",
+    "core-tests>=2.3.0",
 ]
 
 [project.urls]

core_data_structures-1.4.1/setup.py

@@ -0,0 +1,5 @@
+"""Setuptools entry point for building and installing the package."""
+
+from setuptools import setup
+
+setup()

core_data_structures-1.4.0/setup.py

@@ -1,6 +0,0 @@
-# -*- coding: utf-8 -*-
-
-from setuptools import setup
-
-
-setup()