danielutils 1.1.28__py3-none-any.whl

danielutils/reflection/info_classes/import_info.py

@@ -0,0 +1,207 @@
+import ast
+from enum import Enum
+from typing import List, Union, Optional
+
+
+class ImportType(Enum):
+    """Enumeration of import types."""
+    GLOBAL_PACKAGE = "global_package"           # "import x"
+    GLOBAL_FROM_PACKAGE = "global_from_package"  # "from x import y"
+    LOCAL_PACKAGE = "local_package"             # "import .x" or "import ..x"
+    # "from .x import y" or "from ..x import y"
+    LOCAL_FROM_PACKAGE = "local_from_package"
+
+
+class ImportInfo:
+    """
+    A class that encapsulates information about a single import statement.
+
+    This class provides detailed information about imports including:
+    - The type of import (global vs local, package vs from_package)
+    - Whether the import is absolute or relative
+    - Module names and imported object names
+    - Aliases used in the import
+    """
+
+    def __init__(self,
+                 import_type: ImportType,
+                 is_absolute: bool,
+                 module_name: str,
+                 imported_object: Optional[str] = None,
+                 alias: Optional[str] = None,
+                 relative_level: int = 0) -> None:
+        """
+        Initialize ImportInfo.
+
+        :param import_type: The type of import (from ImportType enum)
+        :param is_absolute: Whether the import is absolute (True) or relative (False)
+        :param module_name: The name of the module being imported from
+        :param imported_object: The name of the specific object being imported (for from imports)
+        :param alias: The alias used for the import (if any)
+        :param relative_level: The number of dots for relative imports (0 for absolute)
+        """
+        self._import_type = import_type
+        self._is_absolute = is_absolute
+        self._module_name = module_name
+        self._imported_object = imported_object
+        self._alias = alias
+        self._relative_level = relative_level
+
+    @property
+    def import_type(self) -> ImportType:
+        """Returns the type of import."""
+        return self._import_type
+
+    @property
+    def is_absolute(self) -> bool:
+        """Returns True if the import is absolute, False if relative."""
+        return self._is_absolute
+
+    @property
+    def is_relative(self) -> bool:
+        """Returns True if the import is relative, False if absolute."""
+        return not self._is_absolute
+
+    @property
+    def module_name(self) -> str:
+        """Returns the name of the module being imported from."""
+        return self._module_name
+
+    @property
+    def imported_object(self) -> Optional[str]:
+        """Returns the name of the imported object (for from imports)."""
+        return self._imported_object
+
+    @property
+    def alias(self) -> Optional[str]:
+        """Returns the alias used for the import (if any)."""
+        return self._alias
+
+    @property
+    def relative_level(self) -> int:
+        """Returns the number of dots for relative imports (0 for absolute)."""
+        return self._relative_level
+
+    @property
+    def effective_name(self) -> str:
+        """Returns the effective name used in the code (alias if provided, otherwise imported_object or module_name)."""
+        if self.alias:
+            return self.alias
+        elif self.imported_object:
+            return self.imported_object
+        else:
+            return self.module_name.split('.')[-1]
+
+    def __str__(self) -> str:
+        return (f"ImportInfo(type={self.import_type.value}, "
+                f"absolute={self.is_absolute}, "
+                f"module='{self.module_name}', "
+                f"object={self.imported_object}, "
+                f"alias={self.alias})")
+
+    def __repr__(self) -> str:
+        return self.__str__()
+
+    def to_dict(self) -> dict:
+        """Returns a dictionary representation of the import information."""
+        return {
+            "import_type": self.import_type.value,
+            "is_absolute": self.is_absolute,
+            "module_name": self.module_name,
+            "imported_object": self.imported_object,
+            "alias": self.alias,
+            "relative_level": self.relative_level,
+            "effective_name": self.effective_name
+        }
+
+    @classmethod
+    def from_ast(cls, node: Union[ast.Import, ast.ImportFrom]) -> List["ImportInfo"]:
+        """
+        Create ImportInfo instances from AST nodes.
+
+        :param node: An ast.Import or ast.ImportFrom node
+        :return: A list of ImportInfo objects
+        """
+        imports = []
+
+        if isinstance(node, ast.Import):
+            # Handle "import x" statements
+            for alias in node.names:
+                module_name = alias.name
+                is_absolute = not module_name.startswith('.')
+                relative_level = 0
+
+                if not is_absolute:
+                    # Count leading dots for relative imports
+                    relative_level = len(module_name) - \
+                        len(module_name.lstrip('.'))
+                    module_name = module_name[relative_level:]
+
+                import_type = ImportType.LOCAL_PACKAGE if not is_absolute else ImportType.GLOBAL_PACKAGE
+
+                imports.append(cls(
+                    import_type=import_type,
+                    is_absolute=is_absolute,
+                    module_name=module_name,
+                    imported_object=None,
+                    alias=alias.asname,
+                    relative_level=relative_level
+                ))
+
+        elif isinstance(node, ast.ImportFrom):
+            # Handle "from x import y" statements
+            module_name = node.module if node.module is not None else ""
+            is_absolute = True  # Default to absolute
+            relative_level = 0
+
+            # Check if this is a relative import by looking at the level attribute
+            if hasattr(node, 'level') and node.level > 0:
+                is_absolute = False
+                relative_level = node.level
+            elif module_name.startswith('.'):
+                # Fallback: check if module name starts with dots
+                is_absolute = False
+                relative_level = len(module_name) - \
+                    len(module_name.lstrip('.'))
+                module_name = module_name[relative_level:]
+
+            import_type = ImportType.LOCAL_FROM_PACKAGE if not is_absolute else ImportType.GLOBAL_FROM_PACKAGE
+
+            for alias in node.names:
+                imported_object = alias.name
+                imports.append(cls(
+                    import_type=import_type,
+                    is_absolute=is_absolute,
+                    module_name=module_name,
+                    imported_object=imported_object,
+                    alias=alias.asname,
+                    relative_level=relative_level
+                ))
+
+        return imports
+
+    @classmethod
+    def from_string(cls, import_string: str) -> List["ImportInfo"]:
+        """
+        Create ImportInfo instances from a string representation of import statements.
+
+        :param import_string: A string containing import statements
+        :return: A list of ImportInfo objects
+        """
+        try:
+            tree = ast.parse(import_string)
+            imports = []
+
+            for node in ast.walk(tree):
+                if isinstance(node, (ast.Import, ast.ImportFrom)):
+                    imports.extend(cls.from_ast(node))
+
+            return imports
+        except SyntaxError:
+            raise ValueError(f"Invalid import string: {import_string}")
+
+
+__all__ = [
+    "ImportInfo",
+    "ImportType"
+]

