danielutils 1.1.28__py3-none-any.whl

danielutils/better_builtins/typed_builtins/tset.py

@@ -0,0 +1,67 @@
+from typing import Generic, TypeVar, Iterable
+from .factory import create_typed_class
+from ...functions import isoftype
+T = TypeVar("T")
+parent: type = create_typed_class("tset", set)
+
+
+class tset(parent, Generic[T]):  # type:ignore
+    """like 'set' but with runtime type safety
+    """
+
+    def subscribable_init(self, *args, **kwargs):  # pylint: disable=unused-argument
+        """the "real" __init__ function
+        """
+        print(self.get_params())
+
+    def add(self, value: T) -> None:
+        """adds an item to the set
+
+        Args:
+            value (T): item
+
+        Raises:
+            TypeError: if item is if the wrong type
+        """
+        if not isoftype(value, self.get_params()):  # type:ignore
+            raise TypeError(
+                f"Can't add. Expected {self.get_params()} but got '{value}' which is {type(value)}")
+        set.add(self, value)
+
+    def update(self, *s: Iterable[T]) -> None:
+        """updates the set with another iterable
+        """
+        for value in s:
+            if isinstance(value, Iterable):
+                for subv in value:
+                    self.update(subv)  # type:ignore
+            else:
+                self.add(value)  # type:ignore
+
+    def union(self, *s: Iterable[T]) -> "tset[T]":
+        """creates a union of two sets
+
+        Returns:
+            tset[T]: the resulting set
+        """
+        type_set = set(self.get_params())
+        for value in s:
+            if isinstance(value, Iterable):
+                for subv in value:
+                    type_set.add(type(subv))
+            else:
+                type_set.add(type(value))
+        final_type = next(iter(type_set))
+        for t in type_set:
+            final_type = final_type | t
+        res = tset[final_type]()  # type:ignore
+        # we can skip the type checking because they will be okay
+        set.update(res, self)
+        for value in s:
+            set.update(res, value)
+        return res
+
+
+__all__ = [
+    "tset"
+]

danielutils/better_builtins/typed_builtins/ttuple.py

@@ -0,0 +1,15 @@
+
+from typing import Generic, TypeVar
+from .factory import create_typed_class
+T = TypeVar("T")
+parent_ttuple: type = create_typed_class("ttuple", tuple)
+
+
+class ttuple(parent_ttuple, Generic[T]):
+    """like tuple but with runtime type safety
+    """
+
+
+__all__ = [
+    "ttuple"
+]

danielutils/colors.py

