danielutils 1.1.28__py3-none-any.whl

danielutils/conversions/specialized_conversions/to_hex.py

@@ -0,0 +1,25 @@
+from ...metaclasses.overload_meta import OverloadMeta
+from ..main_conversions import int_to_hex, char_to_hex
+
+
+@OverloadMeta.overload
+def to_hex(v: int) -> str:
+    # docstring at last implementation
+    return int_to_hex(v)
+
+
+@to_hex.overload  # type:ignore
+def to_hex2(v: str) -> str:
+    """to_hex has several options:\n
+    1. type(v) == int\n
+    2. type(v) == str and len(v) == 1
+
+    Returns:
+        str: str of the hex value
+    """
+    return char_to_hex(v)
+
+
+__all__ = [
+    "to_hex"
+]

danielutils/conversions/specialized_conversions/to_int.py

@@ -0,0 +1,19 @@
+"""functions that convert values to int"""
+from typing import Union, List as List
+from ..main_conversions import char_to_int
+from ...reflection import get_python_version
+if get_python_version() >= (3, 9):
+    from builtins import list as List
+
+
+def to_int(value: str) -> Union[int, List[int]]:
+    """converts a single character or a full string to an int or list of int respectively
+    """
+    if len(value) == 1:
+        return char_to_int(value)
+    return [char_to_int(ch) for ch in value]
+
+
+__all__ = [
+    "to_int"
+]

danielutils/custom_types.py

@@ -0,0 +1,18 @@
+from typing import Callable, TypeVar
+from .versioned_imports import TypeAlias
+
+T = TypeVar('T')
+U = TypeVar('U')
+Procedure: TypeAlias = Callable[[], None]
+Supplier: TypeAlias = Callable[[], T]
+Consumer: TypeAlias = Callable[[T], None]
+Predicate: TypeAlias = Callable[[], bool]
+Mapper: TypeAlias = Callable[[T], U]
+
+__all__ = [
+    'Procedure',
+    'Supplier',
+    'Consumer',
+    'Predicate',
+    'Mapper'
+]

danielutils/data_structures/__init__.py

@@ -0,0 +1,8 @@
+from .queue import *
+from .heap import *
+from .comparer import *
+from .graph import *
+from .stack import *
+from .default_dict import *
+from .trees import *
+from .algorithms import *

danielutils/data_structures/algorithms.py

@@ -0,0 +1,52 @@
+import logging
+from collections import defaultdict
+from typing import TypeVar, List, Callable, Dict
+from itertools import product
+from copy import deepcopy
+from ..logging_.utils import get_logger
+logger = get_logger(__name__)
+
+NodeT = TypeVar("NodeT")
+
+DistanceMatrix = Dict[NodeT, Dict[NodeT, float]]
+
+
+def bellman_ford(nodes: List[NodeT], weight_func: Callable[[NodeT, NodeT], float],
+                 iteration_callback: Callable[[DistanceMatrix], None],
+                 poisoned_reverse: bool = False) -> DistanceMatrix:
+    logger.debug("Starting Bellman-Ford algorithm with %s nodes, poisoned_reverse=%s", len(nodes), poisoned_reverse)
+    dist: Dict[NodeT, Dict[NodeT, float]] = defaultdict(defaultdict)
+    prev: Dict[NodeT, Dict[NodeT, NodeT]] = defaultdict(defaultdict)
+
+    for u, v in product(nodes, nodes):
+        dist[u][v] = weight_func(u, v)
+
+    logger.debug("Initial distance matrix computed")
+    iteration_callback(dist)
+
+    for iteration in range(len(nodes) - 1):
+        logger.debug("Bellman-Ford iteration %s/%s", iteration + 1, len(nodes) - 1)
+        tmp = deepcopy(dist)
+        for u, v in product(nodes, nodes):
+            if u == v:
+                continue
+
+            for mid in nodes:
+                if mid == u or mid == v:
+                    continue
+
+                if dist[u][v] > dist[u][mid] + dist[mid][v]:
+                    tmp[u][v] = dist[u][mid] + dist[mid][v]
+                    prev[u][v] = mid
+
+        dist = tmp
+        iteration_callback(dist)
+
+    logger.debug("Bellman-Ford algorithm completed")
+    iteration_callback(prev)
+    return dist
+
+
+__all__ = [
+    "bellman_ford"
+]

danielutils/data_structures/comparer.py

