PyPI - danielutils - Versions diffs - 1.1.1__tar.gz → 1.1.2__tar.gz - Mend

danielutils 1.1.1tar.gz → 1.1.2tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (284) hide show

{danielutils-1.1.1/danielutils.egg-info → danielutils-1.1.2}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: danielutils
-Version: 1.1.1
+Version: 1.1.2
 Summary: A python utils library for things I find useful
 Author-email: danielnachumdev <danielnachumdev@gmail.com>
 License: MIT License

{danielutils-1.1.1 → danielutils-1.1.2}/danielutils/reflection/__init__.py RENAMED Viewed

@@ -2,5 +2,4 @@ from .interpreter import *  # this has to be first, the order matters!
 from .file import *
 from .function import *
 from .info_classes import *
-from .class_ import *
 from .module import *

{danielutils-1.1.1 → danielutils-1.1.2}/danielutils/reflection/info_classes/argument_info.py RENAMED Viewed

@@ -77,9 +77,10 @@ class ArgumentInfo:
         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.strip("/") if kwarg_only else None) or None,
+                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,
@@ -111,6 +112,9 @@ class ArgumentInfo:
         res = []
         for start, end in zip(indices[:-1], indices[1:]):
             substr = string[start + 1:end].strip()
+            # Skip standalone * (keyword-only separator)
+            if substr == "*":
+                continue
             res.append(ArgumentInfo._parse_one(substr))
         return res

{danielutils-1.1.1 → danielutils-1.1.2}/danielutils/reflection/info_classes/class_info.py RENAMED Viewed

@@ -1,159 +1,187 @@
-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 ...functions import isoftype
-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 isoftype(cls, _GenericAlias):  # type:ignore
-            logger.debug("Converting generic alias to origin type")
-            cls = get_origin(cls)  # type:ignore
-        if not inspect.isclass(cls):
-            error_msg = f"'{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")
-        self._src_code = inspect.getsource(self._cls)
-        m = ClassInfo.CLASS_DEFINITION_REGEX.match(self._src_code)
-        if m is None:
-            logger.error("Failed to match class definition regex")
-            raise SyntaxError()
-        decorators, name, bases, _ = m.groupdict().values()
-        logger.debug("Parsed class name: %s, bases: %s", name, bases)
-        self._name = name
-        self._bases = ArgumentInfo.from_str(bases)
-        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():
-                self._decorations.append(
-                    DecoratorInfo.from_str(substr.strip()))
-        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 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"
-]
+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
+        m = ClassInfo.CLASS_DEFINITION_REGEX.match(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 = self._cls.__name__
+            self._bases = []
+            self._parse_body()
+            return
+        decorators, name, bases, _ = m.groupdict().values()
+        logger.debug("Parsed class name: %s, bases: %s", name, bases)
+        self._name = name
+        self._bases = ArgumentInfo.from_str(bases)
+        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:
+                    logger.warning(
+                        "Failed to parse decorator '%s': %s", substr.strip(), e)
+                    # 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-1.1.1 → danielutils-1.1.2}/danielutils/reflection/info_classes/decorator_info.py RENAMED Viewed

@@ -7,7 +7,7 @@ from .argument_info import ArgumentInfo
 class DecoratorInfo:
     DECORATOR_INFO_REGEX: re.Pattern = re.compile(
-        r"^@?(?P<name>\w[\w\d]*)(?:\((?P<arguments>.*)\))?")
+        r"^@?(?P<name>\w[\w\d]*)(?:\((?P<arguments>.*)\))?$")
     def __init__(self, name: str, arguments: List[ArgumentInfo]):
         self._name = name

danielutils 1.1.1__tar.gz → 1.1.2__tar.gz

danielutils 1.1.1tar.gz → 1.1.2tar.gz