@@ -0,0 +1,203 @@
+import logging
+from typing import Optional, IO
+from .decorators import validate
+from .logging_.utils import get_logger
+logger = get_logger(__name__)
+
+RESET = "\033[0m"
+
+
+class ColoredText:
+    """static utility class with static functions:\n
+        from_rgb,
+        green,
+        red,
+        blue,
+        red,
+        yellow,
+        white,
+        black
+    """
+
+    @staticmethod  # type:ignore
+    @validate  # type:ignore
+    def from_rgb(red: int, green: int, blue: int, text: str) -> str:
+        """Applies an RGB color to the given text.
+
+        Args:
+            red (int): The red component of the color.
+            green (int): The green component of the color.
+            blue (int): The blue component of the color.
+            text (str): The text to apply the color to.
+
+        Returns:
+            str: The given text with an RGB color applied to it.
+        """
+        logger.debug("Applying RGB color (%s, %s, %s) to text: %s...", red, green, blue, text[:50])
+        return f"\033[38;2;{red};{green};{blue}m{text}{RESET}"
+
+    @staticmethod
+    def green(text: str) -> str:
+        """Applies green color to the given text.
+
+        Args:
+            text (str): The text to apply the green color to.
+
+        Returns:
+            str: The given text with green color applied to it.
+        """
+        return ColoredText.from_rgb(0, 255, 0, text)
+
+    @staticmethod
+    def blue(text: str):
+        """Applies blue color to the given text.
+
+        Args:
+            text (str): The text to apply the blue color to.
+
+        Returns:
+            str: The given text with blue color applied to it.
+        """
+        return ColoredText.from_rgb(0, 0, 255, text)
+
+    @staticmethod
+    def red(text: str):
+        """Applies red color to the given text.
+
+        Args:
+            text (str): The text to apply the red color to.
+
+        Returns:
+            str: The given text with red color applied to it.
+        """
+        return ColoredText.from_rgb(255, 0, 0, text)
+
+    @staticmethod
+    def yellow(text: str):
+        """Applies yellow color to the given text.
+
+        Args:
+            text (str): The text to apply the yellow color to.
+
+        Returns:
+            str: The given text with yellow color applied to it.
+        """
+        return ColoredText.from_rgb(255, 255, 0, text)
+
+    @staticmethod
+    def orange(text: str):
+        """Applies yellow color to the given text.
+
+        Args:
+            text (str): The text to apply the yellow color to.
+
+        Returns:
+            str: The given text with yellow color applied to it.
+        """
+        return ColoredText.from_rgb(255, 165, 0, text)
+
+    @staticmethod
+    def white(text: str):
+        """Applies white color to the given text.
+
+        Args:
+            text (str): The text to apply the white color to.
+
+        Returns:
+            str: The given text with white color applied to it.
+        """
+        return ColoredText.from_rgb(255, 255, 255, text)
+
+    @staticmethod
+    def black(text: str):
+        """Applies black color to the given text.
+
+        Args:
+            text (str): The text to apply the black color to.
+
+        Returns:
+            str: The given text with black color applied to it.
+        """
+        return ColoredText.from_rgb(0, 0, 0, text)
+
+    @staticmethod
+    def supports_color(stream: IO) -> bool:
+        """return whether a stream will support colored text
+
+        Args:
+            stream (IO): stream to check
+
+        Returns:
+            bool: boolean result
+        """
+        result = stream.isatty()
+        logger.debug("Color support check for stream: %s", result)
+        return result
+
+
+def __special_print(*args, sep: str = " ", end: str = "\n", start_with: Optional[str] = None):
+    """inner helper function"""
+    if start_with:
+        if "\n" not in sep:
+            print(f"{start_with}: ", end="")
+            print(sep.join([str(arg) for arg in args]), sep="", end=end)
+        else:
+            print(
+                sep.join([f"{start_with}: {str(arg)}" for arg in args]), sep="", end=end)
+    else:
+        print(*args, sep=sep, end=end)
+
+
+def success(*args, sep: str = " ", end: str = "\n"):
+    """print a success message
+
+    Args:
+        sep (str, optional): print separator. Defaults to " ".
+        end (str, optional): print endline. Defaults to "\\n".
+    """
+
+    __special_print(*args, sep=sep, end=end,
+                    start_with=ColoredText.green("SUCCESS"))
+
+
+def warning(*args, sep: str = " ", end: str = "\n"):
+    """print a warning message
+
+    Args:
+        sep (str, optional): print separator. Defaults to " ".
+        end (str, optional): print endline. Defaults to "\\n".
+    """
+
+    __special_print(*args, sep=sep, end=end,
+                    start_with=ColoredText.orange("WARNING"))
+
+
+def error(*args, sep: str = " ", end: str = "\n"):
+    """print an error message
+
+    Args:
+        sep (str, optional): print separator. Defaults to " ".
+        end (str, optional): print endline. Defaults to "\\n".
+    """
+    __special_print(*args, sep=sep, end=end,
+                    start_with=ColoredText.red("ERROR"))
+
+
+def info(*args, sep: str = " ", end: str = "\n"):
+    """print an info message
+
+    Args:
+        sep (str, optional): print separator. Defaults to " ".
+        end (str, optional): print endline. Defaults to "\\n".
+    """
+    __special_print(*args, sep=sep, end=end,
+                    start_with=ColoredText.yellow("INFO"))
+
+
+__all__ = [
+    "ColoredText",
+    "success",
+    "warning",
+    "error",
+    "info"
+]

danielutils/context_managers/__init__.py

@@ -0,0 +1,5 @@
+from .attr_context import *
+from .multi_context import *
+from .optional_context import *
+from .state_context import *
+from .temporary_file import *

