danielutils 1.1.28__py3-none-any.whl

danielutils/data_structures/heap/heap.py

@@ -0,0 +1,119 @@
+import logging
+from typing import Union, TypeVar, Generic
+from ..comparer import Comparer
+from ...logging_.utils import get_logger
+logger = get_logger(__name__)
+
+T = TypeVar("T")
+
+
+class Heap(Generic[T]):
+    """a Heap class which will do the sorting according to the supplied comparer object
+    """
+
+    def __init__(self, comparer: Comparer) -> None:
+        logger.debug("Initializing Heap with comparer: %s", type(comparer).__name__)
+        self.arr: list = []
+        self.comparer = comparer
+
+    def push(self, val: T) -> None:
+        """will add a new object to the heap
+
+        Args:
+            val (Any): the object to add to the heap
+        """
+        logger.debug("Pushing value to heap: %s", val)
+        res: Union[int, float] = -1
+        curr_index = len(self)
+        self.arr.append(val)
+        logger.debug("Added value at index %s, heap size: %s", curr_index, len(self.arr))
+        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:
+                logger.debug("Swapping values at indices %s and %s", parent_index, curr_index)
+                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) -> T:
+        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) -> T:
+        """return the value at the top of the heap while removing it
+
+        Returns:
+            Any: the result
+        """
+        if self.is_empty():
+            logger.warning("Attempted to pop from empty heap")
+            raise IndexError("pop from empty heap")
+        
+        logger.debug("Popping from heap, current size: %s", len(self))
+        res = self[0]
+        self.arr[0], self.arr[-1] = self[-1], self[0]
+        self.arr.pop()
+        logger.debug("Swapped root with last element, new size: %s", len(self))
+        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:
+                    logger.debug("Swapping with right child at index %s", child2_index)
+                    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:
+                    logger.debug("Swapping with left child at index %s", child1_index)
+                    self.arr[curr_index], self.arr[child1_index] = self[child1_index], self[curr_index]
+                    curr_index = child1_index
+                else:
+                    logger.debug("Children are equal, heap property satisfied")
+                    flag = False
+            else:
+                if len(self) > child1_index:
+                    if self.comparer.compare(self[child1_index], self[curr_index]) > 0:
+                        logger.debug("Swapping with only child at index %s", child1_index)
+                        self.arr[curr_index], self.arr[child1_index] = self[child1_index], self[curr_index]
+                        curr_index = child1_index
+                    else:
+                        logger.debug("Heap property satisfied with only child")
+                        flag = False
+                else:
+                    logger.debug("No children, heap property satisfied")
+                    flag = False
+        logger.debug("Heap pop completed, returning: %s", res)
+        return res
+
+    def __str__(self):
+        return str(self.arr)
+
+    def peek(self) -> T:
+        """return the value at the top of the Heap without removing it
+
+        Returns:
+            Any: the result
+        """
+        if self.is_empty():
+            logger.warning("Attempted to peek at empty heap")
+            raise IndexError("peek at empty heap")
+        logger.debug("Peeking at heap top: %s", self[0])
+        return self[0]
+
+
+__all__ = [
+    "Heap",
+]

danielutils/data_structures/heap/max_heap.py

@@ -0,0 +1,18 @@
+from typing import TypeVar
+from ..comparer import CompareGreater
+from .heap import Heap
+
+T = TypeVar("T")
+
+
+class MaxHeap(Heap[T]):
+    """classic MaxHeap implementation
+    """
+
+    def __init__(self):
+        super().__init__(CompareGreater)
+
+
+__all__ = [
+    "MaxHeap"
+]

danielutils/data_structures/heap/min_heap.py

@@ -0,0 +1,18 @@
+from typing import TypeVar
+from ..comparer import CompareSmaller
+from .heap import Heap
+
+T = TypeVar("T")
+
+
+class MinHeap(Heap[T]):
+    """classic MinHeap implementation
+    """
+
+    def __init__(self) -> None:
+        super().__init__(CompareSmaller)
+
+
+__all__ = [
+    "MinHeap"
+]