@@ -0,0 +1,47 @@
+"""Comparer class"""
+import logging
+from typing import Callable,  Union, Generic, TypeVar
+from ..logging_.utils import get_logger
+from .functions import default_weight_function
+logger = get_logger(__name__)
+
+U = TypeVar("U")
+V = TypeVar("V")
+
+
+class Comparer(Generic[U, V]):
+    """a Comparer class to be used when comparing two objects
+    """
+
+    def __init__(self, func: Callable[[U, V], Union[int, float]]):
+        self.func = func
+        logger.debug("Comparer initialized with function: %s", func.__name__)
+
+    def compare(self, v1: U, v2: V) -> Union[int, float]:
+        """compares two objects
+
+            Args:
+                v1 (Any): first object
+                v2 (Any): second object
+
+            Returns:
+                int: a number specifying the order of the objects
+            """
+        logger.debug("Comparing objects: %s vs %s", v1, v2)
+        result = self.func(v1, v2)
+        logger.debug("Comparison result: %s", result)
+        return result
+
+    def __call__(self, v1: U, v2: V) -> Union[int, float]:
+        return self.compare(v1, v2)
+
+
+CompareGreater: Comparer[U, V] = Comparer(lambda a, b: default_weight_function(a) -
+                                                       default_weight_function(b))
+CompareSmaller: Comparer[U, V] = Comparer(lambda a, b: default_weight_function(b) -
+                                                       default_weight_function(a))
+__all__ = [
+    "Comparer",
+    "CompareGreater",
+    "CompareSmaller"
+]

danielutils/data_structures/default_dict.py

@@ -0,0 +1,23 @@
+import logging
+from ..logging_.utils import get_logger
+logger = get_logger(__name__)
+
+
+class DefaultDict(dict):
+    """
+    My implementation to `collections.defaultdict`
+    """
+
+    def __init__(self, cls):
+        self._cls = cls
+        logger.debug("DefaultDict initialized with default factory: %s", cls)
+
+    def __getitem__(self, key):
+        if key not in self:
+            logger.debug("Key '%s' not found, creating default value using %s", key, self._cls)
+        return super().get(key, self._cls())
+
+
+__all__ = [
+    "DefaultDict"
+]

danielutils/data_structures/functions.py

@@ -0,0 +1,35 @@
+import logging
+from typing import Any, Union
+from ..functions import isoftype
+from ..logging_.utils import get_logger
+logger = get_logger(__name__)
+
+
+def default_weight_function(v: Any) -> Union[int, float]:
+    """will return the weight of an object
+
+    Args:
+        v (Any): object
+
+    Raises:
+        AttributeError: if the object is not a number or doesn't have __weight__ function defined
+
+    Returns:
+        Union[int, float]: the object's weight
+    """
+    logger.debug("Computing weight for object: %s", v)
+    if isoftype(v, Union[int, float]):  # type:ignore
+        logger.debug("Object is numeric, returning value: %s", v)
+        return v
+    if hasattr(v, "__weight__"):
+        logger.debug("Object has __weight__ method, calling it")
+        result = v.__weight__()
+        logger.debug("Weight method returned: %s", result)
+        return result
+    logger.error("Object %s has no __weight__ function and is not numeric", v)
+    raise AttributeError(f"{v} has no __weight__ function")
+
+
+__all__ = [
+    "default_weight_function"
+]

danielutils/data_structures/graph/__init__.py

@@ -0,0 +1,4 @@
+from .graph import *
+from .node import *
+from .multinode import *
+from .binary_node import *

danielutils/data_structures/graph/binary_node.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+from typing import Optional, TypeVar
+from .multinode import MultiNode
+from ...metaclasses import ImplicitDataDeleterMeta
+
+T = TypeVar("T")
+
+
+class BinaryNode(MultiNode[T], metaclass=ImplicitDataDeleterMeta):
+    """A 'classic' node class with only one child
+    """
+
+    def __init__(self, data: T, l: Optional[BinaryNode[T]] = None,
+                 r: Optional[BinaryNode[T]] = None):  # pylint: disable=redefined-builtin
+        # intentionally can be None
+        super().__init__(data, [l, r])  # type:ignore
+
+    def __str__(self):
+        return MultiNode.__str__(self).replace(
+            self.__class__.__mro__[1].__name__,
+            self.__class__.__name__
+        ).replace("[", "").replace("]", "")
+
+    def __repr__(self):
+        return str(self)
+
+    def __reversed__(self) -> 'BinaryNode[T]':
+        return self.reverse()
+
+    def __eq__(self, other):
+        return MultiNode.__eq__(self, other)
+
+    def __iter__(self):
+        return MultiNode.__iter__(self)
+
+    @property
+    def left(self) -> "BinaryNode[T]":
+        """return the next node after self
+        """
+        return self._children[0]  # type:ignore
+
+    @left.setter
+    def left(self, value: "BinaryNode[T]") -> None:
+        self._children[0] = value
+
+    @property
+    def right(self) -> "BinaryNode[T]":
+        """return the next node after self
+        """
+        return self._children[1]  # type:ignore
+
+    @right.setter
+    def right(self, value: "BinaryNode[T]") -> None:
+        self._children[1] = value
+
+    @property
+    def is_leaf(self) -> bool:
+        return self.left is None and self.right is None
+
+    def reverse(self) -> 'BinaryNode[T]':
+        new_left = self.right.reverse() if self.right is not None else None
+        new_right = self.left.reverse() if self.left is not None else None
+        return BinaryNode(self.data, new_left, new_right)
+
+    def depth(self) -> int:
+        return MultiNode.depth(self)
+
+
+__all__ = [
+    "BinaryNode"
+]