danielutils/reflection/interpreter/__init__.py

@@ -0,0 +1,9 @@
+from .packages import *
+from .python_version import *
+from .tracer import *
+from .os_ import *
+from .callstack import *
+from .get_traceback import *
+from .signals import *
+from .interpreter import *
+from .is_debugging import *

danielutils/reflection/interpreter/callstack.py

@@ -0,0 +1,57 @@
+import logging
+import inspect
+from typing import Optional
+from types import FrameType
+from ...logging_.utils import get_logger
+
+logger = get_logger(__name__)
+
+
+def _get_prev_frame_from(frame: Optional[FrameType]) -> Optional[FrameType]:
+    """Get the previous frame (caller's frame) in the call stack."""
+    return frame.f_back if frame is not None else None
+
+
+def get_current_frame() -> Optional[FrameType]:
+    logger.debug("Getting current frame")
+    frame = _get_prev_frame_from(inspect.currentframe())
+    logger.debug("Current frame: %s", frame)
+    return frame
+
+
+def get_prev_frame(n_steps: int = 1) -> Optional[FrameType]:
+    logger.debug("Getting previous frame with %s steps", n_steps)
+    if (f := get_current_frame()) is None:
+        logger.debug("No current frame available")
+        return None
+    i = 0
+    while i < n_steps:
+        if (f := f.f_back) is None:
+            logger.debug("Reached end of call stack at step %s", i)
+            return None
+        i += 1
+    logger.debug("Found previous frame after %s steps", n_steps)
+    return f
+
+
+def get_prev_line_of_code(n_steps: int = 1) -> Optional[str]:
+    logger.debug("Getting previous line of code with %s steps", n_steps)
+    frame = get_prev_frame(n_steps + 1)
+    if frame is None:
+        logger.debug("No frame found for line of code")
+        return None
+    file = frame.f_back.f_code.co_filename  # type:ignore
+    line_number = frame.f_back.f_lineno - 1  # type:ignore
+    logger.debug("Reading line %s from file: %s", line_number, file)
+    with open(file, "r", encoding="utf-8") as f:
+        lines = f.readlines()
+    line = lines[line_number]
+    logger.debug("Previous line of code: %s", line.strip())
+    return line
+
+
+__all__ = [
+    "get_current_frame",
+    "get_prev_frame",
+    "get_prev_line_of_code"
+]

