danielutils 1.1.28__py3-none-any.whl

danielutils/random_.py

@@ -0,0 +1,47 @@
+import random
+
+LOWERCASE_LETTERS: str = "abcdefghijklmnopqrstuvwxyz"
+UPPERCASE_LETTERS: str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+LETTERS = LOWERCASE_LETTERS + UPPERCASE_LETTERS
+DIGITS: str = "0123456789"
+ALL = LETTERS + DIGITS
+
+
+def builder(length: int, letters: str) -> str:
+    return "".join(random.choices(letters, k=length))
+
+
+class RandomDataGenerator:
+
+    @staticmethod
+    def string(length: int) -> str:
+        return builder(length, ALL)
+
+    @staticmethod
+    def name(length: int) -> str:
+        return builder(length, LETTERS)
+
+    @staticmethod
+    def file_name(length: int) -> str:
+        return "file_" + RandomDataGenerator.name(length)
+
+    @staticmethod
+    def directory_name(length: int) -> str:
+        return "directory_" + RandomDataGenerator.name(length)
+
+    @staticmethod
+    def number(minimum: int, exclusive_maximum: int) -> int:
+        return random.randint(minimum, exclusive_maximum)
+
+    @staticmethod
+    def integer(minimum: int, exclusive_maximum: int) -> int:
+        return random.randint(minimum, exclusive_maximum)
+
+    @staticmethod
+    def float(minimum: float, exclusive_maximum: float) -> float:
+        return random.uniform(minimum, exclusive_maximum)
+
+
+__all__ = [
+    "RandomDataGenerator",
+]

danielutils/reflection/__init__.py

@@ -0,0 +1,6 @@
+from .interpreter import *  # this has to be first, the order matters!
+from .file import *
+from .function import *
+from .info_classes import *
+from .module import *
+from .declarations import *

danielutils/reflection/declarations.py