danielutils/data_structures/graph/graph.py

@@ -0,0 +1,208 @@
+import logging
+from typing import Optional, Generator, List as List, Set as Set, Dict as Dict, Generic, \
+    TypeVar, Iterable, Iterator
+from ...logging_.utils import get_logger
+from ..queue import Queue
+from .multinode import MultiNode
+from ...reflection import get_python_version
+
+if get_python_version() >= (3, 9):
+    from builtins import list as List, set as Set, dict as Dict
+
+T = TypeVar("T")
+
+logger = get_logger(__name__)
+
+
+class Graph(Generic[T]):
+    """A general-purpose Graph class.
+
+    This class represents a directed graph, where nodes can be connected through edges.
+
+    Attributes:
+        nodes (Optional[List[MultiNode]]): A list of MultiNode instances representing the nodes in the graph.
+                                             Default is an empty list.
+
+    Methods:
+        __init__(self, nodes: Optional[List[MultiNode]] = None): Initialize the Graph with given nodes.
+        add_node(self, node): Add a node to the graph.
+        _extended_dfs(self) -> Generator: Perform an extended depth-first search on the graph.
+        dfs(self) -> Generator: Perform a depth-first search on the graph.
+        topological_sort(self) -> list: Get a topological sort of the graph nodes.
+        bfs(self) -> Generator: Perform a breadth-first search on the graph.
+        __str__(self) -> str: Get a string representation of the graph.
+
+    """
+
+    def to_dict(self) -> Dict[T, Set[T]]:
+        """
+        converts the graph to a dictionary.
+        Returns:
+            dict: A dictionary representing the graph.
+        """
+        logger.debug("Converting graph with %s nodes to dictionary", len(self.nodes))
+        dct: Dict[T, Set[T]] = {}
+        for node in self:
+            v = dct.get(node.data, set())
+            for child in node:
+                v.add(child.data)
+            dct[node.data] = v
+        logger.debug("Graph converted to dictionary with %s entries", len(dct))
+        return dct
+
+    @staticmethod
+    def from_dict(dct: Dict[T, Iterable[T]]) -> "Graph[T]":
+        """
+        converts a dictionary to a graph.
+        Args:
+            dct: A dictionary representing the graph.
+
+        Returns:
+            Graph[T]: A graph representing the given dictionary.
+        """
+        logger.debug("Creating graph from dictionary with %s entries", len(dct))
+        g: Graph[T] = Graph()
+        seen: Dict[T, MultiNode[T]] = {}
+        for k, v in dct.items():
+            seen[k] = seen.get(k, MultiNode(k))
+
+            for o in v:
+                seen[o] = seen.get(o, MultiNode(o))
+                seen[k].add_child(seen[o])
+
+            g.add_node(seen[k])
+        logger.info("Graph created from dictionary with %s nodes", len(g.nodes))
+        return g
+
+    def __init__(self, nodes: Optional[List[MultiNode[T]]] = None):
+        self.nodes: List[MultiNode[T]] = nodes if nodes is not None else []
+        logger.debug("Graph initialized with %s nodes", len(self.nodes))
+
+    def add_node(self, node: MultiNode[T]) -> None:
+        """Add a node to the graph.
+
+        Args:
+            node: The MultiNode instance to add to the graph.
+        """
+        self.nodes.append(node)
+        logger.debug("Added node to graph, total nodes: %s", len(self.nodes))
+
+    def _extended_dfs(self) -> Generator[MultiNode[T], None, List[MultiNode[T]]]:
+        """Perform an extended depth-first search on the graph.
+
+        This private method performs an extended depth-first search (DFS) on the graph,
+        keeping track of enter and exit times for each node, and returns a generator that yields
+        nodes in the order of DFS traversal.
+
+        Yields:
+            Generator: The MultiNode instances in the order of depth-first traversal.
+        """
+        seen: set = set()
+        enter_times: dict = {}
+        exit_times: dict = {}
+        travel_index: int = 1
+        all_nodes: List[MultiNode] = []
+
+        def handle_node(node: MultiNode[T]) -> Generator[MultiNode[T], None, None]:
+            nonlocal travel_index
+            seen.add(node)
+            all_nodes.append(node)
+            yield node
+            for subnode in node._children:  # pylint: disable=protected-access
+                if subnode not in seen:
+                    travel_index += 1
+                    enter_times[subnode] = travel_index
+                    if subnode is not None:
+                        yield from handle_node(subnode)
+                    travel_index += 1
+                    exit_times[subnode] = travel_index
+
+        for node in self.nodes:
+            if node not in seen:
+                enter_times[node] = travel_index
+                travel_index += 1
+                yield from handle_node(node)
+                travel_index += 1
+                exit_times[node] = travel_index
+        topological_order = sorted(
+            all_nodes, key=lambda v: exit_times[v], reverse=True)
+        return topological_order
+
+    # def topological_sort(graph: Graph):
+    #     def dfs(node: MultiNode, visited: set, result: list):
+    #         visited.add(node)
+    #         for neighbor in node:
+    #             if neighbor not in visited:
+    #                 dfs(neighbor, visited, result)
+    #         result.append(node)
+    #
+    #     visited: set = set()
+    #     result: list = []
+    #     for node in graph:
+    #         if node not in visited:
+    #             dfs(node, visited, result)
+    #     return result[::-1]  # Reverse the result list
+
+    def dfs(self) -> Generator[MultiNode[T], None, None]:
+        """Perform a depth-first search on the graph.
+
+        This method performs a depth-first search (DFS) on the graph using the private _extended_dfs method.
+
+        Yields:
+            Generator: The MultiNode instances in the order of depth-first traversal.
+        """
+        logger.debug("Starting DFS traversal on graph with %s nodes", len(self.nodes))
+        yield from self._extended_dfs()
+
+    def topological_sort(self) -> List[MultiNode[T]]:
+        """Get a topological sort of the graph nodes.
+
+        This method performs a topological sort on the graph using the private _extended_dfs method.
+
+        Returns:
+            list: A list containing the MultiNode instances in topological order.
+        """
+        logger.debug("Starting topological sort on graph with %s nodes", len(self.nodes))
+        g = self._extended_dfs()
+        try:
+            while True:
+                next(g)
+        except StopIteration as e:
+            result = e.value
+            logger.info("Topological sort completed, result has %s nodes", len(result))
+            return result
+
+    def bfs(self) -> Generator[MultiNode[T], None, None]:
+        """Perform a breadth-first search on the graph.
+
+        This method performs a breadth-first search (BFS) on the graph using a queue.
+
+        Yields:
+            Generator: The MultiNode instances in the order of breadth-first traversal.
+        """
+        logger.debug("Starting BFS traversal on graph with %s nodes", len(self.nodes))
+        q: Queue[MultiNode[T]] = Queue()
+        for node in self.nodes:
+            q.push(node)
+        seen: Set[MultiNode] = set()
+        for node in q:
+            if node not in seen:
+                seen.add(node)
+                yield node
+                for child in node._children:  # pylint: disable=protected-access
+                    q.push(child)  # type:ignore
+        logger.debug("BFS traversal completed, visited %s nodes", len(seen))
+
+    def __str__(self) -> str:
+        tmp = []
+        for n in self.dfs():
+            tmp.append(f"\t{str(n)}")
+        return "Graph(\n" + ",\n".join(tmp) + "\n)"
+
+    def __iter__(self) -> Iterator[MultiNode[T]]:
+        return iter(self.nodes)
+
+
+__all__ = [
+    "Graph"
+]

