danielutils 1.1.28__py3-none-any.whl

danielutils/reflection/info_classes/argument_info.py

@@ -0,0 +1,278 @@
+import re
+from dataclasses import dataclass
+from typing import Optional, List
+
+ARGUMENT_INFO_REGEX: re.Pattern = re.compile(
+    r"(?P<kwargs>\*\*\w[\w\d]*)|(?P<args>\*(?:\w[\w\d]*)?)|(?P<kwarg_only>\/)|(?P<pname>\w[\w\d]*)\[(?P<parameters>.+)\]|(?P<name>\w[\w\d]*)(?:(?:\s*:(?P<type>[^\=\n]+))?(?:\s*=(?P<default_value>[\s\S]+))?)?")
+
+
+class ArgumentInfo:
+    def __init__(
+            self,
+            name: Optional[str],
+            type: Optional[str],
+            default: Optional[str],
+            is_kwargs: bool,
+            is_args: bool,
+            is_kwargs_only: bool,
+            parameters: Optional[List]
+    ) -> None:
+        self._name = name
+        self._type = type
+        self._default = default
+        self._is_kwargs = is_kwargs
+        self._is_args = is_args
+        self._is_kwargs_only = is_kwargs_only
+        self._parameters = parameters
+
+    @property
+    def name(self) -> Optional[str]:
+        return self._name
+
+    @property
+    def type(self) -> Optional[str]:
+        return self._type
+
+    @property
+    def default(self) -> Optional[str]:
+        return self._default
+
+    @property
+    def is_kwargs(self) -> bool:
+        return self._is_kwargs
+
+    @property
+    def is_args(self) -> bool:
+        return self._is_args
+
+    @property
+    def is_kwargs_only(self) -> bool:
+        return self._is_kwargs_only
+
+    @property
+    def parameters(self) -> Optional[List]:
+        return self._parameters
+
+    @property
+    def is_parameterized(self) -> bool:
+        return self._parameters is not None and len(self._parameters) > 0
+
+    def __repr__(self) -> str:
+        res = f"{self.__class__.__name__}(name=\"{self.name}\""
+        if self.type is not None:
+            res += f", type={self.type}"
+        if self.default is not None:
+            res += f", default={self.default}"
+        if self.is_parameterized:
+            res += f", parameters={self.parameters}"
+        return res + ")"
+
+    def __str__(self) -> str:
+        return repr(self)
+
+    @staticmethod
+    def _parse_one(string: str) -> 'ArgumentInfo':
+        string = string.strip()
+
+        # Handle string literals (decorator context)
+        if string.startswith('"') or string.startswith("'"):
+            # Extract the string literal (handling escaped quotes)
+            quote_char = string[0]
+            # Find the matching closing quote
+            i = 1
+            while i < len(string):
+                if string[i] == quote_char and (i == 0 or string[i-1] != '\\'):
+                    # Found matching quote
+                    literal_value = string[:i+1]
+                    return ArgumentInfo(
+                        name=None,
+                        type=None,
+                        default=literal_value,
+                        is_kwargs=False,
+                        is_args=False,
+                        is_kwargs_only=False,
+                        parameters=None
+                    )
+                i += 1
+            # If no closing quote found, treat the whole string as the literal
+            return ArgumentInfo(
+                name=None,
+                type=None,
+                default=string,
+                is_kwargs=False,
+                is_args=False,
+                is_kwargs_only=False,
+                parameters=None
+            )
+
+        # Handle other literals (numbers, booleans, None, etc.) - check BEFORE regex
+        # In decorator context, these are always literals, not parameter definitions
+        if string:
+            # Check for numeric literal (starts with digit, possibly with decimal point or negative)
+            if string[0].isdigit() or (len(string) > 1 and string[0] == '-' and string[1].isdigit()):
+                return ArgumentInfo(
+                    name=None,
+                    type=None,
+                    default=string,
+                    is_kwargs=False,
+                    is_args=False,
+                    is_kwargs_only=False,
+                    parameters=None
+                )
+            # Check for boolean or None literals
+            if string in ('True', 'False', 'None'):
+                return ArgumentInfo(
+                    name=None,
+                    type=None,
+                    default=string,
+                    is_kwargs=False,
+                    is_args=False,
+                    is_kwargs_only=False,
+                    parameters=None
+                )
+            # Check for list/dict literals or function calls (starts with bracket, brace, or identifier followed by paren)
+            if string.startswith('[') or string.startswith('{') or string.startswith('('):
+                return ArgumentInfo(
+                    name=None,
+                    type=None,
+                    default=string,
+                    is_kwargs=False,
+                    is_args=False,
+                    is_kwargs_only=False,
+                    parameters=None
+                )
+            # Check for function call pattern (identifier followed by opening paren)
+            # This handles cases like "some_function(1, 2)"
+            if '(' in string and not string.startswith('='):
+                # Check if it looks like a function call (has identifier before paren)
+                parts = string.split('(', 1)
+                if len(parts) == 2 and parts[0].strip() and (parts[0].strip()[0].isalpha() or parts[0].strip()[0] == '_'):
+                    return ArgumentInfo(
+                        name=None,
+                        type=None,
+                        default=string,
+                        is_kwargs=False,
+                        is_args=False,
+                        is_kwargs_only=False,
+                        parameters=None
+                    )
+
+        # Try regex matching for normal argument patterns
+        m = ARGUMENT_INFO_REGEX.match(string)
+        if m is None:
+            raise ValueError(f"Invalid argument info string: {string}")
+
+        kwargs, args, kwarg_only, pname, parameters, name, type, default_value = m.groups()
+        type = None if type is None else type.strip()
+        default_value = None if default_value is None else default_value.strip()
+
+        return ArgumentInfo(
+            name=name or pname or (args.strip("*") if args else None) or (
+                kwargs.strip("*") if kwargs else None) or (kwarg_only if kwarg_only else None) or None,
+            type=type,
+            default=default_value,
+            is_kwargs=kwargs is not None,
+            is_args=args is not None,
+            is_kwargs_only=kwarg_only is not None,
+            parameters=[parameters]
+        )
+
+    @staticmethod
+    def _strip_comments(string: str) -> str:
+        """Strip comments from string while preserving string literals."""
+        result = []
+        in_string = False
+        string_char = None
+        i = 0
+        while i < len(string):
+            c = string[i]
+            # Track string literals
+            if c in {'"', "'"} and (i == 0 or string[i-1] != '\\'):
+                if not in_string:
+                    in_string = True
+                    string_char = c
+                elif c == string_char:
+                    in_string = False
+                    string_char = None
+                result.append(c)
+            # Handle comments (only when not in string)
+            elif not in_string and c == '#':
+                # Skip everything from # to end of line (or end of string)
+                # Keep the newline if present to preserve line structure
+                while i < len(string) and string[i] != '\n':
+                    i += 1
+                # Include the newline if we found one
+                if i < len(string) and string[i] == '\n':
+                    result.append('\n')
+                    i += 1
+                    continue
+                else:
+                    # End of string, break
+                    break
+            else:
+                result.append(c)
+            i += 1
+        return ''.join(result)
+
+    @staticmethod
+    def from_str(string: str) -> List['ArgumentInfo']:
+        if string is None:
+            return []
+        string = string.strip()
+        if not string:
+            return []
+        # Strip comments before processing
+        string = ArgumentInfo._strip_comments(string).strip()
+        indices = [-1]
+        stack: List[str] = []
+        in_string = False
+        string_char = None
+        for i, c in enumerate(string):
+            # Track string literals
+            if c in {'"', "'"} and (i == 0 or string[i-1] != '\\'):
+                if not in_string:
+                    in_string = True
+                    string_char = c
+                elif c == string_char:
+                    in_string = False
+                    string_char = None
+            # Track brackets, braces, and parentheses only when not in string
+            elif not in_string:
+                if c in {'[', ']', '{', '}', '(', ')'}:
+                    if c in {'[', '{', '('}:
+                        stack.append(c)
+                    else:
+                        # Match closing brackets/braces/parens with opening ones
+                        if stack:
+                            opening = stack[-1]
+                            if (c == ']' and opening == '[') or \
+                               (c == '}' and opening == '{') or \
+                               (c == ')' and opening == '('):
+                                stack.pop()
+                elif len(stack) == 0:
+                    if c == ",":
+                        indices.append(i)
+        indices.append(len(string))
+        res = []
+        for idx, (start, end) in enumerate(zip(indices[:-1], indices[1:])):
+            substr = string[start + 1:end].strip()
+            # Skip standalone * (keyword-only separator)
+            if substr == "*":
+                continue
+            # Skip empty strings (from comment-only lines)
+            if not substr:
+                continue
+            try:
+                res.append(ArgumentInfo._parse_one(substr))
+            except ValueError as e:
+                raise ValueError(
+                    f"Failed to parse argument {idx + 1}: {e}\n"
+                    f"Argument string: {repr(substr)}\n"
+                    f"Full arguments string: {repr(string)}"
+                ) from e
+        return res
+
+
+__all__ = [
+    "ArgumentInfo",
+]

