danielutils 1.1.28__py3-none-any.whl

danielutils/testing/unittest_/auto_cwd_testcase.py

@@ -0,0 +1,114 @@
+import asyncio
+import functools
+import logging
+import os
+import unittest
+from inspect import iscoroutinefunction
+from typing import Callable, Type, Coroutine, Union, Any
+
+from ...random_ import RandomDataGenerator
+from ...io_ import create_directory, delete_directory, directory_exists
+from ...path import get_current_working_directory, set_current_working_directory
+from ...logging_.utils import get_logger
+
+logger = get_logger(__name__)
+
+
+def dispatch_function(func: Union[Callable, Coroutine], *args, **kwargs) -> Any:
+    if asyncio.iscoroutinefunction(func):
+        return asyncio.run(func(*args, **kwargs))
+    elif asyncio.iscoroutine(func):
+        return asyncio.run(func)
+    else:
+        return func(*args, **kwargs)
+
+
+def get_available_folder_name(prefix_path: str, random_suffix_length: int = 15) -> str:
+    res = f"{prefix_path}_{RandomDataGenerator.name(random_suffix_length)}"
+    while directory_exists(res):
+        res = f"{prefix_path}_{RandomDataGenerator.name(random_suffix_length)}"
+    return res
+
+
+def improved_setup(func: Callable) -> Callable:
+    @functools.wraps(func)
+    def wrapper(self):
+        self.cwd = get_available_folder_name(f"./{self.__class__.__name__}_test_folder")
+        logger.debug("Creating test directory: %s", self.cwd)
+        create_directory(self.cwd)
+        self.prev_cwd = get_current_working_directory()
+        set_current_working_directory(os.path.join(self.prev_cwd, self.cwd))
+        logger.debug("Changed working directory to: %s", self.cwd)
+        if func is not None:
+            func(self)
+
+    @functools.wraps(func)
+    async def async_wrapper(self):
+        self.cwd = get_available_folder_name(f"./{self.__class__.__name__}_test_folder")
+        logger.debug("Creating async test directory: %s", self.cwd)
+        create_directory(self.cwd)
+        self.prev_cwd = get_current_working_directory()
+        set_current_working_directory(os.path.join(self.prev_cwd, self.cwd))
+        logger.debug("Changed working directory to: %s", self.cwd)
+        if func is not None:
+            await func(self)
+
+    return async_wrapper if iscoroutinefunction(func) else wrapper
+
+
+def improved_teardown(func: Callable) -> Callable:
+    @functools.wraps(func)
+    def wrapper(self):
+        if func is not None:
+            func(self)
+        logger.debug("Restoring working directory to: %s", self.prev_cwd)
+        set_current_working_directory(self.prev_cwd)
+        logger.debug("Cleaning up test directory: %s", self.cwd)
+        delete_directory(self.cwd)
+
+    @functools.wraps(func)
+    async def async_wrapper(self):
+        if func is not None:
+            await func(self)
+        logger.debug("Restoring working directory to: %s", self.prev_cwd)
+        set_current_working_directory(self.prev_cwd)
+        logger.debug("Cleaning up async test directory: %s", self.cwd)
+        delete_directory(self.cwd)
+
+    return async_wrapper if iscoroutinefunction(func) else wrapper
+
+
+class AutoCWDTestCase(unittest.TestCase):
+    @staticmethod
+    def _dummy(*args, **kwargs) -> None:
+        pass
+
+    @classmethod
+    def __init_subclass__(cls: Type, **kwargs) -> None:
+        logger.debug("Initializing AutoCWDTestCase subclass: %s", cls.__name__)
+        dct = dict(cls.__dict__)
+        impl_setUp = dct.get("setUp", cls._dummy)
+        impl_tearDown = dct.get("tearDown", cls._dummy)
+        setattr(cls, "setUp", improved_setup(impl_setUp))
+        setattr(cls, "tearDown", improved_teardown(impl_tearDown))
+
+
+class AsyncAutoCWDTestCase(unittest.IsolatedAsyncioTestCase):
+    @staticmethod
+    async def _async_dummy(*args, **kwargs) -> None:
+        pass
+
+    @classmethod
+    def __init_subclass__(cls: Type, **kwargs) -> None:
+        logger.debug("Initializing AsyncAutoCWDTestCase subclass: %s", cls.__name__)
+        dct = dict(cls.__dict__)
+        async_impl_setUp = dct.get("asyncSetUp", cls._async_dummy)
+        async_impl_tearDown = dct.get("asyncTearDown", cls._async_dummy)
+        setattr(cls, "asyncSetUp", improved_setup(async_impl_setUp))
+        setattr(cls, "asyncTearDown", improved_teardown(async_impl_tearDown))
+
+
+__all__ = [
+    'AutoCWDTestCase',
+    "AsyncAutoCWDTestCase"
+]