@@ -0,0 +1,288 @@
+import inspect
+import re
+from dataclasses import dataclass
+from typing import Any, List, Optional, Protocol, Tuple, Type, Union
+
+from .interpreter import get_python_version
+
+if get_python_version() >= (3, 9):
+    from builtins import list as List, tuple as Tuple  # type:ignore
+
+argument_kwargs = dict(frozen=True)
+function_declaration_kwargs = dict(frozen=True)
+if get_python_version() >= (3, 10):
+    argument_kwargs.update(slots=True)
+    function_declaration_kwargs.update(slots=True)
+
+
+def get_explicitly_declared_functions(cls: type) -> List[str]:
+    return [func for func, _ in inspect.getmembers(cls, predicate=inspect.isfunction)]
+
+
+def get_mro(obj: Any) -> List[type]:
+    if isinstance(obj, type):
+        return obj.mro()
+    return get_mro(obj.__class__)
+
+
+@dataclass(**argument_kwargs)
+class Argument:
+    name: str
+    type: Optional[str]
+    default: Optional[str]
+
+    def __hash__(self) -> int:
+        arg_type = self.type
+        if self.type is not None and "Union" in self.type:
+            arg_type = tuple(sorted(self.type[self.type.index("[") + 1:self.type.rindex("]")].split(",")))
+        return hash((self.name, arg_type, self.default))
+
+    def duplicate(self, **override_kwargs) -> 'Argument':
+        data = dict(name=self.name, type=self.type, default=self.default)
+        data.update(override_kwargs)
+        return Argument(**data)
+
+
+func_pattern = re.compile(
+    r"(.*def[\s\\]*?(\w+)[\s\\]*?\(([\w\W]*?)\)(?:[\s\\]*?->[\s\\]*?([\w\(\)\[\]\,]+))?[\s\\]*?:)",
+    flags=re.MULTILINE)
+not_whitespace_pattern = re.compile(r"\S+", flags=re.MULTILINE)
+arg_pattern = re.compile(r"([\w\*\/]+)(?:\s*?:\s*?([\w\[\]\(\)\,]+))?(?:\s*?=\s*?(.+))?")
+class_pattern = re.compile(r"\s*class\s+?\w+\s*?(?:\((.*)\))?\s*?:")
+
+
+def split_args(args: str) -> List[str]:
+    from ..data_structures.stack import Stack
+
+    res = []
+    stack: Stack[str] = Stack()
+    start = 0
+    for i, char in enumerate(args):
+        if char not in {'(', ')', '[', ']', ','}:
+            continue
+        if char in {'(', "["}:
+            stack.push(char)
+        elif char in {')', ']'}:
+            stack.pop()
+        elif stack.is_empty():
+            res.append(args[start:i])
+            start = i + 1
+
+    res.append(args[start:len(args)])
+    return res
+
+
+def _format_type_name(type_obj: Any) -> Optional[str]:
+    if type_obj is None or type_obj is inspect.Parameter.empty:
+        return None
+    origin = getattr(type_obj, "__origin__", None)
+    if origin is not None:
+        args = getattr(type_obj, "__args__", ())
+        formatted_args = ", ".join(_format_type_name(arg) or str(arg) for arg in args)
+        origin_name = getattr(origin, "__name__", str(origin).replace("typing.", ""))
+        return f"{origin_name}[{formatted_args}]"
+    if hasattr(type_obj, "__name__"):
+        return type_obj.__name__
+    return str(type_obj).replace("typing.", "")
+
+
+def _extract_generics_from_cls(cls: type) -> List[str]:
+    parameters: List[str] = []
+    for param in getattr(cls, "__parameters__", ()):
+        parameters.append(param.__name__)
+    return parameters
+
+
+def remove_whitespace(text: str) -> str:
+    return "".join(not_whitespace_pattern.findall(text.strip())).replace("\\", "")
+
+
+def _should_use_runtime_introspection(cls: type) -> bool:
+    return "<locals>" in getattr(cls, "__qualname__", "")
+
+
+def _source_matches_class(cls: type, src: str) -> bool:
+    if _should_use_runtime_introspection(cls):
+        return False
+    class_pattern_match = re.compile(
+        rf"^\s*class\s+{re.escape(cls.__name__)}\b",
+        re.MULTILINE,
+    )
+    return class_pattern_match.search(src) is not None
+
+
+@dataclass(**function_declaration_kwargs)
+class FunctionDeclaration:
+    name: str
+    arguments: Tuple[Argument, ...]
+    return_type: Optional[str]
+    decorators: Optional[List[str]] = None
+    generics: Optional[Tuple[str, ...]] = None
+
+    def duplicate(self, **override_kwargs) -> 'FunctionDeclaration':
+        data = dict(
+            name=self.name,
+            arguments=self.arguments,
+            return_type=self.return_type,
+            decorators=self.decorators,
+            generics=self.generics,
+        )
+        data.update(override_kwargs)
+        return FunctionDeclaration(**data)
+
+    @property
+    def has_generics(self) -> bool:
+        return self.generics is not None and len(self.generics) > 0
+
+    @staticmethod
+    def _from_runtime(cls: type) -> List['FunctionDeclaration']:
+        parameters = _extract_generics_from_cls(cls)
+        res: List[FunctionDeclaration] = []
+        expected_qualname_prefix = f"{cls.__qualname__}."
+        for name, obj in cls.__dict__.items():
+            if not inspect.isfunction(obj):
+                continue
+            if getattr(obj, "__qualname__", "") != expected_qualname_prefix + name:
+                continue
+            sig = inspect.signature(obj)
+            arguments: List[Argument] = []
+            for pname, param in sig.parameters.items():
+                if pname == "self":
+                    continue
+                ptype = _format_type_name(
+                    param.annotation if param.annotation is not inspect.Parameter.empty else None
+                )
+                default = None if param.default is inspect.Parameter.empty else repr(param.default)
+                arguments.append(Argument(pname, ptype, default))
+            return_type = _format_type_name(
+                sig.return_annotation if sig.return_annotation is not inspect.Signature.empty else None
+            )
+            res.append(FunctionDeclaration(
+                name,
+                tuple(arguments),
+                return_type,
+                decorators=None,
+                generics=tuple(parameters) or None,
+            ))
+        return res
+
+    @staticmethod
+    def get_declared_functions(cls) -> List['FunctionDeclaration']:
+        if not isinstance(cls, type):
+            raise TypeError('cls must be a Class')
+        if _should_use_runtime_introspection(cls):
+            return FunctionDeclaration._from_runtime(cls)
+        try:
+            src = inspect.getsource(cls)
+            if not _source_matches_class(cls, src):
+                return FunctionDeclaration._from_runtime(cls)
+        except (OSError, TypeError):
+            return FunctionDeclaration._from_runtime(cls)
+        bases = [item for item in map(remove_whitespace, class_pattern.findall(src)) if len(item) > 0]
+        parameters: List[str] = []
+        for base in bases:
+            if '[' in base and ']' in base:
+                generic_args = base[base.index('[') + 1:base.rindex(']')]
+                for arg in split_args(generic_args):
+                    if len(arg) == 1:
+                        parameters.append(arg)
+        res = []
+        for _, name, args, ret in func_pattern.findall(src):
+            name = name.strip()
+            if name not in cls.__dict__:
+                continue
+            args = remove_whitespace(args) if args is not None else None
+            arguments = []
+            if args is not None:
+                for arg in split_args(args):
+                    match = arg_pattern.match(remove_whitespace(arg))
+                    if match is not None:
+                        arguments.append(Argument(*match.groups()))
+            return_type = ret.strip() if ret is not None and len(ret) != 0 else None
+            res.append(FunctionDeclaration(
+                name,
+                tuple(arguments),
+                return_type,
+                decorators=None,
+                generics=tuple(parameters) or None,
+            ))
+        return res
+
+    def __eq__(self, other) -> bool:
+        if not isinstance(other, FunctionDeclaration):
+            return False
+        return (
+            self.name == other.name
+            and self.arguments == other.arguments
+            and self.return_type == other.return_type
+        )
+
+    def __hash__(self) -> int:
+        return hash((self.name, self.arguments, self.return_type))
+
+
+class _ProtocolMarker(Protocol):
+    ...
+
+
+_ProtocolMeta = type(_ProtocolMarker)
+del _ProtocolMarker
+
+
+@dataclass
+class ClassDeclaration:
+    cls: Type
+    name: str
+    module: str
+    bases: Tuple[Type, ...]
+    generics: Optional[Tuple[str, ...]]
+    functions: List[FunctionDeclaration]
+
+    @staticmethod
+    def from_cls(cls) -> 'ClassDeclaration':
+        if not isinstance(cls, type):
+            raise TypeError('obj must be a Class')
+
+        parameters: List[str] = []
+        if _should_use_runtime_introspection(cls):
+            parameters = _extract_generics_from_cls(cls)
+        else:
+            try:
+                src = "\n".join(
+                    line for line in inspect.getsource(cls).splitlines()
+                    if not remove_whitespace(line).startswith("@")
+                )
+                if not _source_matches_class(cls, src):
+                    raise OSError("source does not match class")
+                match = class_pattern.match(src)
+                bases = match.group(1).split(",") if match and match.group(1) else []
+                for base in bases:
+                    if '[' in base and ']' in base:
+                        generic_args = base[base.index('[') + 1:base.rindex(']')]
+                        for arg in split_args(generic_args):
+                            if len(arg) == 1:
+                                parameters.append(arg)
+            except (OSError, TypeError):
+                parameters = _extract_generics_from_cls(cls)
+
+        return ClassDeclaration(
+            cls,
+            cls.__name__,
+            cls.__module__,
+            getattr(cls, "__orig_bases__", getattr(cls, "__args__", ())),
+            tuple(parameters) or None,
+            FunctionDeclaration.get_declared_functions(cls),
+        )
+
+    @property
+    def is_generic(self) -> bool:
+        return self.generics is not None and len(self.generics) > 0
+
+
+__all__ = [
+    "Argument",
+    "ClassDeclaration",
+    "FunctionDeclaration",
+    "get_explicitly_declared_functions",
+    "get_mro",
+]