danielutils/context_managers/attr_context.py

@@ -0,0 +1,40 @@
+import logging
+from typing import ContextManager
+from ..logging_.utils import get_logger
+
+logger = get_logger(__name__)
+
+
+class AttrContext(ContextManager):
+    def __init__(self, obj: object, attr: str, new_value: object, *, nonexistent_is_error: bool = True) -> None:
+        logger.debug("Initializing AttrContext for %s.%s = %s", type(obj).__name__, attr, new_value)
+        self.obj = obj
+        self.attr = attr
+        self.new_value = new_value
+        self.old_value = None
+        self._has_attr: bool = hasattr(self.obj, self.attr)
+        if nonexistent_is_error and not self._has_attr:
+            logger.error("Attribute '%s' does not exist on %s", self.attr, type(obj).__name__)
+            raise RuntimeError(f"Nonexistent attribute '{self.attr}' in '{self.obj}'")
+        logger.debug("AttrContext initialized successfully, has_attr=%s", self._has_attr)
+
+    def __enter__(self) -> 'AttrContext':
+        logger.debug("Entering AttrContext for %s.%s", type(self.obj).__name__, self.attr)
+        self.old_value = getattr(self.obj, self.attr, None)
+        setattr(self.obj, self.attr, self.new_value)
+        logger.info("Attribute %s set to %s (was %s)", self.attr, self.new_value, self.old_value)
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        logger.debug("Exiting AttrContext for %s.%s, exc_type=%s", type(self.obj).__name__, self.attr, exc_type)
+        if self._has_attr:
+            setattr(self.obj, self.attr, self.old_value)
+            logger.info("Attribute %s restored to %s", self.attr, self.old_value)
+        else:
+            delattr(self.obj, self.attr)
+            logger.info("Temporary attribute %s removed", self.attr)
+
+
+__all__ = [
+    'AttrContext'
+]

danielutils/context_managers/multi_context.py

@@ -0,0 +1,34 @@
+import logging
+from typing import ContextManager
+from ..logging_.utils import get_logger
+
+logger = get_logger(__name__)
+
+
+class MultiContext(ContextManager):
+    def __init__(self, *contexts: ContextManager):
+        logger.debug("Initializing MultiContext with %s contexts", len(contexts))
+        self.contexts = contexts
+
+    def __enter__(self):
+        logger.info("Entering MultiContext with %s contexts", len(self.contexts))
+        for i, context in enumerate(self.contexts):
+            logger.debug("Entering context %s/%s: %s", i+1, len(self.contexts), type(context).__name__)
+            context.__enter__()
+        logger.debug("All contexts entered successfully")
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        logger.debug("Exiting MultiContext with %s contexts, exc_type=%s", len(self.contexts), exc_type)
+        for i, context in enumerate(self.contexts):
+            logger.debug("Exiting context %s/%s: %s", i+1, len(self.contexts), type(context).__name__)
+            context.__exit__(exc_type, exc_val, exc_tb)
+        logger.info("All contexts exited")
+
+    def __getitem__(self, index):
+        return self.contexts[index]
+
+
+__all__ = [
+    "MultiContext",
+]

danielutils/context_managers/optional_context.py

@@ -0,0 +1,33 @@
+import logging
+from typing import ContextManager
+from ..logging_.utils import get_logger
+
+logger = get_logger(__name__)
+
+
+class OptionalContext(ContextManager):
+    def __init__(self, predicate: bool, context: ContextManager):
+        logger.debug("Initializing OptionalContext with predicate=%s, context=%s", predicate, type(context).__name__)
+        self.predicate = predicate
+        self.context = context
+
+    def __enter__(self):
+        logger.debug("Entering OptionalContext with predicate=%s", self.predicate)
+        if self.predicate:
+            logger.info("Condition met, entering context: %s", type(self.context).__name__)
+            self.context.__enter__()
+        else:
+            logger.debug("Condition not met, skipping context entry")
+
+    def __exit__(self, __exc_type, __exc_value, __traceback):
+        logger.debug("Exiting OptionalContext with predicate=%s, exc_type=%s", self.predicate, __exc_type)
+        if self.predicate:
+            logger.info("Condition was met, exiting context: %s", type(self.context).__name__)
+            self.context.__exit__(__exc_type, __exc_value, __traceback)
+        else:
+            logger.debug("Condition was not met, no context to exit")
+
+
+__all__=[
+    "OptionalContext"
+]