danielutils/data_structures/queue/__init__.py

@@ -0,0 +1,3 @@
+from .queue import *
+from .atomic_queue import *
+from .priority_queue import *

danielutils/data_structures/queue/atomic_queue.py

@@ -0,0 +1,15 @@
+from typing import TypeVar
+from ...metaclasses import AtomicClassMeta
+from .queue import Queue
+
+T = TypeVar("T")
+
+
+class AtomicQueue(Queue[T], metaclass=AtomicClassMeta):
+    """Same as Queue but atomic
+    """
+
+
+__all__ = [
+    "AtomicQueue"
+]

danielutils/data_structures/queue/priority_queue.py

@@ -0,0 +1,110 @@
+from typing import Callable, Any, Union, TypeVar
+from ..heap import Heap
+from ..comparer import Comparer, CompareGreater
+from ..functions import default_weight_function
+from .queue import Queue
+
+T = TypeVar("T")
+
+
+class PriorityQueue(Queue[T]):
+    """
+    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(  # type:ignore
+            lambda a, b: weight_func(a) - weight_func(b))  # type:ignore
+        self.data: Heap = Heap(comparer)  # type:ignore
+        self.weight_func = weight_func
+        self.dct: dict = {}
+
+    def pop(self) -> T:
+        """
+        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: T) -> None:
+        """
+        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) -> T:
+        """
+        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__ = [
+    "PriorityQueue"
+]

danielutils/data_structures/queue/queue.py

@@ -0,0 +1,92 @@
+import logging
+from typing import Generic, TypeVar, Iterator, List as List
+from ...reflection import get_python_version
+from ...logging_.utils import get_logger
+
+if get_python_version() >= (3, 9):
+    from builtins import list as List
+T = TypeVar("T")
+
+logger = get_logger(__name__)
+
+
+class Queue(Generic[T]):
+    """classic Queue data structure"""
+
+    def __init__(self) -> None:
+        self.data: list = []
+        logger.debug("Queue initialized")
+
+    def pop(self) -> T:
+        """return the oldest element while removing it from the queue
+
+        Returns:
+            Any: result
+        """
+        if self.is_empty():
+            logger.warning("Attempted to pop from empty queue")
+            raise IndexError("pop from empty queue")
+        
+        result = self.data.pop()
+        logger.debug("Popped element from queue, remaining size: %s", len(self.data))
+        return result
+
+    def push(self, value: T) -> None:
+        """adds a new element to the queue
+
+        Args:
+            value (Any): the value to add
+        """
+        self.data.insert(0, value)
+        logger.debug("Pushed element to queue, new size: %s", len(self.data))
+
+    def peek(self) -> T:
+        """returns the oldest element in the queue 
+        without removing it from the queue
+
+        Returns:
+            Any: result
+        """
+        if self.is_empty():
+            logger.warning("Attempted to peek at empty queue")
+            raise IndexError("peek at empty queue")
+        
+        result = self.data[-1]
+        logger.debug("Peeked at element in queue, size: %s", len(self.data))
+        return result
+
+    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) -> Iterator[T]:
+        return iter(self.data)
+
+    def push_many(self, arr: List[T]):
+        """will push many objects to the Queue
+
+        Args:
+            arr (list): the objects to push
+        """
+        logger.debug("Pushing %s elements to queue", len(arr))
+        for v in arr:
+            self.push(v)
+        logger.info("Successfully pushed %s elements to queue", len(arr))
+
+
+__all__ = [
+    "Queue",
+]

danielutils/data_structures/stack.py

