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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: core-data-structures
-Version: 1.3.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.3.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.3.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.3.0 → core_data_structures-1.4.1}/core_data_structures.egg-info/SOURCES.txt

@@ -18,5 +18,6 @@ data_structures/lists/base.py
 data_structures/lists/double_linked_list.py
 data_structures/lists/singly_linked_list.py
 data_structures/trees/__init__.py
+data_structures/trees/base.py
 data_structures/trees/binary_tree.py
 data_structures/trees/simple_tree.py

{core_data_structures-1.3.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.3.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.3.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.3.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.3.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.3.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.3.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.3.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.3.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.3.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.1/data_structures/trees/base.py

@@ -0,0 +1,44 @@
+"""Node with left/right child references, shared by every binary tree."""
+
+from __future__ import annotations
+
+from core_mixins.compatibility import Self
+
+from data_structures.base import Node as BaseNode
+from data_structures.base import T
+
+__all__ = [
+    "Node",
+]
+
+
+class Node(BaseNode[T]):
+    """Node with references to its left and right children."""
+
+    def __init__(
+        self,
+        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) -> Self | None:
+        """The left child of the node, if any."""
+        return self._left
+
+    @left.setter
+    def left(self, node: Self | None) -> None:
+        self._left = node
+
+    @property
+    def right(self) -> Self | None:
+        """The right child of the node, if any."""
+        return self._right
+
+    @right.setter
+    def right(self, node: Self | None) -> None:
+        self._right = node

core_data_structures-1.4.1/data_structures/trees/binary_tree.py

@@ -0,0 +1,247 @@
+"""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, cast
+
+from data_structures.base import T
+from data_structures.trees.base import Node
+
+
+class BinaryTree(Generic[T]):
+    """
+    In computer science, a binary tree is a tree data structure in which
+    each node has at most two children, referred to as the left child
+    and the right child.
+    """
+
+    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: Node[T] | None) -> Iterator[T]:
+        if node is None:
+            return
+
+        yield from cls._iter(node.left)
+        yield cast(T, node.value)
+        yield from cls._iter(node.right)
+
+    def __len__(self) -> int:
+        return self._count(self._root)
+
+    @classmethod
+    def _count(cls, node: Node[T] | None) -> int:
+        if node is None:
+            return 0
+
+        return 1 + cls._count(node.left) + cls._count(node.right)
+
+    def __contains__(self, value: T) -> bool:
+        return any(node_value == value for node_value in self)
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}({self.level_order()!r})"
+
+    @property
+    def root(self) -> Node[T] | None:
+        """The root node of the tree."""
+        return self._root
+
+    def pre_order(self) -> list[T]:
+        """
+        >>> tree = create_example_tree()
+        >>> tree.pre_order()
+        [1, 2, 4, 8, 9, 5, 10, 11, 3, 6, 12, 13, 7, 14, 15]
+        """
+
+        return self._pre_order(self._root)
+
+    @classmethod
+    def _pre_order(cls, node: Node[T] | None) -> list[T]:
+        if node is None:
+            return []
+
+        res = [cast(T, node.value)]
+        res.extend(cls._pre_order(node.left))
+        res.extend(cls._pre_order(node.right))
+        return res
+
+    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: Node[T] | None = self._root
+        res: list[T] = []
+
+        while stack or node:
+            while node:
+                res.append(cast(T, node.value))
+                stack.append(node)
+                node = node.left
+
+            node = stack.pop()
+            node = node.right
+
+        return res
+
+    def in_order(self) -> list[T]:
+        """
+        >>> tree = create_example_tree()
+        >>> tree.in_order()
+        [8, 4, 9, 2, 10, 5, 11, 1, 12, 6, 13, 3, 14, 7, 15]
+        """
+
+        return self._in_order(self._root)
+
+    @classmethod
+    def _in_order(cls, node: Node[T] | None) -> list[T]:
+        if node is None:
+            return []
+
+        res = cls._in_order(node.left)
+        res.append(cast(T, node.value))
+        res.extend(cls._in_order(node.right))
+        return res
+
+    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: Node[T] | None = self._root
+
+        while stack or node:
+            while node:
+                stack.append(node)
+                node = node.left
+
+            node = stack.pop()
+            res.append(cast(T, node.value))
+            node = node.right
+
+        return res
+
+    def post_order(self) -> list[T]:
+        """
+        >>> tree = create_example_tree()
+        >>> tree.post_order()
+        [8, 9, 4, 10, 11, 5, 2, 12, 13, 6, 14, 15, 7, 3, 1]
+        """
+
+        return self._post_order(self._root)
+
+    @classmethod
+    def _post_order(cls, node: Node[T] | None) -> list[T]:
+        if node is None:
+            return []
+
+        res = cls._post_order(node.left)
+        res.extend(cls._post_order(node.right))
+        res.append(cast(T, node.value))
+        return res
+
+    def post_order_iterative(self) -> list[T]:
+        """
+        >>> tree = create_example_tree()
+        >>> tree.post_order_iterative()
+        [8, 9, 4, 10, 11, 5, 2, 12, 13, 6, 14, 15, 7, 3, 1]
+        """
+
+        if self._root is None:
+            return []
+
+        stack: list[Node[T]] = [self._root]
+        stack_tmp: list[Node[T]] = []
+
+        while stack:
+            node = stack.pop()
+            if node.left:
+                stack.append(node.left)
+
+            if node.right:
+                stack.append(node.right)
+
+            stack_tmp.append(node)
+
+        res: list[T] = []
+        while stack_tmp:
+            res.append(cast(T, stack_tmp.pop().value))
+
+        return res
+
+    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] = []
+        if self._root is None:
+            return res
+
+        q: Queue[Node[T]] = Queue()
+        q.put(self._root)
+
+        while not q.empty():
+            node_dequeued = q.get()
+            res.append(cast(T, node_dequeued.value))
+
+            if node_dequeued.left:
+                q.put(node_dequeued.left)
+
+            if node_dequeued.right:
+                q.put(node_dequeued.right)
+
+        return res
+
+    def depth(self) -> int:
+        """
+        The maximum depth of a binary tree is the number of nodes from the
+        root down to the furthest leaf node. In other words, it is
+        the height of a binary tree.
+
+        >>> tree = create_example_tree()
+        >>> tree.depth()
+        4
+        """
+
+        return self._depth(self._root)
+
+    @classmethod
+    def _depth(cls, node: Node[T] | None) -> int:
+        if node is None:
+            return 0
+
+        return 1 + max(cls._depth(node.left), cls._depth(node.right))
+
+
+def create_example_tree() -> BinaryTree[int]:
+    """Build and return a complete binary tree with 15 nodes for testing."""
+
+    tree = BinaryTree(1)
+    root = cast(Node[int], tree.root)
+    nodes = [Node(value) for value in range(2, 16)]
+
+    root.left, root.right = nodes[0], nodes[1]
+    nodes[0].left, nodes[0].right = nodes[2], nodes[3]
+    nodes[1].left, nodes[1].right = nodes[4], nodes[5]
+    nodes[2].left, nodes[2].right = nodes[6], nodes[7]
+    nodes[3].left, nodes[3].right = nodes[8], nodes[9]
+    nodes[4].left, nodes[4].right = nodes[10], nodes[11]
+    nodes[5].left, nodes[5].right = nodes[12], nodes[13]
+    return tree

{core_data_structures-1.3.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.3.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.3.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.3.0/data_structures/trees/binary_tree.py

@@ -1,230 +0,0 @@
-# -*- coding: utf-8 -*-
-
-"""Binary tree data structure with recursive and iterative traversal algorithms."""
-
-from queue import Queue
-from typing import List, Optional
-
-
-class BinaryTree:
-    """
-    In computer science, a binary tree is a tree data structure in which
-    each node has at most two children, which are referred to as the
-    left child and the right child...
-    """
-
-    def __init__(self, value) -> None:
-        self.value = value
-        self.right: Optional[BinaryTree] = None
-        self.left: Optional[BinaryTree] = None
-
-    @staticmethod
-    def create_example_tree():
-        """ Build and return a complete binary tree with 15 nodes for testing. """
-
-        root = BinaryTree(1)
-        tree_node2, tree_node3 = BinaryTree(2), BinaryTree(3)
-        tree_node4, tree_node5 = BinaryTree(4), BinaryTree(5)
-        tree_node6, tree_node7 = BinaryTree(6), BinaryTree(7)
-        tree_node8, tree_node9 = BinaryTree(8), BinaryTree(9)
-        tree_node10, tree_node11 = BinaryTree(10), BinaryTree(11)
-        tree_node12, tree_node13 = BinaryTree(12), BinaryTree(13)
-        tree_node14, tree_node15 = BinaryTree(14), BinaryTree(15)
-
-        root.left, root.right = tree_node2, tree_node3
-        tree_node2.left, tree_node2.right = tree_node4, tree_node5
-        tree_node3.left, tree_node3.right = tree_node6, tree_node7
-        tree_node4.left, tree_node4.right = tree_node8, tree_node9
-        tree_node5.left, tree_node5.right = tree_node10, tree_node11
-        tree_node6.left, tree_node6.right = tree_node12, tree_node13
-        tree_node7.left, tree_node7.right = tree_node14, tree_node15
-        return root
-
-    def pre_order(self) -> List:
-        """
-        >>> root = BinaryTree.create_example_tree()
-        >>> root.pre_order()
-        [1, 2, 4, 8, 9, 5, 10, 11, 3, 6, 12, 13, 7, 14, 15]
-        """
-
-        res = [self.value]
-        if self.left:
-            res.extend(self.left.pre_order())
-
-        if self.right:
-            res.extend(self.right.pre_order())
-
-        return res
-
-    def pre_order_iterative(self) -> List:
-        """
-        >>> root = BinaryTree.create_example_tree()
-        >>> root.pre_order_iterative()
-        [1, 2, 4, 8, 9, 5, 10, 11, 3, 6, 12, 13, 7, 14, 15]
-        """
-
-        stack: List[BinaryTree] = []
-        node: Optional[BinaryTree] = self
-        res = []
-
-        while stack or node:
-            while node:
-                res.append(node.value)
-                stack.append(node)
-                node = node.left
-
-            node = stack.pop()
-            node = node.right
-
-        return res
-
-    def in_order(self) -> List:
-        """
-        >>> root = BinaryTree.create_example_tree()
-        >>> root.in_order()
-        [8, 4, 9, 2, 10, 5, 11, 1, 12, 6, 13, 3, 14, 7, 15]
-        """
-
-        res = []
-        if self.left:
-            res.extend(self.left.in_order())
-
-        res.append(self.value)
-
-        if self.right:
-            res.extend(self.right.in_order())
-
-        return res
-
-    def in_order_iterative(self) -> List:
-        """
-        >>> root = BinaryTree.create_example_tree()
-        >>> root.in_order_iterative()
-        [8, 4, 9, 2, 10, 5, 11, 1, 12, 6, 13, 3, 14, 7, 15]
-        """
-
-        res = []
-        stack: List[BinaryTree] = []
-        node: Optional[BinaryTree] = self
-
-        while stack or node:
-            while node:
-                stack.append(node)
-                node = node.left
-
-            node = stack.pop()
-            res.append(node.value)
-            node = node.right
-
-        return res
-
-    def post_order(self) -> List:
-        """
-        >>> root = BinaryTree.create_example_tree()
-        >>> root.post_order()
-        [8, 9, 4, 10, 11, 5, 2, 12, 13, 6, 14, 15, 7, 3, 1]
-        """
-
-        res = []
-        if self.left:
-            res.extend(self.left.post_order())
-
-        if self.right:
-            res.extend(self.right.post_order())
-
-        res.append(self.value)
-        return res
-
-    def post_order_iterative(self) -> List:
-        """
-        >>> root = BinaryTree.create_example_tree()
-        >>> root.post_order_iterative()
-        [8, 9, 4, 10, 11, 5, 2, 12, 13, 6, 14, 15, 7, 3, 1]
-        """
-
-        stack: List[BinaryTree] = [self]
-        stack_tmp: List[BinaryTree] = []
-
-        while stack:
-            node = stack.pop()
-            if node.left:
-                stack.append(node.left)
-
-            if node.right:
-                stack.append(node.right)
-
-            stack_tmp.append(node)
-
-        res = []
-        while stack_tmp:
-            res.append(stack_tmp.pop().value)
-
-        return res
-
-    def level_order(self) -> List:
-        """
-        >>> root = BinaryTree.create_example_tree()
-        >>> root.level_order()
-        [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
-        """
-
-        res = []
-        q: Queue[BinaryTree] = Queue()
-        q.put(self)
-
-        while not q.empty():
-            node_dequeued = q.get()
-            res.append(node_dequeued.value)
-
-            if node_dequeued.left:
-                q.put(node_dequeued.left)
-
-            if node_dequeued.right:
-                q.put(node_dequeued.right)
-
-        return res
-
-    # def level_order_iterative(self) -> List:
-    #     """
-    #     >>> root = BinaryTree.create_example_tree()
-    #     >>> root.post_order_iterative()
-    #     [8, 9, 4, 10, 11, 5, 2, 12, 13, 6, 14, 15, 7, 3, 1]
-    #     """
-    #
-    #     stack: List[BinaryTree] = []
-    #     node, res = self, []
-    #
-    #     while stack or node:
-    #         while node.left:
-    #             stack.append(node)
-    #             node = node.left
-    #
-    #         res.append(node.value)
-    #         node = stack.pop()
-    #         node = node.right
-    #
-    #     return res
-
-    def depth(self):
-        """
-        The maximum depth of a binary tree is the number of nodes from the
-        root down to the furthest leaf node. In other words, it is
-        the height of a binary tree.
-
-        >>> root = BinaryTree.create_example_tree()
-        >>> root.depth()
-        4
-        """
-
-        if not self.left and not self.right:
-            return 1
-
-        depth_left = 0
-        if self.left:
-            depth_left = self.left.depth()
-
-        depth_right = 0
-        if self.right:
-            depth_right = self.right.depth()
-
-        return 1 + max(depth_left, depth_right)

core_data_structures-1.3.0/setup.py

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