danielutils/text.py

@@ -0,0 +1,169 @@
+# -*- coding: utf-8 -*-
+import logging
+from typing import Union
+from .decorators.validate import validate
+from .functions.check_foreach import check_foreach
+from .logging_.utils import get_logger
+
+logger = get_logger(__name__)
+HEBREW_LETTERS = ['\u05D0', '\u2135', '\uFB21', '\uFB2E', '\uFB2F',
+                  '\uFB30', '\uFB4F', '\u05D1', '\u2136', '\uFB31',
+                  '\uFB4C', '\u05D2', '\u2137', '\uFB32', '\u05D3',
+                  '\u2138', '\uFB22', '\uFB33', '\u05D4', '\uFB23',
+                  '\uFB34', '\u05D5', '\uFB4B', '\uFB35', '\u05F0',
+                  '\u05F1', '\u05D6', '\uFB36', '\u05D7', '\u05D8',
+                  '\uFB38', '\u05D9', '\uFB1D', '\uFB39', '\u05EF',
+                  '\u05F2', '\uFB1F', '\u05DB', '\uFB24', '\u05DA',
+                  '\uFB3B', '\uFB3A', '\uFB4D', '\u05DC', '\uFB25',
+                  '\uFB3C', '\u05DE', '\uFB26', '\u05DD', '\uFB3E',
+                  '\u05E0', '\u05DF', '\uFB40', '\u05E1', '\uFB41',
+                  '\u05E2', '\uFB20', '\u05E4', '\u05E3', '\uFB44',
+                  '\uFB43', '\uFB4E', '\u05E6', '\u05E5', '\uFB46',
+                  '\u05E7', '\uFB47', '\u05E8', '\uFB27', '\uFB48',
+                  '\u05E9', '\uFB2B', '\uFB2A', '\uFB49', '\uFB2D',
+                  '\uFB2C', '\u05EA', '\uFB28', '\uFB4A']
+
+
+HEBREW_LETTERS_DEC = [ord(v) for v in HEBREW_LETTERS]
+HEBREW_LETTERS_HEX = [hex(v) for v in HEBREW_LETTERS_DEC]
+ENGLISH_LETTERS = [chr(v) for v in range(65, 91)]+[chr(v)
+                                                   for v in range(97, 123)]
+ENGLISH_LETTERS_DEC = [ord(v) for v in ENGLISH_LETTERS]
+ENGLISH_LETTERS_HEX = [hex(v) for v in ENGLISH_LETTERS_DEC]
+
+
+@validate  # type:ignore
+def is_english(s: str) -> bool:
+    """returns whether the specified string is in the english language
+
+    Args:
+        s (str): the string to check
+
+    Returns:
+        bool: returns true if the string is in english
+    """
+    return check_foreach(s, lambda c: c in ENGLISH_LETTERS)
+
+
+@validate  # type:ignore
+def is_number(s: str) -> bool:
+    """checks if a string is a number
+
+    Args:
+        text (str): string to check
+
+    Returns:
+        bool: true if string is a number
+    """
+    return s.isnumeric()
+
+
+@validate  # type:ignore
+def is_int(num: Union[int, float]) -> bool:
+    """_summary_
+
+    Args:
+        num (Union[int, float]): is a number an int
+
+    Returns:
+        bool: return true if num is a while number
+    """
+    if isinstance(num, int):
+        return True
+
+    return int(num) == num
+
+
+@validate  # type:ignore
+def is_float(s: str) -> bool:
+    """checks whether a string has a float value
+
+    Args:
+        s (str): string to check
+
+    Returns:
+        bool: result
+    """
+    try:
+        float(s)
+        logger.debug("String '%s' is a valid float", s)
+        return True
+    except ValueError:
+        logger.debug("String '%s' is not a valid float", s)
+        return False
+
+
+@validate  # type:ignore
+def is_hebrew(s: str) -> bool:
+    """checks if a string is in hebrew
+
+    Args:
+        text (str): string to check
+
+    Returns:
+        bool: true iff all chars are hebrew
+    """
+    return check_foreach(s, lambda c: c in HEBREW_LETTERS)
+
+
+@validate  # type:ignore
+def is_binary(s: str) -> bool:
+    """checks if s string has a binary value
+
+    Args:
+        s (str): string to check
+
+    Returns:
+        bool: result
+    """
+    return check_foreach(s, lambda c: c in {0, 1})
+
+
+@validate  # type:ignore
+def is_decimal(s: str) -> bool:
+    """checks if a string has a decimal number
+
+    Args:
+        s (str): string to check
+
+    Returns:
+        bool: result
+    """
+    return check_foreach(s, lambda c: c in range(10))
+
+
+@validate  # type:ignore
+def is_hex(s: str) -> bool:
+    """checks if a string has a hexadecimal value
+
+    Args:
+        s (str): string to check
+
+    Returns:
+        bool: result
+    """
+    try:
+        int(s, 16)
+        logger.debug("String '%s' is a valid hexadecimal", s)
+        return True
+    except ValueError:
+        logger.debug("String '%s' is not a valid hexadecimal", s)
+        return False
+
+
+__all__ = [
+    "HEBREW_LETTERS",
+    "HEBREW_LETTERS_DEC",
+    "HEBREW_LETTERS_HEX",
+    "ENGLISH_LETTERS",
+    "ENGLISH_LETTERS_DEC",
+    "ENGLISH_LETTERS_HEX",
+    "is_english",
+    "is_number",
+    "is_int",
+    "is_float",
+    "is_hebrew",
+    "is_binary",
+    "is_decimal",
+    "is_hex"
+]