danielutils/data_structures/graph/multinode.py

@@ -0,0 +1,101 @@
+from typing import Optional, Generator, TypeVar, Generic, List as List, Set
+
+from ...reflection import get_python_version
+
+if get_python_version() >= (3, 9):
+    from builtins import list as List
+T = TypeVar("T")
+
+
+class MultiNode(Generic[T]):
+    """A node class with no limit to children amount
+    """
+
+    def __init__(self, data: T, children: Optional[List[Optional['MultiNode[T]']]] = None):
+        self.data: T = data
+        self._children: List[Optional[MultiNode[T]]] = children if children is not None else []
+
+    def __getitem__(self, index) -> T:
+        return self._children[index]
+
+    def __setitem__(self, value: T, index: int) -> None:
+        self._children[index] = value  # type:ignore
+
+    def __len__(self) -> int:
+        return len(self._children)
+
+    def __iter__(self) -> Generator["MultiNode[T]", None, None]:
+        yield from self._children
+
+    def __str__(self) -> str:
+        res = ""
+        seen = set()
+
+        def handle_node(node: MultiNode):
+            nonlocal res
+            # res += f"MultiNode({node.data}, ["
+            seen.add(node)
+            tmp = []
+            for child in node._children:  # pylint: disable=protected-access
+                if child in seen:
+                    tmp.append("...")
+                else:
+                    if child is not None:
+                        tmp.append(handle_node(child))
+            child_str = ", [" + ", ".join(tmp) + "]" if len(tmp) > 0 else ""
+            return f"{node.__class__.__name__}({node.data}{child_str})"
+
+        return handle_node(self)
+
+    def __repr__(self):
+        return str(self)
+
+    def __eq__(self, other) -> bool:
+        if not isinstance(other, MultiNode):
+            return False
+
+        return self.data == other.data and len(self) == len(other) and all(
+            [a.data == b.data for a, b in zip(self, other)])
+
+    def __hash__(self) -> int:
+        return hash((self.__class__, self.data, len(self), (c.data for c in self)))
+
+    def __reversed__(self) -> 'MultiNode[T]':
+        return self.reverse()
+
+    @property
+    def is_leaf(self) -> bool:
+        return len(self._children) == 0
+
+    def reverse(self) -> 'MultiNode[T]':
+        return MultiNode(self.data, self._children[::-1])
+
+    def add_child(self, child: "MultiNode[T]") -> None:
+        """adds a child to current node
+        """
+        self._children.append(child)
+
+    def depth(self) -> int:
+        """
+        Returns the depth of the current node (including).
+        Returns:
+            int
+        """
+
+        def helper(cur: MultiNode, seen: Optional[Set[MultiNode]] = None) -> int:
+            if not isinstance(cur, MultiNode):
+                return 0
+            if seen is None:
+                seen = set()
+            elif cur in seen:
+                return 0
+            seen.add(cur)
+            seq = [helper(child, seen) for child in cur if ((child is not None) and (child not in seen))]
+            return 1 + (max(seq) if len(seq) > 0 else 0)
+
+        return helper(self)
+
+
+__all__ = [
+    "MultiNode"
+]