danielutils/reflection/info_classes/class_info.py

@@ -0,0 +1,204 @@
+import logging
+import inspect
+import json
+import re
+from typing import List, Iterable, Type, TypeVar, Generic, get_origin
+from .function_info import FunctionInfo
+from .decorator_info import DecoratorInfo
+from .argument_info import ArgumentInfo
+
+from ...logging_.utils import get_logger
+
+logger = get_logger(__name__)
+
+T = TypeVar("T")
+
+
+class _A(Generic[T]):
+    ...
+
+
+_GenericAlias = type(_A[int])
+
+del T, _A
+
+
+class ClassInfo:
+    CLASS_DEFINITION_REGEX: re.Pattern = re.compile(
+        r"(?P<decorations>[\s\S]*)?(^)?class (?P<name>\w[\w\d]*)(?:\((?P<bases>.*)\))?:(?P<body>[\s\S]+)", re.MULTILINE)
+
+    # r"(?P<decorations>[\s\S]*)?^class (?P<name>\w[\w\d]*)(?:\((?P<bases>.*)\))?:(?P<body>[\s\S]+)"
+
+    def __init__(self, cls: Type) -> None:
+        logger.debug("Creating ClassInfo for: %s", cls)
+        if isinstance(cls, _GenericAlias):
+            logger.debug("Converting generic alias to origin type")
+            cls = get_origin(cls)  # type:ignore
+        if not inspect.isclass(cls):
+            error_msg = f"'{getattr(cls, '__name__', type(cls).__name__)}' is not a class"
+            logger.error("ClassInfo creation failed: %s", error_msg)
+            raise TypeError(error_msg)
+        self._cls = cls
+        self._src_code: str = ""
+        self._name: str = ""
+        self._bases: List[ArgumentInfo] = []
+        self._functions: List[FunctionInfo] = []
+        self._decorations: List[DecoratorInfo] = []
+        logger.debug("Parsing source code for class: %s", cls.__name__)
+        self._parse_src_code()
+        logger.info("ClassInfo created successfully for: %s", cls.__name__)
+
+    def _parse_src_code(self) -> None:
+        logger.debug("Parsing source code")
+        try:
+            self._src_code = inspect.getsource(self._cls)
+        except (OSError, TypeError) as e:
+            logger.warning(
+                "Source code not available for class: %s - %s", self._cls.__name__, e)
+            self._src_code = ""
+            # Fall back to runtime introspection
+            self._name = self._cls.__name__
+            self._bases = []
+            self._parse_body()
+            return
+
+        class_name = self._cls.__name__
+        class_pattern = re.compile(
+            rf"(?P<decorations>[\s\S]*?)(?:^|\n)\s*class {re.escape(class_name)}\b"
+            rf"(?:\((?P<bases>.*)\))?:(?P<body>[\s\S]+)",
+            re.MULTILINE,
+        )
+        m = class_pattern.search(self._src_code)
+        if m is None:
+            logger.warning(
+                "Failed to match class definition regex, falling back to runtime introspection")
+            # Fall back to runtime introspection
+            self._name = class_name
+            self._bases = []
+            self._parse_body()
+            return
+
+        decorators = m.group("decorations")
+        bases = m.group("bases")
+        name = class_name
+        logger.debug("Parsed class name: %s, bases: %s", name, bases)
+        self._name = name
+        try:
+            self._bases = ArgumentInfo.from_str(bases)
+        except ValueError as e:
+            raise ValueError(
+                f"Failed to parse base classes for class '{name}': {e}\n"
+                f"Bases string: {repr(bases)}"
+            ) from e
+        logger.debug("Parsed %s base classes", len(self._bases))
+        self._parse_body()
+
+        if decorators is not None:
+            logger.debug("Parsing %s decorators", len(
+                decorators.strip().splitlines()))
+            for substr in decorators.strip().splitlines():
+                try:
+                    self._decorations.append(
+                        DecoratorInfo.from_str(substr.strip()))
+                except ValueError as e:
+                    error_msg = (
+                        f"Failed to parse decorator for class '{name}': {e}\n"
+                        f"Decorator string: {repr(substr.strip())}"
+                    )
+                    logger.warning(error_msg)
+                    # Skip invalid decorators
+                    continue
+        logger.debug("Parsed %s decorators", len(self._decorations))
+
+    def _parse_body(self) -> None:
+        for attr in dir(self._cls):
+            obj = getattr(self._cls, attr, None)
+            if inspect.isbuiltin(obj):
+                continue
+            try:
+                if inspect.isroutine(obj):
+                    inspect.getsource(obj)
+                elif inspect.isdatadescriptor(obj):
+                    inspect.getsource(obj.fget)  # type:ignore
+                else:
+                    continue
+            except:
+                continue
+
+            try:
+                self._functions.append(FunctionInfo(
+                    obj, self._cls))  # type: ignore
+            except TypeError as e:
+                # Skip functions that can't be parsed (e.g., lambda, built-ins)
+                logger.debug("Skipping function '%s': %s", attr, e)
+                continue
+            except Exception as e:
+                raise Exception(
+                    f"Error parsing function '{attr}' of class '{self._name}': {e}", e) from e
+
+    def __str__(self) -> str:
+        body = json.dumps({
+            "name": self.name,
+            "bases": self.bases,
+            "decorations": self.decorations,
+            "static_methods": self.static_methods,
+            "class_methods": self.class_methods,
+            "instance_methods": self.instance_methods
+        }, default=str, indent=4)[1:-1]
+        return f"{self.__class__.__name__}({body})"
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}(name=\"{self.name}\")"
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def decorations(self) -> List[DecoratorInfo]:
+        return self._decorations
+
+    @property
+    def bases(self) -> List[ArgumentInfo]:
+        return self._bases
+
+    @property
+    def static_methods(self) -> Iterable[FunctionInfo]:
+        return sorted(filter(lambda f: f.is_static_method, self._functions), key=lambda f: f.name)
+
+    @property
+    def class_methods(self) -> Iterable[FunctionInfo]:
+        return sorted(filter(lambda f: f.is_class_method, self._functions), key=lambda f: f.name)
+
+    @property
+    def instance_methods(self) -> Iterable[FunctionInfo]:
+        return sorted(filter(lambda f: f.is_instance_method, self._functions), key=lambda f: f.name)
+
+    @property
+    def inherited_methods(self) -> Iterable[FunctionInfo]:
+        return sorted(filter(lambda f: f.is_inherited, self._functions), key=lambda f: f.name)
+
+    @property
+    def abstract_methods(self) -> Iterable[FunctionInfo]:
+        return sorted(filter(lambda f: f.is_abstract, self._functions), key=lambda f: f.name)
+
+    @property
+    def functions(self) -> List[FunctionInfo]:
+        return self._functions
+
+    @property
+    def properties(self):
+        pass
+
+    @property
+    def instance_properties(self):
+        pass
+
+    @property
+    def class_properties(self):
+        pass
+
+
+__all__ = [
+    "ClassInfo"
+]

danielutils/reflection/info_classes/decorator_info.py

@@ -0,0 +1,54 @@
+import re
+from dataclasses import dataclass, Field
+from typing import Optional, List
+
+from .argument_info import ArgumentInfo
+
+
+class DecoratorInfo:
+    DECORATOR_INFO_REGEX: re.Pattern = re.compile(
+        r"^@?(?P<name>\w[\w\d]*)(?:\((?P<arguments>.*)\))?$")
+
+    def __init__(self, name: str, arguments: List[ArgumentInfo]):
+        self._name = name
+        self._arguments = arguments
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def arguments(self) -> List[ArgumentInfo]:
+        return self._arguments
+
+    @staticmethod
+    def from_str(string: str) -> 'DecoratorInfo':
+        m = DecoratorInfo.DECORATOR_INFO_REGEX.match(string)
+        if m is None:
+            raise ValueError(f"Invalid decorator format: {repr(string)}")
+
+        name, arguments = m.groups()
+        if arguments:
+            try:
+                args = ArgumentInfo.from_str(arguments)
+            except ValueError as e:
+                raise ValueError(
+                    f"Failed to parse arguments for decorator '{name}': {e}\n"
+                    f"Arguments string: {repr(arguments)}"
+                ) from e
+        else:
+            args = []
+        return DecoratorInfo(name, args)
+
+    def __str__(self) -> str:
+        return repr(self)
+
+    def __repr__(self) -> str:
+        if self.arguments:
+            return f"{self.__class__.__name__}(name=\"{self.name}\", arguments={self.arguments})"
+        return f"{self.__class__.__name__}(name=\"{self.name}\")"
+
+
+__all__ = [
+    'DecoratorInfo',
+]