danielutils/reflection/file/__init__.py

@@ -0,0 +1 @@
+from .file_reflection import *

danielutils/reflection/file/file_reflection.py

@@ -0,0 +1,85 @@
+import inspect
+import logging
+import os
+from typing import Optional, cast
+from types import FrameType
+from ..interpreter.callstack import _get_prev_frame_from
+from ...logging_.utils import get_logger
+
+logger = get_logger(__name__)
+
+
+def get_caller_file_name() -> Optional[str]:
+    """return the name of the file that the caller of the
+    function that's using this function is in
+
+    Returns:
+        Optional[str]: name of file
+    """
+    logger.debug("Getting caller file name")
+    frame = _get_prev_frame_from(_get_prev_frame_from(inspect.currentframe()))
+    if frame is None:
+        logger.debug("No caller frame found")
+        return None
+    frame = cast(FrameType, frame)
+    filename = frame.f_code.co_filename
+    logger.debug("Caller file name: %s", filename)
+    return filename
+
+
+def get_current_file_path() -> Optional[str]:
+    """returns the name of the file that this functions is called from
+
+    Returns:
+        Optional[str]: name of file
+    """
+    logger.debug("Getting current file path")
+    return get_caller_file_name()
+
+
+def get_current_file_name() -> Optional[str]:
+    logger.debug("Getting current file name")
+    if (filepath := get_caller_file_name()) is None: 
+        logger.debug("No file path available")
+        return None
+    filename = filepath.split('\\')[-1]
+    logger.debug("Current file name: %s", filename)
+    return filename
+
+
+def get_current_folder_path() -> Optional[str]:
+    logger.debug("Getting current folder path")
+    if (filepath := get_caller_file_name()) is None: 
+        logger.debug("No file path available")
+        return None
+    folder_path = "\\".join(filepath.split("\\")[:-1])
+    logger.debug("Current folder path: %s", folder_path)
+    return folder_path
+
+
+def get_current_folder_name() -> Optional[str]:
+    logger.debug("Getting current folder name")
+    if (filepath := get_caller_file_name()) is None: 
+        logger.debug("No file path available")
+        return None
+    folder_name = filepath.split("\\")[-2]
+    logger.debug("Current folder name: %s", folder_name)
+    return folder_name
+
+
+def get_current_directory() -> str:
+    """returns the name of the directory of main script"""
+    logger.debug("Getting current directory")
+    directory = os.path.dirname(os.path.abspath(get_caller_file_name()))  # type:ignore # noqa
+    logger.debug("Current directory: %s", directory)
+    return directory or ""
+
+
+__all__ = [
+    "get_current_file_path",
+    "get_current_file_name",
+    "get_current_folder_path",
+    "get_current_folder_name",
+    "get_caller_file_name",
+    'get_current_directory',
+]