danielutils/time.py

@@ -0,0 +1,64 @@
+import logging
+import time
+from datetime import datetime
+from typing import Callable, TypeVar
+from .versioned_imports import ParamSpec
+from .logging_.utils import get_logger
+
+logger = get_logger(__name__)
+
+T = TypeVar("T")
+P = ParamSpec("P")
+
+
+def measure(func: Callable[P, T]) -> Callable[P, float]:
+    """A function to measure the execution time of a function.
+
+    Args:
+        func (function): The function to be measured.
+
+    Returns:
+        float: The time taken in seconds to execute the given function.
+    """
+
+    def wrapper(*args, **kwargs) -> float:
+        logger.debug("Measuring execution time of function: %s", func.__name__)
+        start = time.time()
+        func(*args, **kwargs)
+        end = time.time()
+        execution_time = end - start
+        logger.debug("Function %s executed in %.4f seconds", func.__name__, execution_time)
+        return execution_time
+
+    return wrapper
+
+
+def epoch_to_datetime(epoch: float) -> datetime:
+    """Converts a POSIX timestamp to datetime
+
+    Args:
+        epoch (int): time from epoch
+
+    Returns:
+        datetime: resulting conversion
+    """
+    return datetime.fromtimestamp(epoch)
+
+
+def datetime_to_epoch(dt: datetime) -> float:
+    """Converts a datetime to a POSIX timestamp
+
+    Args:
+        dt (datetime): datetime object
+
+    Returns:
+        int: resulting conversion
+    """
+    return dt.timestamp()
+
+
+__all__ = [
+    "measure",
+    'epoch_to_datetime',
+    'datetime_to_epoch'
+]

danielutils/tools/__init__.py

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

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/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 UnittestRunner, 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 = UnittestRunner(
+        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/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 UnittestRunner orchestration
+- types: Type definitions and data structures
+"""
+
+from .runner import UnittestRunner
+
+# Define VerboseLevel here since it's a simple type alias
+from typing import Literal
+VerboseLevel = Literal["module", "file", "class", "function"]
+