danielutils 0.9.68__tar.gz → 0.9.70__tar.gz

{danielutils-0.9.68 → danielutils-0.9.70}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: danielutils
-Version: 0.9.68
+Version: 0.9.70
 Summary: A python utils library for things I find useful
 Author-email: danielnachumdev <danielnachumdev@gmail.com>
 License: MIT License

{danielutils-0.9.68 → danielutils-0.9.70}/danielutils/__init__.py

@@ -28,4 +28,5 @@ from .university import *
 from .my_tqdm import *
 from .threads import *
 from .loops import *
-from .multi_x import *
+from .multi_x import *
+from .package_utils import *

danielutils-0.9.70/danielutils/data_structures/Comparer.py

@@ -0,0 +1,40 @@
+"""Comparer class"""
+from typing import Callable, Any, Union, Generic, TypeVar
+from .functions import default_weight_function
+
+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
+
+    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
+            """
+        return self.func(v1, v2)
+
+    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-0.9.68 → danielutils-0.9.70}/danielutils/data_structures/Stack.py

@@ -1,16 +1,18 @@
-from typing import Optional, Generator, Any, cast
-from .node import Node
+from typing import Optional, Generator, Any, cast, TypeVar, Generic
+from .graph import Node
 
+T = TypeVar('T')
 
-class Stack:
+
+class Stack(Generic[T]):
     """A classic Stack class
     """
 
     def __init__(self) -> None:
-        self.head: Optional[Node] = None
+        self.head: Optional[Node[T]] = None
         self.size = 0
 
-    def push(self, value: Any):
+    def push(self, value: Node[T]):
         """push an item to the stack
 
         Args:
@@ -23,7 +25,7 @@ class Stack:
             self.head = new_head
         self.size += 1
 
-    def pop(self) -> Any:
+    def pop(self) -> Node[T]:
         """pop an item from the stack
 
         Returns:
@@ -39,7 +41,7 @@ class Stack:
     def __len__(self) -> int:
         return self.size
 
-    def __iter__(self) -> Generator:
+    def __iter__(self) -> Generator[Node[T], None, None]:
         while self:
             yield self.pop()
 
@@ -51,7 +53,7 @@ class Stack:
     def __bool__(self) -> bool:
         return not self.is_empty()
 
-    def __contains__(self, value) -> bool:
+    def __contains__(self, value: T) -> bool:
         curr = self.head
         while curr is not None:
             if curr.data == value:

{danielutils-0.9.68 → danielutils-0.9.70}/danielutils/data_structures/__init__.py

@@ -1,7 +1,6 @@
 from .queue import *
 from .heap import *
 from .comparer import *
-from .node import *
 from .graph import *
 from .stack import *
 from .default_dict import *

{danielutils-0.9.68 → danielutils-0.9.70}/danielutils/decorators/__init__.py

@@ -12,3 +12,4 @@ from .threadify import *
 from .delay_call import *
 from .deprecate import *
 from .processify import *
+from .singleton import *

{danielutils-0.9.68 → danielutils-0.9.70}/danielutils.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: danielutils
-Version: 0.9.68
+Version: 0.9.70
 Summary: A python utils library for things I find useful
 Author-email: danielnachumdev <danielnachumdev@gmail.com>
 License: MIT License

{danielutils-0.9.68 → danielutils-0.9.70}/danielutils.egg-info/SOURCES.txt

@@ -16,6 +16,7 @@ danielutils/multi_x.py
 danielutils/my_tqdm.py
 danielutils/path.py
 danielutils/print.py
+danielutils/py.typed
 danielutils/relations.py
 danielutils/signals.py
 danielutils/text.py
@@ -48,19 +49,11 @@ danielutils/conversions/specialized_conversions/__init__.py
 danielutils/conversions/specialized_conversions/to_hex.py
 danielutils/conversions/specialized_conversions/to_int.py
 danielutils/data_structures/Comparer.py
-danielutils/data_structures/Graph.py
-danielutils/data_structures/Heap.py
-danielutils/data_structures/Node.py
-danielutils/data_structures/Queue.py
 danielutils/data_structures/Stack.py
 danielutils/data_structures/__init__.py
 danielutils/data_structures/comparer.py
 danielutils/data_structures/default_dict.py
 danielutils/data_structures/functions.py
-danielutils/data_structures/graph.py
-danielutils/data_structures/heap.py
-danielutils/data_structures/node.py
-danielutils/data_structures/queue.py
 danielutils/data_structures/stack.py
 danielutils/decorators/__init__.py
 danielutils/decorators/atomic.py

{danielutils-0.9.68 → danielutils-0.9.70}/pyproject.toml

@@ -4,28 +4,28 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "danielutils"
-version = "0.9.68"
+version = "0.9.70"
 authors = [
     { name = "danielnachumdev", email = "danielnachumdev@gmail.com" },
 ]
-dependencies = ["tqdm"]
+dependencies = ['tqdm']
 keywords = ['functions', 'decorators', 'methods', 'classes', 'metaclasses']
 license = { "file" = "LISENCE" }
 description = "A python utils library for things I find useful"
 readme = "README.md"
 requires-python = ">=3.8.17"
 classifiers = [
-    "Development Status :: 3 - Alpha",
-    "Intended Audience :: Developers",
-    "Programming Language :: Python :: 3",
-    # "Operating system :: Unix",
-    # "Operating system :: MacOS :: MacOS X",
-    "Operating System :: Microsoft :: Windows",
+	"Development Status :: 3 - Alpha",
+	"Intended Audience :: Developers",
+	"Programming Language :: Python :: 3",
+	"Operating System :: Microsoft :: Windows"
 ]
 
 [tool.setuptools]
 packages = ["danielutils"]
+[tool.setuptools.package-data]
+"danielutils" = ["py.typed"]
 
 [project.urls]
 "Homepage" = "https://github.com/danielnachumdev/danielutils"
-"Bug Tracker" = "https://github.com/danielnachumdev/danielutils/issues"
+"Bug Tracker" = "https://github.com/danielnachumdev/danielutils/issues"

{danielutils-0.9.68 → danielutils-0.9.70}/setup.py

@@ -1,2 +1,3 @@
 from setuptools import setup
-setup()
+
+setup()

danielutils-0.9.68/danielutils/data_structures/Comparer.py

@@ -1,37 +0,0 @@
-"""Comparer class"""
-from typing import Callable, Any, Union
-from .functions import default_weight_function
-
-
-class Comparer():
-    """a Comparer class to be used when comparing two objects
-    """
-
-    def __init__(self, func: Callable[[Any, Any], Union[int, float]]):
-        self.func = func
-
-    def compare(self, v1: Any, v2: Any) -> 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
-            """
-        return self.func(v1, v2)
-
-    def __call__(self, v1: Any, v2: Any) -> Union[int, float]:
-        return self.compare(v1, v2)
-
-
-CompareGreater = Comparer(lambda a, b: default_weight_function(a) -
-                          default_weight_function(b))
-CompareSmaller = Comparer(lambda a, b: default_weight_function(b) -
-                          default_weight_function(a))
-__all__ = [
-    "Comparer",
-    "CompareGreater",
-    "CompareSmaller"
-]