danielutils/reflection/function/__init__.py

@@ -0,0 +1 @@
+from .function_reflections import *

danielutils/reflection/function/function_reflections.py

@@ -0,0 +1,152 @@
+import inspect
+import logging
+from typing import Optional, Callable
+from ..interpreter import get_python_version, get_prev_frame
+from ...logging_.utils import get_logger
+
+if get_python_version() < (3, 9):
+    from typing import Set as Set  # pylint: disable=ungrouped-imports
+else:
+    from builtins import set as Set
+
+logger = get_logger(__name__)
+
+
+def get_caller_name(steps_back: int) -> Optional[str]:
+    """returns the name caller of the function
+
+    Returns:
+        str: name of caller
+
+    USING THIS FUNCTION WHILE DEBUGGING WILL ADD ADDITIONAL FRAMES TO THE TRACEBACK
+    """
+    if not isinstance(steps_back, int):
+        logger.error("Invalid steps_back type: %s", type(steps_back))
+        raise TypeError("steps_back must be an int")
+    if steps_back < 0:
+        logger.error("Invalid steps_back value: %s", steps_back)
+        raise ValueError("steps_back must be a non-negative integer")
+    if (frame := get_prev_frame(2 + steps_back)) is None:
+        return None
+    caller_name = frame.f_code.co_name
+    return caller_name
+
+
+def get_prev_func(steps_back: int) -> Optional[Callable]:
+    """Returns the current function"""
+    if steps_back < 0:
+        logger.error("Invalid steps_back value: %s", steps_back)
+        raise ValueError("n_step must be a non-negative integer")
+    if (caller_frame := get_prev_frame(2 + steps_back)) is None:
+        return None
+    caller_name = caller_frame.f_code.co_name
+    if 'self' in caller_frame.f_locals:
+        return getattr(caller_frame.f_locals['self'], caller_name)
+    return caller_frame.f_globals.get(caller_name, None)
+
+
+def get_current_func() -> Optional[Callable]:
+    """returns the current func
+    Example:
+        >>> def foo():
+        >>>     return get_current_func()
+
+        >>> foo is foo()
+        True
+        >>> foo is foo()()()
+        True     
+    """
+    return get_prev_func(1)
+
+
+def get_caller() -> Optional[Callable]:
+    """returns the caller to the current function
+
+    Example:
+        >>> def foo():
+        >>>     print(get_caller())
+
+        >>> def bar():
+        >>>     foo()
+
+        >>> bar()
+        "bar"
+    """
+    return get_prev_func(2)
+
+
+def get_function_return_type(func: Callable, signature: Optional[inspect.Signature] = None) -> Optional[type]:
+    """returns the return type of a function
+
+    Args:
+        func (Callable): a function to inquire about
+
+    Returns:
+        Optional[type]: the return type of the function
+    """
+    if signature is None:
+        signature = inspect.signature(func)
+    if ("inspect._empty" in str(signature.return_annotation)) or (signature.return_annotation is None):
+        return type(None)
+    return signature.return_annotation
+
+
+def is_function_annotated_properly(func: Callable, ignore: Optional[set] = None, check_return: bool = True) -> bool:
+    """checks whether a function is annotated properly
+
+    Args:
+        func (Callable): the function to check
+        ignore (set, optional): arguments to ignore when validating.
+        when 'None' Defaults to {"self", "cls", "args", "kwargs"}.
+        check_return (bool, optional): whether to also check that the return value is annotated. Defaults to True
+    Raises:
+        ValueError: if any of the parameters is of the wrong type
+
+    Returns:
+        bool: result of validation
+    """
+    from ...functions.isoftype import isoftype
+    if not inspect.isfunction(func):
+        logger.error("Invalid function type: %s", type(func))
+        raise ValueError("param should be a function")
+
+    if ignore is None:
+        ignore = {"self", "cls", "args", "kwargs"}
+    if not isoftype(ignore, Set[str]):
+        logger.error("Invalid ignore type: %s", type(ignore))
+        raise ValueError("ignore must be a set of str")
+
+    # get the signature of the function
+    signature = inspect.signature(func)
+    for arg_name, arg_param in signature.parameters.items():
+        if arg_name not in ignore:
+            arg_type = arg_param.annotation
+            # check if an annotation is missing
+            if arg_type == inspect.Parameter.empty:
+                return False
+        # check if the argument has a default value
+        default_value = signature.parameters[arg_name].default
+        if default_value != inspect.Parameter.empty:
+            # allow everything to be set to None as default
+            if default_value is None:
+                continue
+            # if it does, check the type of the default value
+            if not isoftype(default_value, arg_type):
+                return False
+
+    return True
+
+
+def get_source_code(func: Callable):
+    return inspect.getsource(func)
+
+
+__all__ = [
+    "get_caller_name",
+    'get_prev_func',
+    "get_current_func",
+    'get_caller',
+    "get_function_return_type",
+    "is_function_annotated_properly",
+    "get_source_code"
+]

danielutils/reflection/info_classes/__init__.py

@@ -0,0 +1,6 @@
+from .argument_info import *
+from .class_info import *
+from .decorator_info import *
+from .file_info import *
+from .function_info import *
+from .import_info import *