danielutils/context_managers/state_context.py

@@ -0,0 +1,25 @@
+import logging
+from contextlib import contextmanager
+from ..custom_types import Procedure
+from ..logging_.utils import get_logger
+
+logger = get_logger(__name__)
+
+
+@contextmanager
+def StateContext(set_state: Procedure, restore_state: Procedure):
+    logger.debug("Entering StateContext")
+    try:
+        logger.info("Setting state")
+        set_state()
+        logger.debug("State set successfully, yielding control")
+        yield
+    finally:
+        logger.info("Restoring state")
+        restore_state()
+        logger.debug("State restored successfully")
+
+
+__all__ = [
+    'StateContext'
+]

danielutils/context_managers/temporary_file.py

@@ -0,0 +1,108 @@
+import atexit
+import logging
+import random
+from typing import ContextManager, Set, List, Literal, Optional
+from ..io_ import file_exists, delete_file
+from ..logging_.utils import get_logger
+
+logger = get_logger(__name__)
+
+
+class TemporaryFile(ContextManager):
+    _instances: Set['TemporaryFile'] = set()
+
+    @classmethod
+    def random(cls, length: int = 10, /, type: Literal["file", "folder"] = "file", prefix: Optional[str] = None,
+               suffix: Optional[str] = None) -> 'TemporaryFile':
+        from danielutils import RandomDataGenerator
+        temp_name = f"{type}_"
+        if prefix is not None:
+            temp_name += f"{prefix}_"
+
+        temp_name += RandomDataGenerator.name(length)
+        if suffix is not None:
+            temp_name += f"_{suffix}"
+        logger.debug("Creating random temporary file: %s", temp_name)
+        return TemporaryFile(temp_name)
+
+    def __init__(self, path: str):
+        if file_exists(path):
+            logger.error("Can't create temporary file - file already exists: %s", path)
+            raise RuntimeError(f"Can't create a temporary file if file '{path}' already exists.")
+        self.path = path
+        TemporaryFile._instances.add(self)
+        logger.debug("TemporaryFile created: %s", path)
+
+    def __enter__(self):
+        logger.debug("TemporaryFile context entered: %s", self.path)
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if exc_type is not None:
+            logger.warning("TemporaryFile context exited with exception: %s: %s", exc_type.__name__, exc_val)
+        else:
+            logger.debug("TemporaryFile context exited successfully: %s", self.path)
+        self.close()
+
+    def __str__(self) -> str:
+        return self.path
+
+    def close(self) -> None:
+        logger.debug("Closing temporary file: %s", self.path)
+        delete_file(self.path)
+
+    def read(self) -> str:
+        if not file_exists(self.path):
+            logger.debug("Temporary file does not exist for reading: %s", self.path)
+            return ""
+        logger.debug("Reading temporary file: %s", self.path)
+        with open(self.path, 'r') as f:
+            return f.read()
+
+    def readbinary(self) -> bytes:
+        if not file_exists(self.path):
+            logger.debug("Temporary file does not exist for binary reading: %s", self.path)
+            return b""
+        logger.debug("Reading temporary file as binary: %s", self.path)
+        with open(self.path, 'rb') as f:
+            return f.read()
+
+    def readlines(self) -> List[str]:
+        if not file_exists(self.path):
+            logger.debug("Temporary file does not exist for reading lines: %s", self.path)
+            return []
+        logger.debug("Reading lines from temporary file: %s", self.path)
+        with open(self.path, 'r') as f:
+            return f.readlines()
+
+    def write(self, s: str) -> None:
+        logger.debug("Writing to temporary file: %s", self.path)
+        with open(self.path, 'a') as f:
+            f.write(s)
+
+    def writebinary(self, s: bytes) -> None:
+        logger.debug("Writing binary data to temporary file: %s", self.path)
+        with open(self.path, 'ab') as f:
+            f.write(s)
+
+    def writelines(self, lines: List[str]) -> None:
+        logger.debug("Writing %s lines to temporary file: %s", len(lines), self.path)
+        with open(self.path, 'a') as f:
+            f.writelines(lines)
+
+    def clear(self):
+        logger.debug("Clearing temporary file: %s", self.path)
+        with open(self.path, 'w') as _:
+            pass
+
+
+@atexit.register
+def __close_all():
+    logger.debug("Closing %s temporary files at exit", len(TemporaryFile._instances))
+    for inst in TemporaryFile._instances:  # type:ignore #pylint: disable=all
+        inst.close()
+
+
+__all__ = [
+    'TemporaryFile'
+]