danielutils-0.9.68/danielutils/data_structures/Graph.py

@@ -1,134 +0,0 @@
-from typing import Optional, Generator, List as t_list, Set as t_set
-from .queue import Queue
-from .node import MultiNode
-from ..reflection import get_python_version
-if get_python_version() >= (3, 9):
-    from builtins import list as t_list, set as t_set
-
-
-class Graph:
-    """A general-purpose Graph class.
-
-    This class represents a directed graph, where nodes can be connected through edges.
-
-    Attributes:
-        nodes (Optional[t_list[MultiNode]]): A list of MultiNode instances representing the nodes in the graph.
-                                             Default is an empty list.
-
-    Methods:
-        __init__(self, nodes: Optional[t_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 __init__(self, nodes: Optional[t_list[MultiNode]] = None):
-        self.nodes: t_list[MultiNode] = nodes if nodes is not None else []
-
-    def add_node(self, node):
-        """Add a node to the graph.
-
-        Args:
-            node: The MultiNode instance to add to the graph.
-        """
-        self.nodes.append(node)
-
-    def _extended_dfs(self) -> Generator:
-        """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 = []
-
-        def handle_node(node: MultiNode):
-            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 dfs(self) -> Generator:
-        """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.
-        """
-        yield from self._extended_dfs()
-
-    def topological_sort(self) -> list:
-        """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.
-        """
-        g = self._extended_dfs()
-        try:
-            while True:
-                next(g)
-        except StopIteration as e:
-            return e.value
-
-    def bfs(self) -> Generator:
-        """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.
-        """
-        q = Queue()
-        for node in self.nodes:
-            q.push(node)
-        seen: t_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)
-
-    def __str__(self) -> str:
-        tmp = []
-        for n in self.dfs():
-            tmp.append(f"\t{str(n)}")
-        return "Graph(\n"+",\n".join(tmp)+"\n)"
-
-
-__all__ = [
-    "Graph"
-]

danielutils-0.9.68/danielutils/data_structures/Heap.py

