danielutils 1.1.2__tar.gz → 1.1.22__tar.gz

{danielutils-1.1.2/danielutils.egg-info → danielutils-1.1.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: danielutils
-Version: 1.1.2
+Version: 1.1.22
 Summary: A python utils library for things I find useful
 Author-email: danielnachumdev <danielnachumdev@gmail.com>
 License: MIT License
@@ -41,7 +41,7 @@ Dynamic: license-file
 [![gitleaks](https://github.com/danielnachumdev/danielutils/actions/workflows/gitleaks.yml/badge.svg)](https://github.com/danielnachumdev/danielutils/actions/workflows/gitleaks.yml)
 [![CodeQL](https://github.com/danielnachumdev/danielutils/actions/workflows/github-code-scanning/codeql/badge.svg)](https://github.com/danielnachumdev/danielutils/actions/workflows/github-code-scanning/codeql)
 
-# danielutils v1.0.51
+# danielutils v1.1.21
 
 A comprehensive Python utilities library designed to enhance your development workflow with powerful tools for type safety, async programming, database operations, and much more.
 

{danielutils-1.1.2 → danielutils-1.1.22}/README.md

@@ -4,7 +4,7 @@
 [![gitleaks](https://github.com/danielnachumdev/danielutils/actions/workflows/gitleaks.yml/badge.svg)](https://github.com/danielnachumdev/danielutils/actions/workflows/gitleaks.yml)
 [![CodeQL](https://github.com/danielnachumdev/danielutils/actions/workflows/github-code-scanning/codeql/badge.svg)](https://github.com/danielnachumdev/danielutils/actions/workflows/github-code-scanning/codeql)
 
-# danielutils v1.0.51
+# danielutils v1.1.21
 
 A comprehensive Python utilities library designed to enhance your development workflow with powerful tools for type safety, async programming, database operations, and much more.
 

danielutils-1.1.22/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-1.1.2 → danielutils-1.1.22}/danielutils/reflection/info_classes/class_info.py

@@ -75,7 +75,13 @@ class ClassInfo:
         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)
+        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()
 
@@ -87,8 +93,11 @@ class ClassInfo:
                     self._decorations.append(
                         DecoratorInfo.from_str(substr.strip()))
                 except ValueError as e:
-                    logger.warning(
-                        "Failed to parse decorator '%s': %s", substr.strip(), 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))

{danielutils-1.1.2 → danielutils-1.1.22}/danielutils/reflection/info_classes/decorator_info.py

@@ -25,10 +25,19 @@ class DecoratorInfo:
     def from_str(string: str) -> 'DecoratorInfo':
         m = DecoratorInfo.DECORATOR_INFO_REGEX.match(string)
         if m is None:
-            raise ValueError()
+            raise ValueError(f"Invalid decorator format: {repr(string)}")
 
         name, arguments = m.groups()
-        args = ArgumentInfo.from_str(arguments)
+        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:

{danielutils-1.1.2 → danielutils-1.1.22}/danielutils/reflection/info_classes/function_info.py

@@ -166,13 +166,26 @@ class FunctionInfo:
         decorators, async_, name, arguments, return_type, body = m.groups()
         if decorators is not None:
             for substr in decorators.strip().splitlines():
-                self._decorators.append(DecoratorInfo.from_str(substr.strip()))
+                try:
+                    self._decorators.append(
+                        DecoratorInfo.from_str(substr.strip()))
+                except ValueError as e:
+                    raise ValueError(
+                        f"Failed to parse decorator for function '{name}': {e}\n"
+                        f"Decorator string: {repr(substr.strip())}"
+                    ) from e
 
         self._is_async = async_ is not None
 
         self._name = name
         if arguments is not None:
-            all_args = ArgumentInfo.from_str(arguments)
+            try:
+                all_args = ArgumentInfo.from_str(arguments)
+            except ValueError as e:
+                raise ValueError(
+                    f"Failed to parse arguments for function '{name}': {e}\n"
+                    f"Arguments string: {repr(arguments)}"
+                ) from e
             # Filter out separator arguments (/, *) - they are syntax markers, not actual arguments
             self._arguments = [arg for arg in all_args if not (
                 arg.is_kwargs_only and arg.name == "/") and not (arg.is_args and arg.name is None)]

danielutils-1.1.22/danielutils/tools/__init__.py

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

danielutils-1.1.22/danielutils/tools/unittest_test_runner/__init__.py

@@ -0,0 +1,9 @@
+"""
+Test Runner Module
+
+A comprehensive test runner with hierarchical execution and smart skipping capabilities.
+"""
+
+from .core import *
+from .models import *
+from .cli import main

danielutils-1.1.22/danielutils/tools/unittest_test_runner/cli.py

@@ -0,0 +1,70 @@
+"""
+Command-line interface for the test runner using Google Fire.
+"""
+
+import logging
+import fire
+from typing import Optional, Literal
+from .core import TestRunner, VerboseLevel
+
+logger = logging.getLogger(__name__)
+
+
+def run_tests(python_path: Optional[str] = None,
+              results_file: str = "test_results.json",
+              skip_threshold: int = 24,
+              force: bool = False,
+              test_name: Optional[str] = None,
+              target: Optional[str] = None,
+              verbose: VerboseLevel = "class",
+              show_function_results: bool = False):
+    """
+    Run tests with smart skipping and detailed reporting.
+    
+    Args:
+        python_path: Path to Python executable to use for running tests (defaults to current Python)
+        results_file: JSON file to store/load results (default: test_results.json)
+        skip_threshold: Hours after which to re-run previously passing tests (default: 24)
+        force: Force run all tests, ignoring previous results
+        test_name: Run only a specific test module (e.g., tests.abstractions.db.test_in_memory_database)
+        target: unittest dot-notation target (e.g., tests.module.class.function)
+        verbose: Verbose level - module/file/class/function (default: class)
+        show_function_results: Show pass/fail status for each individual test function within modules
+    """
+    logger.info("Starting test run with parameters: python_path=%s, results_file=%s, skip_threshold=%d, force=%s, target=%s, verbose=%s", 
+                python_path, results_file, skip_threshold, force, target, verbose)
+    
+    runner = TestRunner(
+        python_path=python_path,
+        results_file=results_file,
+        skip_threshold_hours=skip_threshold,
+        force_run=force,
+        test_name=test_name,
+        target=target,
+        verbose=verbose,
+        show_function_results=show_function_results
+    )
+
+    try:
+        logger.info("Executing all tests")
+        runner.run_all_tests()
+        logger.info("Saving results to JSON file: %s", results_file)
+        runner.save_results_json()
+        logger.info("Test run completed successfully")
+    except KeyboardInterrupt:
+        logger.warning("Test run interrupted by user")
+        print("\nTest run interrupted by user.")
+    except Exception as e:
+        logger.error("Error during test run: %s", e)
+        print(f"Error during test run: {e}")
+        raise
+
+
+def main():
+    """Main entry point for the CLI."""
+    logger.info("Starting CLI main entry point")
+    fire.Fire(run_tests)
+
+
+if __name__ == "__main__":
+    main()

danielutils-1.1.22/danielutils/tools/unittest_test_runner/core/__init__.py

@@ -0,0 +1,17 @@
+"""
+Core test runner modules.
+
+This package contains the core functionality split by responsibility:
+- discovery: Test discovery and structure analysis
+- execution: Test execution hierarchy
+- parser: Output parsing and result processing
+- runner: Main TestRunner orchestration
+- types: Type definitions and data structures
+"""
+
+from .runner import TestRunner
+
+# Define VerboseLevel here since it's a simple type alias
+from typing import Literal
+VerboseLevel = Literal["module", "file", "class", "function"]
+