danielutils/data_structures/graph/node.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+from typing import Optional, TypeVar
+from ...metaclasses import ImplicitDataDeleterMeta
+from .multinode import MultiNode
+
+T = TypeVar("T")
+
+
+class Node(MultiNode[T], metaclass=ImplicitDataDeleterMeta):
+    """A 'classic' node class with only one child
+    """
+
+    def __init__(self, data: T, next: Optional[Node[T]] = None):  # pylint: disable=redefined-builtin
+        super().__init__(data, [next])
+
+    @property
+    def next(self) -> "Node[T]":
+        """return the next node after self
+        """
+        return self._children[0]  # type:ignore
+
+    @next.setter
+    def next(self, value: Node[T]) -> None:
+        self._children[0] = value
+
+    def __str__(self):
+        # res = ""
+        # seen = set()
+
+        # def handle_node(node: Node):
+        #     nonlocal res
+        #     if node in seen:
+        #         res += "..."
+        #     else:
+        #         seen.add(node)
+        #         res += f"Node({node.data}, "
+        #         if node.next is None:
+        #             res += "None)"
+        #         elif node.next in seen:
+        #             res += "...)"
+
+        # curr = self
+        # while curr is not None:
+        #     handle_node(curr)
+        #     curr = curr.next
+        #     if curr in seen:
+        #         break
+        # return res+")"
+        return MultiNode.__str__(self).replace(
+            self.__class__.__mro__[1].__name__,
+            self.__class__.__name__
+        ).replace("[", "").replace("]", "")
+
+    def __repr__(self):
+        return str(self)
+
+
+__all__ = [
+    "Node"
+]

danielutils/data_structures/heap/__init__.py

@@ -0,0 +1,3 @@
+from .heap import *
+from .max_heap import *
+from .min_heap import *