@@ -1,111 +0,0 @@
-from typing import Any, Union
-from .comparer import Comparer, CompareGreater, CompareSmaller
-
-
-class Heap:
-    """a Heap class which will do the sorting according to the supplied comparer object
-    """
-
-    def __init__(self, comparer: Comparer) -> None:
-        self.arr: list = []
-        self.comparer = comparer
-
-    def push(self, val: Any) -> None:
-        """will add a new object to the heap
-
-        Args:
-            val (Any): the object to add to the heap
-        """
-        res: Union[int, float] = -1
-        curr_index = len(self)
-        self.arr.append(val)
-        parent_index = curr_index//2 - (1 - curr_index % 2)
-        while res < 0 and parent_index >= 0:
-            res = self.comparer.compare(
-                self[parent_index], self[curr_index])
-            if res < 0:
-                self.arr[parent_index], self.arr[curr_index] = self[curr_index], self[parent_index]
-                curr_index = parent_index
-                parent_index = curr_index//2 - (1 - curr_index % 2)
-
-    def __len__(self):
-        return len(self.arr)
-
-    def __getitem__(self, index: int):
-        return self.arr[index]
-
-    def is_empty(self) -> bool:
-        """return whether the heap is empty
-
-        Returns:
-            bool: result
-        """
-        return len(self) == 0
-
-    def pop(self) -> Any:
-        """return the value at the top of the heap while removing it
-
-        Returns:
-            Any: the result
-        """
-        res = self[0]
-        self.arr[0], self.arr[-1] = self[-1], self[0]
-        self.arr.pop()
-        flag = True
-        curr_index = 0
-        while flag:
-            child1_index = curr_index*2+1
-            child2_index = curr_index*2+2
-            if len(self) > child2_index:
-                if self.comparer.compare(self[child1_index], self[child2_index]) < 0:
-                    self.arr[curr_index], self.arr[child2_index] = self[child2_index], self[curr_index]
-                    curr_index = child2_index
-                elif self.comparer.compare(self[child1_index], self[child2_index]) > 0:
-                    self.arr[curr_index], self.arr[child1_index] = self[child1_index], self[curr_index]
-                    curr_index = child1_index
-                else:
-                    flag = False
-            else:
-                if len(self) > child1_index:
-                    if self.comparer.compare(self[child1_index], self[curr_index]) > 0:
-                        self.arr[curr_index], self.arr[child1_index] = self[child1_index], self[curr_index]
-                        curr_index = child1_index
-                    else:
-                        flag = False
-                else:
-                    flag = False
-        return res
-
-    def __str__(self):
-        return str(self.arr)
-
-    def peek(self) -> Any:
-        """return the value at the top of the Heap without removing it
-
-        Returns:
-            Any: the result
-        """
-        return self[0]
-
-
-class MaxHeap(Heap):
-    """classic MaxHeap implementation
-    """
-
-    def __init__(self):
-        super().__init__(CompareGreater)
-
-
-class MinHeap(Heap):
-    """classic MinHeap implementation
-    """
-
-    def __init__(self) -> None:
-        super().__init__(CompareSmaller)
-
-
-__all__ = [
-    "Heap",
-    "MaxHeap",
-    "MinHeap",
-]

danielutils-0.9.68/danielutils/data_structures/Node.py

@@ -1,106 +0,0 @@
-from __future__ import annotations
-from typing import Any, Optional, Generator
-from ..metaclasses import ImplicitDataDeleterMeta
-
-
-class MultiNode:
-    """A node class with no limit to children amount
-    """
-
-    def __init__(self, data: Any, children: Optional[list[Optional[MultiNode]]] = None):
-        self.data = data
-        self._children = children if children is not None else []
-
-    def __getitem__(self, index) -> Any:
-        return self._children[index]
-
-    def __setitem__(self, value, index) -> None:
-        self._children[index] = value
-
-    def __len__(self) -> int:
-        return len(self._children)
-
-    def __iter__(self) -> Generator:
-        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))
-            return f"{node.__class__.__name__}({node.data}, ["+", ".join(tmp)+"])"
-
-        return handle_node(self)
-
-    def __repr__(self):
-        return str(self)
-
-    def add_child(self, child):
-        """adds a child to current node
-        """
-        self._children.append(child)
-
-
-class Node(MultiNode, metaclass=ImplicitDataDeleterMeta):
-    """A 'classic' node class with only one child
-    """
-
-    def __init__(self, data, next: Optional[Node] = None):  # pylint: disable=redefined-builtin
-        super().__init__(data, [next])
-
-    @property
-    def next(self):
-        """return the next node after self
-        """
-        return self._children[0]
-
-    @next.setter
-    def next(self, value):
-        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__ = [
-    "MultiNode",
-    "Node"
-]

danielutils-0.9.68/danielutils/data_structures/Queue.py