danielutils/reflection/interpreter/get_traceback.py

@@ -0,0 +1,27 @@
+import traceback
+from .python_version import get_python_version
+
+if get_python_version() < (3, 9):
+    from typing import List as List
+else:
+    from builtins import list as List
+
+from .is_debugging import is_debugging
+
+
+def get_traceback() -> List[str]:
+    """returns the traceback of the stack until current frame
+
+    Returns:
+        list[str]: list of frames as strings
+    """
+    s = slice(8, -2)
+    if not is_debugging():
+        # TODO: fix
+        s = s
+    return traceback.format_stack()[8:-2]
+
+
+__all__ = [
+    "get_traceback"
+]

danielutils/reflection/interpreter/interpreter.py

@@ -0,0 +1,41 @@
+import os
+import sys
+from typing import Any
+
+
+class Interpreter:
+    def get_version(self):
+        pass
+
+    def __init__(self, executable_path: str) -> None:
+        self._executable_path = executable_path
+
+    def _execute(self, command: str) -> None:
+        os.system(command)
+
+    def run_module(self, module_name: str, *args, **kwargs) -> None:
+        jargs = " ".join(args)
+        jkwargs = " ".join([f"{k}={v}" for k, v in kwargs.items()])
+        self._execute(f'{self._executable_path} -m {module_name} {jargs} {jkwargs}')
+
+    def execute_file(self, file_name: str, *args, **kwargs) -> None:
+        jargs = " ".join(args)
+        jkwargs = " ".join([f"{k}={v}" for k, v in kwargs.items()])
+        self._execute(f'{self._executable_path} {file_name} {jargs} {jkwargs}')
+
+    def execute_package(self, package_name: str, *args, **kwargs) -> None:
+        self.execute_file(package_name, *args, **kwargs)
+
+    def evaluate(self, expr: str) -> Any:
+        return self._execute(f"{self._executable_path} -c {expr}")
+
+
+class CurrentInterpreter(Interpreter):
+    def __init__(self) -> None:
+        super().__init__(sys.executable)
+
+
+__all__ = [
+    "Interpreter",
+    "CurrentInterpreter",
+]

danielutils/reflection/interpreter/is_debugging.py

@@ -0,0 +1,13 @@
+import sys
+
+
+def is_debugging() -> bool:
+    # TODO: fix
+    print("function 'is_debugging' might not work properly")
+    attr = getattr(sys, 'gettrace', None)
+    return bool(attr)
+
+
+__all__ = [
+    "is_debugging"
+]

danielutils/reflection/interpreter/os_.py

@@ -0,0 +1,33 @@
+import sys
+from enum import Enum
+
+
+class OSType(Enum):
+    """enum result for possible results of get_os()
+    """
+    LINUX = "Linux"
+    WINDOWS = "Windows"
+    OSX = "OS X"
+    UNKNOWN = "Unknown"
+
+
+def get_os() -> OSType:
+    """returns the type of operation system running this code
+
+    Returns:
+        OSType: enum result
+    """
+    p = sys.platform
+    if p in {"linux", "linux2"}:
+        return OSType.LINUX
+    if p == "darwin":
+        return OSType.OSX
+    if p == "win32":
+        return OSType.WINDOWS
+    return OSType.UNKNOWN
+
+
+__all__ = [
+    "OSType",
+    "get_os",
+]

danielutils/reflection/interpreter/packages.py