danielutils/convenience.py

@@ -0,0 +1,12 @@
+"""class for convenience"""
+
+
+class DisablePytestDiscovery:
+    """inheriting from this class will disable pytest discovery
+    """
+    __test__ = False
+
+
+__all__ = [
+    "DisablePytestDiscovery"
+]

danielutils/conversions/__init__.py

@@ -0,0 +1,2 @@
+from .main_conversions import *
+from .specialized_conversions import *

danielutils/conversions/main_conversions.py

@@ -0,0 +1,131 @@
+from ..decorators import validate
+
+
+@validate  # type:ignore
+def char_to_int(c: str) -> int:
+    """convert char to its representing int value
+
+    Args:
+        c (str): char to convert
+
+    Returns:
+        int: int value
+    """
+    return ord(c)
+
+
+@validate  # type:ignore
+def int_to_char(num: int) -> str:
+    """convert int to its corresponding char
+
+    Args:
+        num (int): number to convert
+
+    Returns:
+        str: result character
+    """
+    return chr(num)
+
+
+@validate  # type:ignore
+def hex_to_char(h: str) -> str:
+    """convert hex number to char
+
+    Args:
+        h (str): number to convert
+
+    Returns:
+        str: result char
+    """
+    return int_to_char(hex_to_dec(h))
+
+
+@validate  # type:ignore
+def hex_to_dec(h: str) -> int:
+    """convert hex to dec
+
+    Args:
+        h (str): converts base 16 to base 10
+
+    Returns:
+        int: decimal value for hex number
+    """
+    return int(h, 16)
+
+
+@validate  # type:ignore
+def char_to_hex(c: str) -> str:
+    """convert char to hex
+
+    Args:
+        c (str): char to convert
+
+    Returns:
+        str: hex representation
+    """
+    return int_to_hex(char_to_int(c))
+
+
+@validate  # type:ignore
+def dec_to_hex(num: int) -> str:
+    """convert decimal number to hex
+
+    Args:
+        num (int): number to convert
+
+    Returns:
+        str: _description_
+    """
+    return int_to_hex(num)
+
+
+@validate  # type:ignore
+def int_to_hex(num: int) -> str:
+    """converts an int to it's hex representation
+
+    Args:
+        num (int): int to convert
+
+    Returns:
+        str: the hex representation of the int
+    """
+    return hex(num)
+
+
+@validate  # type:ignore
+def bytes_to_str(b: bytes) -> str:
+    """decodes bytes to str
+
+    Args:
+        b (bytes): bytes to decode
+
+    Returns:
+        str: result
+    """
+    return b.decode("utf-8")
+
+
+@validate  # type:ignore
+def str_to_bytes(s: str) -> bytes:
+    """encodes a string to bytes
+
+    Args:
+        s (str): the string to encode
+
+    Returns:
+        bytes: result
+    """
+    return bytes(s, encoding='utf-8')
+
+
+__all__ = [
+    "char_to_int",
+    "int_to_char",
+    "hex_to_char",
+    "hex_to_dec",
+    "char_to_hex",
+    "dec_to_hex",
+    "int_to_hex",
+    "bytes_to_str",
+    "str_to_bytes"
+]

danielutils/conversions/specialized_conversions/__init__.py

@@ -0,0 +1,2 @@
+from .to_hex import *
+from .to_int import *