@@ -1,176 +0,0 @@
-from typing import Callable, Any, Union
-from .heap import Heap
-from .comparer import Comparer, CompareGreater
-from .functions import default_weight_function
-from ..metaclasses import AtomicClassMeta
-
-
-class Queue:
-    """classic Queue data structure"""
-
-    def __init__(self) -> None:
-        self.data: list = []
-
-    def pop(self) -> Any:
-        """return the oldest element while removing it from the queue
-
-        Returns:
-            Any: result
-        """
-        return self.data.pop()
-
-    def push(self, value: Any) -> None:
-        """adds a new element to the queue
-
-        Args:
-            value (Any): the value to add
-        """
-        self.data.insert(0, value)
-
-    def peek(self) -> Any:
-        """returns the oldest element in the queue 
-        without removing it from the queue
-
-        Returns:
-            Any: result
-        """
-        return self.data[-1]
-
-    def __len__(self) -> int:
-        return len(self.data)
-
-    def is_empty(self) -> bool:
-        """returns whether the queue is empty
-
-        Returns:
-            bool: result
-        """
-        return len(self) == 0
-
-    def __str__(self) -> str:
-        return repr(self)
-
-    def __repr__(self) -> str:
-        return str(self.data)
-
-    def __iter__(self):
-        return iter(self.data)
-
-    def push_many(self, arr: list):
-        """will push many objects to the Queue
-
-        Args:
-            arr (list): the objects to push
-        """
-        for v in arr:
-            self.push(v)
-
-
-class AtomicQueue(Queue, metaclass=AtomicClassMeta):
-    """Same as Queue but atomic
-    """
-
-
-class PriorityQueue(Queue):
-    """
-    A priority queue implementation based on a binary heap.
-
-    Args:
-        weight_func (Callable[[T], Union[int, float]], optional): A function to calculate the weight of items added
-            to the queue. Defaults to default_weight_function.
-        comparer (Comparer, optional): The comparer to use when comparing weights of items in the queue.
-            Defaults to Comparer.GREATER.
-
-    Raises:
-        ValueError: Raised if an item with the same weight value is added more than once.
-
-    Methods:
-        pop() -> T:
-            Removes and returns the item with the highest priority (i.e., the lowest weight value) from the queue.
-        push(value: T):
-            Adds a new item to the queue with the specified value and weight.
-        peek() -> T:
-            Returns the item with the highest priority 
-            (i.e., the lowest weight value) from the queue without removing it.
-        __str__() -> str:
-            Returns a string representation of the queue.
-
-    Example:
-        >>> pq = PriorityQueue()
-        >>> pq.push(5)
-        >>> pq.push(10)
-        >>> pq.push(3)
-        >>> pq.pop()
-        10
-    """
-
-    def __init__(self, weight_func: Callable[[Any], Union[int, float]] = default_weight_function):
-        super().__init__()
-        comparer = CompareGreater if weight_func is default_weight_function else Comparer(
-            lambda a, b: weight_func(a)-weight_func(b))
-        self.data: Heap = Heap(comparer)  # type:ignore
-        self.weight_func = weight_func
-        self.dct: dict = {}
-
-    def pop(self) -> Any:
-        """
-        Removes and returns the item with the highest priority (i.e., the lowest weight value) from the queue.
-
-        Returns:
-            T: The item with the highest priority in the queue.
-
-        Raises:
-            KeyError: Raised if the queue is empty.
-        """
-        item_weight = self.data.pop()
-        res = self.dct[item_weight]
-        del self.dct[item_weight]
-        return res
-
-    def push(self, value: Any):
-        """
-        Adds a new item to the queue with the specified value and weight.
-
-        Args:
-            value (T): The value of the item to add to the queue.
-
-        Returns:
-            None
-
-        Raises:
-            ValueError: Raised if an item with the same weight value is added more than once.
-        """
-        item_weight = self.weight_func(value)
-        if item_weight in self.dct:
-            raise ValueError(
-                "Can't have same weight value more than once in current implementation")
-        self.data.push(item_weight)
-        self.dct[item_weight] = value
-
-    def peek(self) -> Any:
-        """
-        Returns the item with the highest priority (i.e., the lowest weight value) from the queue without removing it.
-
-        Returns:
-            T: The item with the highest priority in the queue.
-
-        Raises:
-            KeyError: Raised if the queue is empty.
-        """
-        return self.dct[self.data.peek()]
-
-    def __str__(self) -> str:
-        """
-        Returns a string representation of the queue.
-
-        Returns:
-            str: A string representation of the queue.
-        """
-        return str([str(self.dct[w]) for w in [self.data[i] for i in range(len(self.data))]])
-
-
-__all__ = [
-    "Queue",
-    "AtomicQueue",
-    "PriorityQueue"
-]