@@ -0,0 +1,33 @@
+# from typing import Optional
+# from ...system import cm
+# from ...decorators import memo
+#
+# @memo
+# def get_currently_installed_packages() -> list[tuple[str, str]]:
+#     ret, out, err = cm("pip", "list")
+#     text = out.decode("utf-8")
+#     res = []
+#     for line in text.splitlines()[2:]:
+#         splits = line.split(" ")
+#         dep = splits[0]
+#         ver = splits[-1]
+#         res.append((dep, ver))
+#     return res
+#
+#
+# def is_package_installed(name: str, *, min_version: Optional[str] = None, max_version: Optional[str] = None) -> bool:
+#     for dep, ver in get_currently_installed_packages():
+#         if dep == name:
+#             res = True
+#             if min_version is not None:
+#                 res = res and ver >= min_version
+#             if max_version is not None:
+#                 res = res and ver <= max_version
+#             return res
+#     return False
+#
+#
+# __all__ = [
+#     "get_currently_installed_packages",
+#     "is_package_installed"
+# ]

danielutils/reflection/interpreter/python_version.py

@@ -0,0 +1,33 @@
+import logging
+import platform
+from ...logging_.utils import get_logger
+
+logger = get_logger(__name__)
+
+
+def _get_python_version_untyped() -> tuple:
+    values = (int(v) for v in platform.python_version().split("."))
+    version = tuple(values)  # type:ignore
+    return version
+
+
+if _get_python_version_untyped() < (3, 9):
+    from typing import Tuple as Tuple
+else:
+    from builtins import tuple as Tuple  # type:ignore
+
+
+def get_python_version() -> Tuple[int, int, int]:
+    """return the version of python that is currently running this code
+
+    Returns:
+        tuple[int, int, int]: version
+    """
+    version = _get_python_version_untyped()
+    logger.info("Python version: %s", version)
+    return version  # type:ignore
+
+
+__all__ = [
+    "get_python_version"
+]

danielutils/reflection/interpreter/signals.py

@@ -0,0 +1,18 @@
+from typing import Callable, Optional
+from types import FrameType
+import signal
+
+
+def register_signal_handler(signal_number: int, handler: Callable[[int, Optional[FrameType]], None]):
+    """register a signal handler for specified signal
+
+    Args:
+        signal_number (int): signal number to handle
+        handler (Callable[[int, FrameType], None]): the handler function
+    """
+    signal.signal(signal_number, handler)
+
+
+__all__ = [
+    "register_signal_handler"
+]

danielutils/reflection/interpreter/tracer.py