@@ -0,0 +1,102 @@
+import logging
+from typing import Optional, Generator, TypeVar, Generic
+from .graph import Node
+from ..logging_.utils import get_logger
+logger = get_logger(__name__)
+
+T = TypeVar('T')
+
+
+class Stack(Generic[T]):
+    """A classic Stack class
+    """
+
+    def __init__(self) -> None:
+        self.head: Optional[Node[T]] = None
+        self.size = 0
+        logger.debug("Stack initialized")
+
+    def push(self, value: T):
+        """push an item to the stack
+
+        Args:
+            value (Any): item to push
+        """
+        logger.debug("Pushing value to stack: %s", value)
+        if self.head is None:
+            self.head = Node(value)
+            logger.debug("Created first node in stack")
+        else:
+            new_head = Node(value, self.head)
+            self.head = new_head
+            logger.debug("Added new head node to stack")
+        self.size += 1
+        logger.debug("Stack size is now: %s", self.size)
+
+    def pop(self) -> T:
+        """pop an item from the stack
+
+        Returns:
+            Any: poped item
+        """
+        if not self.is_empty():
+            res = self.head.data  # type:ignore
+            self.size -= 1
+            self.head = self.head.next  # type:ignore
+            logger.debug("Popped value from stack: %s, remaining size: %s", res, self.size)
+            return res
+        logger.warning("Attempted to pop from empty stack")
+        raise RuntimeError("Can't pop from an empty stack")
+
+    def peek(self) -> Optional[T]:
+        """
+        Returns the top element of the stack
+        Returns:
+            Optional[T]
+        """
+        if self.is_empty():
+            logger.debug("Peek called on empty stack")
+            return None
+        result = self.head.data  # type:ignore
+        logger.debug("Peeked at stack top: %s", result)
+        return result
+
+    def __len__(self) -> int:
+        return self.size
+
+    def __iter__(self) -> Generator[T, None, None]:
+        while self:
+            yield self.pop()
+
+    def is_empty(self) -> bool:
+        """return whether the stack is empty
+        """
+        return len(self) == 0
+
+    def __bool__(self) -> bool:
+        return not self.is_empty()
+
+    def __contains__(self, value: T) -> bool:
+        curr = self.head
+        while curr is not None:
+            if curr.data == value:
+                return True
+            curr = curr.next
+        return False
+
+    def __str__(self) -> str:
+        values = []
+        curr = self.head
+        while curr:
+            values.append(str(curr.data))
+            curr = curr.next
+        inside = ", ".join(values)
+        return f"Stack({inside})"
+
+    def __repr__(self) -> str:
+        return str(self)
+
+
+__all__ = [
+    "Stack"
+]

danielutils/data_structures/trees/__init__.py

@@ -0,0 +1,2 @@
+from .binary_tree import *
+from .binary_syntax_tree import *

danielutils/data_structures/trees/binary_syntax_tree.py

@@ -0,0 +1,84 @@
+from typing import Union, Any, Callable,Dict as Dict
+from .binary_tree import BinaryTree
+from ..graph import BinaryNode
+from ...reflection import get_python_version
+if get_python_version()>=(3,9):
+    from builtins import dict as Dict
+
+class BinarySyntaxTree(BinaryTree):
+    """
+    Binary tree data structure to represent syntax of expressions
+    """
+
+    @staticmethod
+    def _evaluate_node(v: BinaryNode, operator_func_dict: Dict[Any, Callable[[Any, Any], Any]]):
+        if not isinstance(v, BinaryNode) or v.left is None and v.right is None:
+            return v
+
+        lres = BinarySyntaxTree._evaluate_node(v.left, operator_func_dict)
+        rres = BinarySyntaxTree._evaluate_node(v.right, operator_func_dict)
+
+        return operator_func_dict[v.data](lres, rres)
+
+    @property
+    def bottom_right(self) -> BinaryNode:
+        cur = self.root
+        while hasattr(cur, "right"):
+            if isinstance(cur, BinaryNode):
+                if cur.right is None:
+                    return cur
+                cur = cur.right
+            else:
+                break
+        return cur
+
+    @bottom_right.setter
+    def bottom_right(self, v: BinaryNode) -> None:
+        cur = self.root
+        while (
+                hasattr(cur, "right") and
+                isinstance(cur.right, BinaryNode) and
+                hasattr(cur.right, "right") and
+                isinstance(cur.right.right, BinaryNode)
+        ):
+            cur = cur.right
+        cur.right = v
+
+    @property
+    def bottom_left(self) -> BinaryNode:
+        cur = self.root
+        while hasattr(cur, "left"):
+            if isinstance(cur, BinaryNode):
+                if cur.left is None:
+                    return cur
+                cur = cur.left
+            else:
+                break
+        return cur
+
+    @bottom_left.setter
+    def bottom_left(self, v: BinaryNode) -> None:
+        cur = self.root
+        while (
+                hasattr(cur, "left") and
+                isinstance(cur.left, BinaryNode) and
+                hasattr(cur.left, "left") and
+                isinstance(cur.left.left, BinaryNode)
+        ):
+            cur = cur.left
+        cur.left = v
+
+    def reverse(self) -> "BinarySyntaxTree":
+        return BinarySyntaxTree(self.root.reverse())
+
+    def __reversed__(self) -> "BinarySyntaxTree":
+        return self.reverse()
+
+    def evaluate(self, operator_func_dict: Dict[Any, Callable[[Any, Any], Any]]) -> Any:
+        return BinarySyntaxTree._evaluate_node(self.root, operator_func_dict)
+
+
+
+__all__ = [
+    "BinarySyntaxTree"
+]

