danielutils 1.1.25__tar.gz → 1.1.26__tar.gz

{danielutils-1.1.25/danielutils.egg-info → danielutils-1.1.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: danielutils
-Version: 1.1.25
+Version: 1.1.26
 Summary: A comprehensive Python utilities library providing type-safe collections, async programming tools, database abstractions, retry executors, data structures, and developer productivity enhancements to streamline Python development workflows
 Author-email: danielnachumdev <danielnachumdev@gmail.com>
 License: MIT License

{danielutils-1.1.25 → danielutils-1.1.26}/danielutils/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "1.1.25"
+__version__ = "1.1.26"
 """danielutils is a convenience library of functions decorators
     data-structures and more that make my development workflow faster
 """

{danielutils-1.1.25 → danielutils-1.1.26}/danielutils/abstractions/db/database_definitions.py

@@ -1,8 +1,6 @@
 import json
 from typing import Dict, Any, List, Optional, Literal, Union, Type
 from enum import Enum
-from datetime import datetime, date, time
-from uuid import UUID
 
 try:
     from pydantic import BaseModel, Field, ConfigDict
@@ -39,23 +37,16 @@ class ColumnType(str, Enum):
 class BaseDBModel(BaseModel):
     """Base model with JSON serialization support"""
     model_config = ConfigDict(
-        json_encoders={
-            datetime: lambda v: v.isoformat(),
-            date: lambda v: v.isoformat(),
-            time: lambda v: v.isoformat(),
-            UUID: lambda v: str(v),
-            Enum: lambda v: v.value
-        },
         arbitrary_types_allowed=True
     )
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert model to dictionary"""
-        return self.model_dump()
+        return self.model_dump(mode="json")
 
     def to_json(self) -> str:
         """Convert model to JSON string"""
-        return json.dumps(self.to_dict())
+        return self.model_dump_json()
 
     @classmethod
     def from_json(cls, json_str: str) -> 'BaseDBModel':

{danielutils-1.1.25 → danielutils-1.1.26}/danielutils/abstractions/db/database_models.py

@@ -1,8 +1,6 @@
 from typing import Dict, Any, List, Optional, Literal, Union
 from enum import Enum
 from pydantic import BaseModel, Field, ConfigDict
-from datetime import datetime, date, time
-from uuid import UUID
 import json
 
 
@@ -33,23 +31,16 @@ class ColumnType(str, Enum):
 class BaseDBModel(BaseModel):
     """Base model with JSON serialization support"""
     model_config = ConfigDict(
-        json_encoders={
-            datetime: lambda v: v.isoformat(),
-            date: lambda v: v.isoformat(),
-            time: lambda v: v.isoformat(),
-            UUID: lambda v: str(v),
-            Enum: lambda v: v.value
-        },
         arbitrary_types_allowed=True
     )
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert model to dictionary"""
-        return self.model_dump()
+        return self.model_dump(mode="json")
 
     def to_json(self) -> str:
         """Convert model to JSON string"""
-        return json.dumps(self.to_dict())
+        return self.model_dump_json()
 
     @classmethod
     def from_json(cls, json_str: str) -> 'BaseDBModel':

{danielutils-1.1.25 → danielutils-1.1.26}/danielutils/tools/unittest_test_runner/cli.py

@@ -5,7 +5,7 @@ Command-line interface for the test runner using Google Fire.
 import logging
 import fire
 from typing import Optional, Literal
-from .core import TestRunner, VerboseLevel
+from .core import UnittestRunner, VerboseLevel
 
 logger = logging.getLogger(__name__)
 
@@ -34,7 +34,7 @@ def run_tests(python_path: Optional[str] = None,
     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(
+    runner = UnittestRunner(
         python_path=python_path,
         results_file=results_file,
         skip_threshold_hours=skip_threshold,

{danielutils-1.1.25 → danielutils-1.1.26}/danielutils/tools/unittest_test_runner/core/__init__.py

@@ -5,11 +5,11 @@ 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
+- runner: Main UnittestRunner orchestration
 - types: Type definitions and data structures
 """
 
-from .runner import TestRunner
+from .runner import UnittestRunner
 
 # Define VerboseLevel here since it's a simple type alias
 from typing import Literal

{danielutils-1.1.25 → danielutils-1.1.26}/danielutils/tools/unittest_test_runner/core/discovery.py

@@ -7,18 +7,18 @@ import os
 import subprocess
 from pathlib import Path
 from typing import List, Dict, Optional, Tuple, Literal
-from ..models import TestDiscovery
+from ..models import UnittestDiscovery
 
 logger = logging.getLogger(__name__)
 
 VerboseLevel = Literal["module", "file", "class", "function"]
 
 
-class TestDiscoveryService:
+class UnittestDiscoveryService:
     """Handles discovery of test structure and target parsing."""
     
     def __init__(self, python_path: str, verbose: VerboseLevel = "class"):
-        logger.debug("Initializing TestDiscoveryService with python_path=%s, verbose=%s", python_path, verbose)
+        logger.debug("Initializing UnittestDiscoveryService with python_path=%s, verbose=%s", python_path, verbose)
         self._python_path = python_path
         self._verbose = verbose
     
@@ -107,7 +107,7 @@ class TestDiscoveryService:
             
         return sorted(test_modules)
     
-    def discover_test_structure(self, test_modules: List[str]) -> TestDiscovery:
+    def discover_test_structure(self, test_modules: List[str]) -> UnittestDiscovery:
         """Discover the complete test structure for progress tracking."""
         logger.info("Discovering test structure for %d modules", len(test_modules))
         if self._verbose in ["module", "file", "class", "function"]:
@@ -192,7 +192,7 @@ class TestDiscoveryService:
         if self._verbose in ["module", "file", "class", "function"]:
             print(f"  ✅ Discovery complete: {len(modules)} modules, {total_classes} classes, {total_functions} functions")
         
-        discovery = TestDiscovery(
+        discovery = UnittestDiscovery(
             modules=modules,
             classes=classes,
             functions=functions,
@@ -254,7 +254,7 @@ class TestDiscoveryService:
         return module, class_name, function_name
     
     def create_focused_discovery(self, target_module: str, target_class: Optional[str], 
-                               target_function: Optional[str], full_discovery: TestDiscovery) -> TestDiscovery:
+                               target_function: Optional[str], full_discovery: UnittestDiscovery) -> UnittestDiscovery:
         """Create a focused test discovery based on target specification."""
         logger.debug("Creating focused discovery for target: %s.%s.%s", target_module, target_class or '', target_function or '')
         if self._verbose == "function":
@@ -312,7 +312,7 @@ class TestDiscoveryService:
         logger.info("Created focused discovery: %d modules, %d classes, %d functions", 
                    len(modules), total_classes, total_functions)
         
-        return TestDiscovery(
+        return UnittestDiscovery(
             modules=modules,
             classes=classes,
             functions=functions,

{danielutils-1.1.25 → danielutils-1.1.26}/danielutils/tools/unittest_test_runner/core/execution.py

@@ -7,27 +7,27 @@ import logging
 import time
 import subprocess
 from typing import List, Optional, Literal
-from ..models import TestFunctionState, TestResult, ModuleState
-from .parser import TestOutputParser
+from ..models import UnittestFunctionState, UnittestResult, ModuleState
+from .parser import UnittestOutputParser
 
 logger = logging.getLogger(__name__)
 
 VerboseLevel = Literal["module", "file", "class", "function"]
 
 
-class TestExecutor:
+class UnittestExecutor:
     """Handles hierarchical test execution with _run_test_function as the core."""
     
     def __init__(self, python_path: str, verbose: VerboseLevel = "class", 
                  test_discovery: Optional[object] = None):
-        logger.debug("Initializing TestExecutor with python_path=%s, verbose=%s", python_path, verbose)
+        logger.debug("Initializing UnittestExecutor with python_path=%s, verbose=%s", python_path, verbose)
         self._python_path = python_path
         self._verbose = verbose
         self._test_discovery = test_discovery
-        self._parser = TestOutputParser(verbose)
+        self._parser = UnittestOutputParser(verbose)
     
     def run_test_function(self, module_path: str, test_class: str, test_function: str, 
-                         function_index: int = 0, total_functions: int = 0) -> TestFunctionState:
+                         function_index: int = 0, total_functions: int = 0) -> UnittestFunctionState:
         """Run a single test function and return its state. This is the core execution context."""
         logger.debug("Running test function: %s.%s.%s", module_path, test_class, test_function)
         indent = "        "  # 8 spaces for function level
@@ -66,7 +66,7 @@ class TestExecutor:
             else:
                 # Create a failed state if parsing failed
                 logger.warning("Failed to parse test output for function: %s", test_function)
-                error_state = TestFunctionState(
+                error_state = UnittestFunctionState(
                     function_name=test_function,
                     status="error",
                     runtime=0.0,
@@ -82,7 +82,7 @@ class TestExecutor:
                 
         except Exception as e:
             logger.error("Error running test function %s: %s", test_function, e)
-            error_state = TestFunctionState(
+            error_state = UnittestFunctionState(
                 function_name=test_function,
                 status="error",
                 runtime=0.0,
@@ -96,7 +96,7 @@ class TestExecutor:
                 print(f"{indent}  ⚠ {test_function} (error) - {e}")
             return error_state
     
-    def run_test_class(self, module_path: str, test_class: str, class_index: int = 0, total_classes: int = 0) -> List[TestFunctionState]:
+    def run_test_class(self, module_path: str, test_class: str, class_index: int = 0, total_classes: int = 0) -> List[UnittestFunctionState]:
         """Run all test functions in a test class and return their states."""
         logger.debug("Running test class: %s.%s", module_path, test_class)
         indent = "      "  # 6 spaces for class level
@@ -162,7 +162,7 @@ class TestExecutor:
             
             return test_functions
     
-    def run_test_file(self, module_path: str, file_index: int = 0, total_files: int = 0) -> List[TestFunctionState]:
+    def run_test_file(self, module_path: str, file_index: int = 0, total_files: int = 0) -> List[UnittestFunctionState]:
         """Run all test classes in a test file and return all test function states."""
         logger.debug("Running test file: %s", module_path)
         indent = "    "  # 4 spaces for file level

{danielutils-1.1.25 → danielutils-1.1.26}/danielutils/tools/unittest_test_runner/core/parser.py

@@ -5,19 +5,19 @@ Output parsing and result processing functionality.
 import logging
 import time
 from typing import List, Tuple
-from ..models import TestFunctionState
+from ..models import UnittestFunctionState
 
 logger = logging.getLogger(__name__)
 
 
-class TestOutputParser:
+class UnittestOutputParser:
     """Handles parsing of unittest output and creating test states."""
     
     def __init__(self, verbose: str = "class"):
-        logger.debug("Initializing TestOutputParser with verbose=%s", verbose)
+        logger.debug("Initializing UnittestOutputParser with verbose=%s", verbose)
         self._verbose = verbose
     
-    def parse_test_output(self, output_lines: List[str], stderr_lines: List[str]) -> Tuple[List[TestFunctionState], List[str], List[str]]:
+    def parse_test_output(self, output_lines: List[str], stderr_lines: List[str]) -> Tuple[List[UnittestFunctionState], List[str], List[str]]:
         """Parse unittest output to extract individual test function results."""
         logger.debug("Parsing test output: %d output lines, %d stderr lines", len(output_lines), len(stderr_lines))
         test_functions = []
@@ -114,7 +114,7 @@ class TestOutputParser:
                                 pass
                     
                     # Create test function state
-                    test_function = TestFunctionState(
+                    test_function = UnittestFunctionState(
                         function_name=test_name,
                         status=status or "unknown",
                         runtime=runtime,
@@ -146,7 +146,7 @@ class TestOutputParser:
                     if match and int(match.group(1)) > 0:
                         # This is a summary line, but we can't extract individual results
                         # Just create a placeholder
-                        test_function = TestFunctionState(
+                        test_function = UnittestFunctionState(
                             function_name="unknown",
                             status="unknown",
                             runtime=0.0,

{danielutils-1.1.25 → danielutils-1.1.26}/danielutils/tools/unittest_test_runner/core/runner.py

@@ -1,5 +1,5 @@
 """
-Main TestRunner orchestration functionality.
+Main UnittestRunner orchestration functionality.
 """
 
 import logging
@@ -9,17 +9,17 @@ import time
 import json
 import subprocess
 from typing import List, Optional, Literal, Tuple
-from ..models import TestFunctionState, ModuleState, TestResult, TestRunSummary, TestDiscovery
-from .discovery import TestDiscoveryService
-from .execution import TestExecutor
-from .parser import TestOutputParser
+from ..models import UnittestFunctionState, ModuleState, UnittestResult, UnittestRunSummary, UnittestDiscovery
+from .discovery import UnittestDiscoveryService
+from .execution import UnittestExecutor
+from .parser import UnittestOutputParser
 
 logger = logging.getLogger(__name__)
 
 VerboseLevel = Literal["module", "file", "class", "function"]
 
 
-class TestRunner:
+class UnittestRunner:
     """Smart test runner that executes tests module by module and collects detailed statistics."""
     
     def __init__(self, 
@@ -31,7 +31,7 @@ class TestRunner:
                  target: Optional[str] = None,
                  verbose: VerboseLevel = "class",
                  show_function_results: bool = False):
-        logger.info("Initializing TestRunner with python_path=%s, results_file=%s, skip_threshold_hours=%d, force_run=%s, target=%s, verbose=%s", 
+        logger.info("Initializing UnittestRunner with python_path=%s, results_file=%s, skip_threshold_hours=%d, force_run=%s, target=%s, verbose=%s", 
                    python_path, results_file, skip_threshold_hours, force_run, target, verbose)
         
         self.python_path = python_path or sys.executable
@@ -61,12 +61,12 @@ class TestRunner:
         
         # Initialize services
         logger.debug("Initializing discovery service and parser")
-        self.discovery_service = TestDiscoveryService(self.python_path, self.verbose)
-        self.parser = TestOutputParser(self.verbose)
+        self.discovery_service = UnittestDiscoveryService(self.python_path, self.verbose)
+        self.parser = UnittestOutputParser(self.verbose)
         
         # Initialize state
-        self.results: List[TestResult] = []
-        self.previous_results: Optional[TestRunSummary] = None
+        self.results: List[UnittestResult] = []
+        self.previous_results: Optional[UnittestRunSummary] = None
         logger.debug("Loading previous results from: %s", self.results_file)
         self._load_previous_results()
         
@@ -90,7 +90,7 @@ class TestRunner:
             self.test_modules = self.discovery_service.discover_test_modules()
         
         logger.info("Discovered %d test modules", len(self.test_modules))
-        self.test_discovery: Optional[TestDiscovery] = None
+        self.test_discovery: Optional[UnittestDiscovery] = None
         self._discover_test_structure()
         
         # Apply target filtering if specified
@@ -109,7 +109,7 @@ class TestRunner:
         
         # Initialize executor
         logger.debug("Initializing test executor")
-        self.executor = TestExecutor(self.python_path, self.verbose, self.test_discovery)
+        self.executor = UnittestExecutor(self.python_path, self.verbose, self.test_discovery)
     
     def _discover_test_structure(self):
         """Discover the complete test structure for progress tracking."""
@@ -131,7 +131,7 @@ class TestRunner:
             with open(self.results_file, 'r') as f:
                 data = json.load(f)
                 
-                # Convert results list from dicts to TestResult objects
+                # Convert results list from dicts to UnittestResult objects
                 if 'results' in data and isinstance(data['results'], list):
                     results = []
                     logger.debug("Converting %d previous results from dicts to objects", len(data['results']))
@@ -139,15 +139,15 @@ class TestRunner:
                         # Convert nested dicts to proper objects
                         if 'module_state' in result_dict:
                             module_state_dict = result_dict['module_state']
-                            # Convert test_functions dict to TestFunctionState objects
+                            # Convert test_functions dict to UnittestFunctionState objects
                             test_functions = {}
                             if 'test_functions' in module_state_dict:
                                 for func_name, func_dict in module_state_dict['test_functions'].items():
-                                    test_functions[func_name] = TestFunctionState(**func_dict)
+                                    test_functions[func_name] = UnittestFunctionState(**func_dict)
                             
                             # Create ModuleState objects
-                            initial_state = TestFunctionState(**module_state_dict['initial_state']) if module_state_dict.get('initial_state') else None
-                            current_state = TestFunctionState(**module_state_dict['current_state']) if module_state_dict.get('current_state') else None
+                            initial_state = UnittestFunctionState(**module_state_dict['initial_state']) if module_state_dict.get('initial_state') else None
+                            current_state = UnittestFunctionState(**module_state_dict['current_state']) if module_state_dict.get('current_state') else None
                             
                             module_state = ModuleState(
                                 initial_state=initial_state,
@@ -155,7 +155,7 @@ class TestRunner:
                                 test_functions=test_functions
                             )
                             
-                            result = TestResult(
+                            result = UnittestResult(
                                 module_path=result_dict['module_path'],
                                 module_state=module_state,
                                 errors=result_dict.get('errors', []),
@@ -165,7 +165,7 @@ class TestRunner:
                     
                     data['results'] = results
                 
-                self.previous_results = TestRunSummary(**data)
+                self.previous_results = UnittestRunSummary(**data)
                 logger.info("Successfully loaded previous results: %d modules, %d tests", 
                            self.previous_results.total_modules, self.previous_results.total_tests)
         except Exception as e:
@@ -216,7 +216,7 @@ class TestRunner:
         logger.debug("Module %s needs attention", module_path)
         return False, "Module needs attention"
     
-    def _create_module_state(self, module_path: str, test_functions: List[TestFunctionState], 
+    def _create_module_state(self, module_path: str, test_functions: List[UnittestFunctionState], 
                            total_runtime: float) -> ModuleState:
         """Create a ModuleState from test function results."""
         if not test_functions:
@@ -357,7 +357,7 @@ class TestRunner:
         logger.info("All test execution completed")
         self._print_final_summary()
     
-    def _run_test_module(self, module_path: str) -> TestResult:
+    def _run_test_module(self, module_path: str) -> UnittestResult:
         """Run a single test module and collect detailed statistics."""
         logger.debug("Running test module: %s", module_path)
         if self.verbose in ["module", "file", "class", "function"]:
@@ -430,7 +430,7 @@ class TestRunner:
                     current_state.errors < initial_state.errors
                 )
             
-            return TestResult(
+            return UnittestResult(
                 module_path=module_path,
                 initial_state=initial_state,
                 current_state=current_state,
@@ -447,7 +447,7 @@ class TestRunner:
             
             # Create error state
             current_state = self._create_module_state(module_path, [], time.time() - start_time)
-            return TestResult(
+            return UnittestResult(
                 module_path=module_path,
                 initial_state=initial_state,
                 current_state=current_state,
@@ -463,7 +463,7 @@ class TestRunner:
             
             # Create error state
             current_state = self._create_module_state(module_path, [], time.time() - start_time)
-            return TestResult(
+            return UnittestResult(
                 module_path=module_path,
                 initial_state=initial_state,
                 current_state=current_state,
@@ -534,7 +534,7 @@ class TestRunner:
         total_execution_time = sum(r.current_state.total_runtime for r in self.results)
         
         # Create summary
-        summary = TestRunSummary(
+        summary = UnittestRunSummary(
             timestamp=time.strftime('%Y-%m-%d %H:%M:%S'),
             python_executable=self.python_path,
             total_modules=total_modules,

{danielutils-1.1.25 → danielutils-1.1.26}/danielutils/tools/unittest_test_runner/models.py

@@ -8,7 +8,7 @@ import time
 
 
 @dataclass
-class TestFunctionState:
+class UnittestFunctionState:
     """State of an individual test function."""
     function_name: str
     status: str  # "passed", "failed", "skipped", "error", "unknown"
@@ -25,7 +25,7 @@ class TestFunctionState:
 class ModuleState:
     """State of a test module containing multiple test functions."""
     module_path: str
-    test_functions: List[TestFunctionState]
+    test_functions: List[UnittestFunctionState]
     total_tests: int
     passed: int
     failed: int
@@ -43,7 +43,7 @@ class ModuleState:
 
 
 @dataclass
-class TestResult:
+class UnittestResult:
     """Result of running a test module with initial and current states."""
     module_path: str
     initial_state: Optional[ModuleState]
@@ -54,7 +54,7 @@ class TestResult:
 
 
 @dataclass
-class TestRunSummary:
+class UnittestRunSummary:
     """Summary of a complete test run across all modules."""
     timestamp: str
     python_executable: str
@@ -68,11 +68,11 @@ class TestRunSummary:
     total_errors: int
     success_rate: float
     total_execution_time: float
-    results: List[TestResult]
+    results: List[UnittestResult]
 
 
 @dataclass
-class TestDiscovery:
+class UnittestDiscovery:
     """Represents discovered test structure for progress tracking."""
     modules: List[str]
     classes: Dict[str, List[str]]  # module -> list of classes

{danielutils-1.1.25 → danielutils-1.1.26/danielutils.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: danielutils
-Version: 1.1.25
+Version: 1.1.26
 Summary: A comprehensive Python utilities library providing type-safe collections, async programming tools, database abstractions, retry executors, data structures, and developer productivity enhancements to streamline Python development workflows
 Author-email: danielnachumdev <danielnachumdev@gmail.com>
 License: MIT License

{danielutils-1.1.25 → danielutils-1.1.26}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "danielutils"
-version = "1.1.25"
+version = "1.1.26"
 authors = [
     { name = "danielnachumdev", email = "danielnachumdev@gmail.com" },
 ]