@@ -0,0 +1,175 @@
+import sys
+from abc import ABC, abstractmethod
+from enum import Enum
+from types import FrameType
+from typing import Any, Callable, Optional, Set as Set, Dict as Dict
+from .python_version import get_python_version
+
+if get_python_version() >= (3, 9):
+    from builtins import set as Set, dict as Dict
+
+
+# from danielutils import singleton
+# @singleton
+class Tracer(ABC):
+    """
+    A class to trace (during runtime) the flow of the currently executing code
+    """
+    _INSTANCE = None
+
+    class EventType(Enum):
+        """
+        An enum class to represent all the types of possible events
+        """
+        CALL = "call"
+        C_CALL = "c_call"
+        RETURN = "return"
+        C_RETURN = "c_return"
+
+        @staticmethod
+        def from_value(value: str):
+            """
+            Converts the given value to a Tracer.EventType instance
+            """
+            if value not in Tracer.EventType._value2member_map_:
+                raise KeyError("Unknown value")
+            return Tracer.EventType._value2member_map_[value]
+
+    def __init__(
+            self,
+            *,
+            skip_call: bool = False,
+            skip_return: bool = False,
+            skip_c_call: bool = True,
+            skip_c_return: bool = True,
+            functions: bool = True,
+            classes: bool = True,
+            instance_methods: bool = True,
+            static_methods: bool = True,
+            class_methods: bool = True,
+            exclude: Optional[Set[str]] = None
+    ) -> None:
+
+        self._call_dict: Dict[Tracer.EventType, Callable] = {
+            Tracer.EventType.CALL: self.on_call,
+            Tracer.EventType.C_CALL: self.on_call_c,
+            Tracer.EventType.RETURN: self.on_return,
+            Tracer.EventType.C_RETURN: self.on_return_c,
+        }
+        self._skip_call = skip_call
+        self._skip_return = skip_return
+        self._skip_c_call = skip_c_call
+        self._skip_c_return = skip_c_return
+        self._functions = functions
+        self._classes = classes
+        self._instance_methods = instance_methods
+        self._static_methods = static_methods
+        self._class_methods = class_methods
+        self._exclude = exclude if exclude is not None else set()
+        from ...data_structures import Stack
+        self._exclude_stack: Stack[str] = Stack()
+
+    def _handler(self, stack_frame: FrameType, event_type: str, return_value: Optional[Any]):
+        et = Tracer.EventType.from_value(event_type)
+        if not self._should_skip(et, stack_frame):
+            values = self.parse_event(stack_frame, et, return_value)
+            self._call_dict[et](*values)
+        return self._handler
+
+    def _should_skip(self, et: 'Tracer.EventType', frame: FrameType) -> bool:
+        func_name = frame.f_code.co_qualname
+
+        if not self._exclude_stack.is_empty():
+            if et in {Tracer.EventType.CALL, Tracer.EventType.C_CALL}:
+                self._exclude_stack.push(func_name)
+            else:
+                self._exclude_stack.pop()
+            return True
+        if func_name in self._exclude:
+            self._exclude_stack.push(func_name)
+            return True
+
+        if et == Tracer.EventType.CALL and self._skip_call or \
+                et == Tracer.EventType.RETURN and self._skip_return or \
+                et == Tracer.EventType.C_CALL and self._skip_c_call or \
+                et == Tracer.EventType.C_RETURN and self._skip_c_return:
+            return True
+
+        # TODO add more cases
+        return False
+
+    def __enter__(self):
+        if Tracer._INSTANCE is not None:
+            raise RuntimeError("Can only have one active Tracer object at a time")
+        Tracer._INSTANCE = self
+        self.start_tracing()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        Tracer._INSTANCE = None
+        self.stop_tracing()
+
+    def start_tracing(self) -> None:
+        sys.setprofile(self._handler)
+
+    def stop_tracing(self) -> None:
+        sys.setprofile(None)
+
+    @abstractmethod
+    def parse_event(self, frame: FrameType, et: EventType, return_value: Optional[Any]) -> tuple:
+        pass
+
+    @abstractmethod
+    def on_call(self, *args, **kwargs) -> None:
+        """
+        A Handler for when a function is called
+        """
+
+    @abstractmethod
+    def on_call_c(self, *args, **kwargs) -> None:
+        """
+        A Handler for when an underlying C function is called
+        """
+
+    @abstractmethod
+    def on_return(self, *args, **kwargs) -> None:
+        """
+        A Handler for when a function returns
+        """
+
+    @abstractmethod
+    def on_return_c(self, *args, **kwargs) -> None:
+        """
+        A Handler for when an underlying C function returns
+        """
+
+
+class ConsoleTracer(Tracer):
+    # def __init__(self, *args, **kwargs) -> None:
+    #     super().__init__(*args, **kwargs)
+
+    def parse_event(self, frame: FrameType, event_type: Tracer.EventType, return_value: Optional[Any]) -> tuple:
+        func_name: str = frame.f_code.co_qualname
+        base: tuple = event_type, func_name
+        final: tuple = base
+        if return_value is not None:
+            final = *base, return_value
+        return final
+
+    def on_call(self, *args, **kwargs) -> None:
+        print(*args, **kwargs)
+
+    def on_call_c(self, *args, **kwargs) -> None:
+        print(*args, **kwargs)
+
+    def on_return(self, *args, **kwargs) -> None:
+        print(*args, **kwargs)
+
+    def on_return_c(self, *args, **kwargs) -> None:
+        print(*args, **kwargs)
+
+
+__all__ = [
+    "Tracer",
+    "ConsoleTracer"
+]

danielutils/reflection/module/__init__.py

@@ -0,0 +1,3 @@
+from .module_reflections import *
+from .package_reflection import *
+from .lazy_module import *