danielutils/data_structures/trees/binary_tree.py

@@ -0,0 +1,63 @@
+from enum import Enum
+
+from ..graph import BinaryNode
+from typing import TypeVar, Generic, Iterator
+
+T = TypeVar("T")
+
+
+class BinaryTree(Generic[T]):
+    Node: type = BinaryNode
+
+    class TraversalMode(Enum):
+        First = 1
+        Middle = 2
+        Last = 3
+
+    def __init__(self, root: BinaryNode[T]):
+        self._root = root
+
+    def __reversed__(self) -> 'BinaryTree[T]':
+        return self.reverse()
+
+    def __iter__(self) -> Iterator[BinaryNode[T]]:
+        yield from self.traverse(BinaryTree.TraversalMode.First)
+
+    def __eq__(self, other):
+        if not isinstance(other, BinaryTree):
+            return False
+
+        for a, b in zip(self, other):
+            if not (a == b):
+                return False
+        return True
+
+    @property
+    def root(self) -> BinaryNode[T]:
+        return self._root
+
+    def traverse(self, mode: 'TraversalMode') -> Iterator[BinaryNode[T]]:
+        def helper(node: BinaryNode[T]):
+            if mode == self.TraversalMode.First:
+                yield node
+            if node.left is not None:
+                yield from helper(node.left)
+            if mode == self.TraversalMode.Middle:
+                yield node
+            if node.right is not None:
+                yield from helper(node.right)
+            if mode == self.TraversalMode.Last:
+                yield node
+
+        yield from helper(self._root)
+
+    def reverse(self) -> "BinaryTree[T]":
+        return BinaryTree(self.root.reverse())
+
+    def depth(self) -> int:
+        return self.root.depth()
+
+
+__all__ = [
+    'BinaryTree'
+]

danielutils/date.py

@@ -0,0 +1,43 @@
+import json
+import logging
+from .decorators import validate
+from .logging_.utils import get_logger
+logger = get_logger(__name__)
+
+
+@validate  # type:ignore # type:ignore
+def dict_to_json(dct: dict) -> str:
+    """converts a python dict to a json object
+
+    Args:
+        d (dict): the dict to convert
+
+    Returns:
+        str: the json as string
+    """
+    logger.debug("Converting dict with %d keys to JSON", len(dct))
+    result = json.dumps(dct, indent=4)
+    logger.debug("JSON conversion completed, result length: %d", len(result))
+    return result
+
+
+@validate  # type:ignore
+def json_to_dict(json_str: str) -> dict:
+    """converts a json object from a string to a python dict
+
+    Args:
+        j (str): the json str to convert
+
+    Returns:
+        dict: a python dict from the json
+    """
+    logger.debug("Converting JSON string (length: %d) to dict", len(json_str))
+    result = json.loads(json_str)
+    logger.debug("JSON parsing completed, dict has %d keys", len(result))
+    return result
+
+
+__all__ = [
+    "dict_to_json",
+    "json_to_dict"
+]