qa-testing-utils 0.0.10__tar.gz → 0.0.11__tar.gz

{qa_testing_utils-0.0.10 → qa_testing_utils-0.0.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: qa-testing-utils
-Version: 0.0.10
+Version: 0.0.11
 Summary: QA testing utilities
 Author-Email: Adrian Herscu <adrian.herscu@gmail.com>
 License: Apache-2.0

{qa_testing_utils-0.0.10 → qa_testing_utils-0.0.11}/pyproject.toml

@@ -3,7 +3,7 @@ distribution = true
 
 [tool.pdm.version]
 source = "scm"
-write_to = "qa_testing_utils/__init__.py"
+write_to = "qa_testing_utils/_version.py"
 write_template = "__version__ = '{}'"
 fallback_version = "0.0.0"
 
@@ -31,7 +31,7 @@ dependencies = [
     "more-itertools==10.7.0",
     "returns==0.25.0",
 ]
-version = "0.0.10"
+version = "0.0.11"
 
 [project.license]
 text = "Apache-2.0"

qa_testing_utils-0.0.11/src/qa_testing_utils/__init__.py

@@ -0,0 +1,88 @@
+# mkinit: start preserve
+from ._version import __version__  # isort: skip
+# mkinit: end preserve
+
+from qa_testing_utils.conftest_helpers import (
+    configure,
+    get_test_body,
+    makereport,
+)
+from qa_testing_utils.exception_utils import (
+    safely,
+    swallow,
+)
+from qa_testing_utils.exceptions import (
+    TestException,
+)
+from qa_testing_utils.file_utils import (
+    IterableReader,
+    crc32_of,
+    decompress_xz_stream,
+    extract_files_from_tar,
+    read_lines,
+    stream_file,
+    write_csv,
+)
+from qa_testing_utils.logger import (
+    Context,
+    LoggerMixin,
+    logger,
+    trace,
+)
+from qa_testing_utils.matchers import (
+    ContainsStringIgnoringCase,
+    IsIteratorYielding,
+    IsIteratorYieldingAll,
+    IsStreamContainingEvery,
+    IsWithinDates,
+    TracingMatcher,
+    adapted_iterator,
+    adapted_object,
+    adapted_sequence,
+    contains_string_ignoring_case,
+    match_as,
+    tracing,
+    within_dates,
+    yields_every,
+    yields_item,
+    yields_items,
+)
+from qa_testing_utils.object_utils import (
+    ImmutableMixin,
+    InvalidValueException,
+    SingletonBase,
+    SingletonMeta,
+    ToDictMixin,
+    Valid,
+    WithMixin,
+    classproperty,
+    require_not_none,
+    valid,
+)
+from qa_testing_utils.stream_utils import (
+    process_next,
+)
+from qa_testing_utils.string_utils import (
+    to_string,
+)
+from qa_testing_utils.thread_utils import (
+    ThreadLocal,
+    sleep_for,
+)
+from qa_testing_utils.tuple_utils import (
+    FromTupleMixin,
+)
+
+__all__ = ['ContainsStringIgnoringCase', 'Context', 'FromTupleMixin',
+           'ImmutableMixin', 'InvalidValueException', 'IsIteratorYielding',
+           'IsIteratorYieldingAll', 'IsStreamContainingEvery', 'IsWithinDates',
+           'IterableReader', 'LoggerMixin', 'SingletonBase', 'SingletonMeta',
+           'TestException', 'ThreadLocal', 'ToDictMixin', 'TracingMatcher',
+           'Valid', 'WithMixin', 'adapted_iterator', 'adapted_object',
+           'adapted_sequence', 'classproperty', 'configure',
+           'contains_string_ignoring_case', 'crc32_of', 'decompress_xz_stream',
+           'extract_files_from_tar', 'get_test_body', 'logger', 'makereport',
+           'match_as', 'process_next', 'read_lines', 'require_not_none',
+           'safely', 'sleep_for', 'stream_file', 'swallow', 'to_string',
+           'trace', 'tracing', 'valid', 'within_dates', 'write_csv',
+           'yields_every', 'yields_item', 'yields_items']

qa_testing_utils-0.0.11/src/qa_testing_utils/_version.py

@@ -0,0 +1 @@
+__version__ = '0.0.11'

{qa_testing_utils-0.0.10 → qa_testing_utils-0.0.11}/src/qa_testing_utils/conftest_helpers.py

@@ -4,9 +4,8 @@
 
 import inspect
 import logging.config
-from pathlib import Path
 import sys
-from typing import Callable, Optional
+from pathlib import Path
 
 import pytest
 
@@ -15,6 +14,10 @@ def configure(config: pytest.Config,
               path: Path = Path(__file__).parent / "logging.ini") -> None:
     """
     Configures logging for pytest using a specified INI file, or defaults to internal logging.ini.
+
+    Args:
+        config (pytest.Config): The pytest configuration object.
+        path (Path, optional): Path to the logging configuration file. Defaults to 'logging.ini' in the current directory.
     """
     caller_module = inspect.getmodule(inspect.stack()[1][0])
     module_name = caller_module.__name__ if caller_module else "unknown"
@@ -28,6 +31,15 @@ def configure(config: pytest.Config,
 
 def makereport(
         item: pytest.Item, call: pytest.CallInfo[None]) -> pytest.TestReport:
+    """
+    Creates a pytest test report and appends the test body source code to the report sections.
+
+    Args:
+        item (pytest.Item): The pytest test item.
+        call (pytest.CallInfo[None]): The call information for the test.
+    Returns:
+        pytest.TestReport: The generated test report with the test body included.
+    """
     report = pytest.TestReport.from_item_and_call(item, call)
 
     if call.when == "call":
@@ -37,7 +49,15 @@ def makereport(
 
 
 def get_test_body(item: pytest.Item) -> str:
-    function: Optional[Callable[..., None]] = getattr(item, 'function', None)
+    """
+    Retrieves the source code of the test function for the given pytest item.
+
+    Args:
+        item (pytest.Item): The pytest test item.
+    Returns:
+        str: The source code of the test function, or an error message if unavailable.
+    """
+    function = getattr(item, 'function', None)
     if function is None:
         return "No function found for this test item."
 

{qa_testing_utils-0.0.10 → qa_testing_utils-0.0.11}/src/qa_testing_utils/exception_utils.py

@@ -6,8 +6,8 @@ import functools
 import logging
 from typing import Any, Callable
 
-from returns.maybe import Maybe, Nothing, Some
 from qa_testing_utils.stream_utils import Supplier
+from returns.maybe import Maybe, Nothing, Some
 
 
 def safely[T](supplier: Supplier[T]) -> Maybe[T]:
@@ -24,8 +24,7 @@ def safely[T](supplier: Supplier[T]) -> Maybe[T]:
         Maybe[T]: The result wrapped in Maybe, or Nothing if an exception occurs.
     """
     try:
-        result = supplier()
-        return Some(result)
+        return Some(supplier())
     except Exception as e:
         logging.exception(f"Exception occurred: {e}")
         return Nothing

{qa_testing_utils-0.0.10 → qa_testing_utils-0.0.11}/src/qa_testing_utils/file_utils.py

@@ -13,9 +13,9 @@ from zlib import crc32
 from more_itertools import peekable
 from qa_testing_utils.logger import *
 from qa_testing_utils.object_utils import *
-from qa_testing_utils.string_utils import *
+from qa_testing_utils.string_utils import DOT, EMPTY_BYTES, SPACE, UTF_8
 
-LAUNCHING_DIR = Path.cwd()
+LAUNCHING_DIR: Final[Path] = Path.cwd()
 
 
 @final

{qa_testing_utils-0.0.10 → qa_testing_utils-0.0.11}/src/qa_testing_utils/logger.py

@@ -2,37 +2,49 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from dataclasses import dataclass
 import inspect
 import logging
+from dataclasses import dataclass
 from functools import cached_property, wraps
-from typing import Callable, ClassVar, ParamSpec, TypeVar, cast, final
+from typing import Callable, ClassVar, Final, ParamSpec, TypeVar, cast, final
 
 import allure
 from qa_testing_utils.object_utils import classproperty
 from qa_testing_utils.string_utils import EMPTY_STRING, LF
 from qa_testing_utils.thread_utils import ThreadLocal
 
-P = ParamSpec('P')
-R = TypeVar('R')
+_P = ParamSpec('_P')
+_R = TypeVar('_R')
+
 
 @dataclass
+@final
 class Context:
     """Per-thread context for reporting and logging, allowing dynamic formatting of messages."""
-    _local: ClassVar[ThreadLocal['Context']]
-    _context_fn: Callable[[str], str]
+    _THREAD_LOCAL: ClassVar[ThreadLocal['Context']]
+    _formatter: Final[Callable[[str], str]]
+
+    @classmethod
+    def default(cls) -> "Context":
+        """
+        Returns a default Context instance with a no-op formatter.
+
+        Returns:
+            Context: A Context instance with the identity formatter.
+        """
+        return cls(lambda _: _)  # no formatter
 
     @classproperty
-    def _apply(cls) -> Callable[[str], str]:
-        return Context._local.get()._context_fn
+    def _format(cls) -> Callable[[str], str]:
+        return cls._THREAD_LOCAL.get()._formatter
 
-    @staticmethod
-    def set(context_fn: Callable[[str], str]) -> None:
+    @classmethod
+    def set(cls, context_fn: Callable[[str], str]) -> None:
         """Sets per-thread context function to be used for formatting report and log messages."""
-        return Context._local.set(Context(context_fn))
-    
-    @staticmethod
-    def traced(func: Callable[P, R]) -> Callable[P, R]:
+        cls._THREAD_LOCAL.set(Context(context_fn))
+
+    @classmethod
+    def traced(cls, func: Callable[_P, _R]) -> Callable[_P, _R]:
         """
         Decorator to log function entry, arguments, and return value at DEBUG level.
 
@@ -53,7 +65,7 @@ class Context:
             Callable[P, R]: The result of the function call.
         """
         @wraps(func)
-        def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+        def wrapper(*args: _P.args, **kwargs: _P.kwargs) -> _R:
             # NOTE: each time a decorated function is called this logic will be
             # re-evaluated.
             signature = inspect.signature(func)
@@ -63,23 +75,24 @@ class Context:
                 instance = args[0]
                 logger = logging.getLogger(f"{instance.__class__.__name__}")
                 logger.debug(f">>> "
-                    + Context._apply(
-                        f"{func.__name__} "
-                        f"{", ".join([str(arg) for arg in args[1:]])} "
-                        f"{LF.join(
-                            f"{key}={str(value)}"
-                            for key, value in kwargs.items()) if kwargs else EMPTY_STRING}"))
+                             + cls._format(
+                                 f"{func.__name__} "
+                                 f"{", ".join([str(arg) for arg in args[1:]])} "
+                                 f"{LF.join(
+                                     f"{key}={str(value)}"
+                                     for key, value in kwargs.items()) if kwargs else EMPTY_STRING}"))
 
                 with allure.step(  # type: ignore
-                    Context._apply(
+                    cls._format(
                         f"{func.__name__} "
                         f"{', '.join([str(arg) for arg in args[1:]])}")):
                     result = func(*args, **kwargs)
 
                 if result == instance:
-                    logger.debug(f"<<< " + Context._apply(f"{func.__name__}"))
+                    logger.debug(f"<<< " + cls._format(f"{func.__name__}"))
                 else:
-                    logger.debug(f"<<< " + Context._apply(f"{func.__name__} {result}"))
+                    logger.debug(
+                        f"<<< " + cls._format(f"{func.__name__} {result}"))
 
                 return result
             else:
@@ -93,7 +106,8 @@ class Context:
 
 
 # NOTE: python does not support static initializers, so we init here.
-Context._local = ThreadLocal(Context(lambda _: _)) # type: ignore
+Context._THREAD_LOCAL = ThreadLocal(Context.default())  # type: ignore
+
 
 def trace[T](value: T) -> T:
     """Logs at debug level using the invoking module name as the logger."""
@@ -118,13 +132,16 @@ def trace[T](value: T) -> T:
 
 def logger[T:type](cls: T) -> T:
     """
-    Class decorator that injects a logger into annotated class.
+    Class decorator that injects a logger into the decorated class.
+
+    Adds a `log` property to the class, providing a logger named after the class.
+    Useful for adding logging to any class without boilerplate.
 
     Args:
-        cls (type): automatically provided by the runtime
+        cls (type): The class to decorate.
 
     Returns:
-        _type_: the decorated class
+        type: The decorated class with a `log` property.
     """
     cls._logger = logging.getLogger(cls.__name__)
 
@@ -152,6 +169,12 @@ class LoggerMixin:
     @final
     @cached_property
     def log(self) -> logging.Logger:
+        """
+        Returns a logger named after the class.
+
+        Returns:
+            logging.Logger: The logger instance for this class.
+        """
         return logging.getLogger(self.__class__.__name__)
 
     @final
@@ -164,14 +187,13 @@ class LoggerMixin:
             then.eventually_assert_that(
                 lambda: self.trace(...call some API...),
                 greater_that(0)) \
-
                 .and_....other verifications may follow...
 
         Args:
-            value (T): the value
+            value (T): The value to log.
 
         Returns:
-            T: the value
+            T: The value (unchanged).
         """
         self.log.debug(f"=== {value}")
         return value

{qa_testing_utils-0.0.10 → qa_testing_utils-0.0.11}/src/qa_testing_utils/matchers.py

@@ -3,20 +3,35 @@
 # SPDX-License-Identifier: Apache-2.0
 
 from datetime import date, datetime
-from typing import (Any, Callable, Iterable, Iterator, List, Optional, Sequence,
-                    Union, cast, final, override)
+from typing import (
+    Any,
+    Callable,
+    Iterable,
+    Iterator,
+    List,
+    Optional,
+    Sequence,
+    Union,
+    cast,
+    final,
+    override,
+)
 
 from hamcrest.core.base_matcher import BaseMatcher
 from hamcrest.core.description import Description
 from hamcrest.core.helpers.wrap_matcher import wrap_matcher
 from hamcrest.core.matcher import Matcher
-
 from qa_testing_utils.logger import LoggerMixin
 
 
 class TracingMatcher[T](BaseMatcher[T], LoggerMixin):
     """
     A matcher wrapper that adds debug logging around another matcher.
+
+    Logs the result of each match attempt using the class logger.
+
+    Args:
+        matcher (Matcher[T]): The matcher to wrap and trace.
     """
 
     def __init__(self, matcher: Matcher[T]) -> None:
@@ -31,17 +46,30 @@ class TracingMatcher[T](BaseMatcher[T], LoggerMixin):
         self._matcher.describe_to(description)
 
 
-def traced[T](matcher: Matcher[T]) -> TracingMatcher[T]:
+def tracing[T](matcher: Matcher[T]) -> TracingMatcher[T]:
     """
-    Wraps a matcher with TraceMatcher to enable debug logging.
+    Wraps a matcher with TracingMatcher to enable debug logging.
 
     Usage:
-        assert_that(actual, trace(contains_string("hello")))
+        assert_that(actual, traced(contains_string("hello")))
+
+    Args:
+        matcher (Matcher[T]): The matcher to wrap.
+    Returns:
+        TracingMatcher[T]: The wrapped matcher with tracing enabled.
     """
     return TracingMatcher(matcher)
 
 
+@final
 class ContainsStringIgnoringCase(BaseMatcher[str]):
+    """
+    Matcher that checks if a string contains a given substring, ignoring case.
+
+    Args:
+        substring (str): The substring to search for (case-insensitive).
+    """
+
     def __init__(self, substring: str) -> None:
         self.substring: str = substring.lower()
 
@@ -147,9 +175,10 @@ class IsIteratorYieldingAll[T](BaseMatcher[Iterator[T]]):
             description.append_description_of(matcher)
 
 
-DateOrDateTime = Union[date, datetime]
+type DateOrDateTime = Union[date, datetime]
 
 
+@final
 class IsWithinDates(BaseMatcher[DateOrDateTime]):
     def __init__(
             self, start_date: Optional[DateOrDateTime],
@@ -255,8 +284,7 @@ def yields_items[T](matches: Iterable[Union[Matcher[T],
     This matcher will iterate through the evaluated iterator and check if it yields
     at least one instance of each specified matcher or value.
     """
-    wrapped_matchers = [wrap_matcher(match) for match in matches]
-    return IsIteratorYieldingAll(wrapped_matchers)
+    return IsIteratorYieldingAll([wrap_matcher(match) for match in matches])
 
 
 def adapted_object[T, R](

{qa_testing_utils-0.0.10 → qa_testing_utils-0.0.11}/src/qa_testing_utils/object_utils.py

@@ -2,12 +2,19 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import Callable, Any
 import threading
 from dataclasses import asdict, fields, is_dataclass, replace
 from enum import Enum
-from typing import (Any, Dict, Optional, Protocol,
-                    final, runtime_checkable, ClassVar)
+from typing import (
+    Any,
+    Callable,
+    ClassVar,
+    Dict,
+    Optional,
+    Protocol,
+    final,
+    runtime_checkable,
+)
 
 
 @runtime_checkable
@@ -159,6 +166,7 @@ class ToDictMixin:
         return flat_dict
 
 
+@final
 class SingletonMeta(type):
     """
     Thread-safe singleton metaclass.
@@ -201,16 +209,16 @@ class InvalidValueException(ValueError):
 
 def valid[T:Valid](value: T) -> T:
     """
-    Validates specified object, assuming that it supports the Valid protocol.
+    Validates the specified object, assuming it supports the Valid protocol.
 
     Args:
-        value (T:Valid): the object
+        value (T:Valid): The object to validate.
 
     Raises:
-        InvalidValueException: if the object is invalid
+        InvalidValueException: If the object is invalid (is_valid() returns False).
 
     Returns:
-        T:Valid: the validated object
+        T:Valid: The validated object if valid.
     """
     if value.is_valid():
         return value
@@ -228,18 +236,29 @@ def require_not_none[T](
         value (Optional[T]): The value to check for None.
         message (str, optional): The error message to use if value is None. Defaults to "Value must not be None".
 
-    Returns:
-        T: The value, guaranteed to be not None.
-
     Raises:
         ValueError: If value is None.
+
+    Returns:
+        T: The value, guaranteed to be not None.
     """
     if value is None:
         raise ValueError(message)
     return value
 
 
+@final
 class classproperty[T]:
+    """
+    Descriptor for defining class-level properties (like @property but for classes).
+
+    Example:
+        class MyClass:
+            @classproperty
+            def foo(cls):
+                return ...
+    """
+
     def __init__(self, fget: Callable[[Any], T]) -> None:
         self.fget = fget
 

{qa_testing_utils-0.0.10 → qa_testing_utils-0.0.11}/src/qa_testing_utils/stream_utils.py

@@ -4,7 +4,6 @@
 
 from typing import Callable, Iterator
 
-
 """
 A generic callable type alias representing a supplier of values of type T.
 

{qa_testing_utils-0.0.10 → qa_testing_utils-0.0.11}/src/qa_testing_utils/string_utils.py

@@ -2,16 +2,16 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import Callable, Type
+from typing import Callable, Final, Literal, Type
 
 from ppretty import ppretty  # type: ignore
 
-EMPTY_STRING = ""
-SPACE = " "
-DOT = "."
-LF = "\n"
-UTF_8 = "utf-8"
-EMPTY_BYTES = b''
+EMPTY_STRING: Final[str] = ""
+SPACE: Final[str] = " "
+DOT: Final[str] = "."
+LF: Final[str] = "\n"
+UTF_8: Final[str] = "utf-8"
+EMPTY_BYTES: Final[Literal[b'']] = b''
 
 
 def to_string[T](indent: str = '    ',

qa_testing_utils-0.0.11/src/qa_testing_utils/thread_utils.py

@@ -0,0 +1,60 @@
+# SPDX-FileCopyrightText: 2025 Adrian Herscu
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import concurrent.futures
+import time
+from datetime import timedelta
+from threading import local
+from typing import Final, Optional, cast
+
+COMMON_EXECUTOR: Final[concurrent.futures.ThreadPoolExecutor] = concurrent.futures.ThreadPoolExecutor()
+"""
+A shared thread pool executor for concurrent tasks across the application.
+"""
+
+
+def sleep_for(duration: timedelta):
+    """
+    Sleep for the specified duration.
+
+    Args:
+        duration (timedelta): The amount of time to sleep.
+    """
+    time.sleep(duration.total_seconds())
+
+
+class ThreadLocal[T]:
+    """
+    Thread-local storage for a value, with a default initializer.
+
+    Provides per-thread storage for a value of type T, initialized with a default.
+    """
+
+    def __init__(self, default: Optional[T] = None):
+        """
+        Initializes the thread-local storage with a default value.
+
+        Args:
+            default (Optional[T]): The default value for each thread, None if not specified.
+        """
+        self._local = local()
+        self._local.value = default
+
+    def set(self, value: T) -> None:
+        """
+        Sets the thread-local value for the current thread.
+
+        Args:
+            value (T): The value to set for the current thread.
+        """
+        self._local.value = value
+
+    def get(self) -> T:
+        """
+        Gets the thread-local value for the current thread.
+
+        Returns:
+            T: The value for the current thread.
+        """
+        return cast(T, self._local.value)

{qa_testing_utils-0.0.10 → qa_testing_utils-0.0.11}/src/qa_testing_utils/tuple_utils.py

@@ -2,19 +2,34 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from dataclasses import is_dataclass, replace, fields
+from dataclasses import fields, is_dataclass, replace
 from typing import Any, Self, Tuple, Type
 
 
 class FromTupleMixin:
     """
-    Class decorator adding a `from_tuple` method allowing instantiation from
-    a tuple matching the order of decorated class fields.
+    Mixin that adds a `from_tuple` class method for instantiating objects from a tuple.
 
-    Works with frozen dataclasses too.
+    Allows creating an instance of a class (dataclass or regular class) by passing a tuple
+    whose values match the order of the class fields. Works with frozen dataclasses as well.
+
+    Example:
+        @dataclass(frozen=True)
+        class Point(FromTupleMixin):
+            x: int
+            y: int
+        p = Point.from_tuple((1, 2))
     """
     @classmethod
     def from_tuple(cls: Type[Self], data: Tuple[Any, ...]) -> Self:
+        """
+        Instantiates the class from a tuple of values, matching the order of class fields.
+
+        Args:
+            data (Tuple[Any, ...]): Tuple of values corresponding to the class fields.
+        Returns:
+            Self: An instance of the class with fields set from the tuple.
+        """
         if is_dataclass(cls):
             # Retrieve all fields, including inherited ones
             cls_fields = [f.name for f in fields(cls)]

{qa_testing_utils-0.0.10 → qa_testing_utils-0.0.11}/tests/assertion_tests.py

@@ -7,7 +7,13 @@ from random import randint
 from typing import Callable
 
 import pytest
-from tenacity import Retrying, before_sleep_log, retry_if_exception_type, stop_after_attempt, wait_exponential
+from tenacity import (
+    Retrying,
+    before_sleep_log,
+    retry_if_exception_type,
+    stop_after_attempt,
+    wait_exponential,
+)
 
 
 def unstable_function():

{qa_testing_utils-0.0.10 → qa_testing_utils-0.0.11}/tests/file_utils_tests.py

@@ -1,5 +1,6 @@
 import csv
 from pathlib import Path
+
 from qa_testing_utils.file_utils import *
 
 
@@ -70,8 +71,9 @@ def should_decompress_xz_stream():
 
 
 def should_extract_files_from_tar():
-    import tarfile
     import io
+    import tarfile
+
     # Create a tar archive in memory
     file_content = b"testdata"
     tar_bytes = io.BytesIO()

{qa_testing_utils-0.0.10 → qa_testing_utils-0.0.11}/tests/logger_tests.py

@@ -5,8 +5,8 @@
 from functools import wraps
 from typing import Callable, ParamSpec, Self, TypeVar
 
+from qa_pytest_rabbitmq.queue_handler import to_string
 from qa_testing_utils.logger import *
-from qa_testing_utils.string_utils import *
 
 
 def should_trace():

{qa_testing_utils-0.0.10 → qa_testing_utils-0.0.11}/tests/matchers_tests.py

@@ -8,11 +8,12 @@ from typing import Callable, Union
 import attr
 import pytest
 from functional import seq
-from hamcrest import all_of, assert_that, has_item, has_property, is_  # type: ignore -- seq
-from qa_testing_utils.string_utils import to_string
+from hamcrest import is_  # type: ignore
+from hamcrest import all_of, assert_that, has_item, has_property
 from qa_testing_utils.matchers import *
 from qa_testing_utils.object_utils import *
 from qa_testing_utils.string_utils import *
+from qa_testing_utils.string_utils import to_string
 
 
 @to_string()

{qa_testing_utils-0.0.10 → qa_testing_utils-0.0.11}/tests/self_tests.py

@@ -2,18 +2,24 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from datetime import timedelta
 import random
+from datetime import timedelta
 from typing import Any, final
 
 import attr
-from hamcrest import assert_that, is_  # type: ignore
 import pytest
-from tenacity import before_sleep_log, retry, retry_if_exception_type, stop_after_attempt, wait_fixed
-from qa_testing_utils.logger import Context
-from qa_testing_utils.logger import *
+from hamcrest import assert_that, is_  # type: ignore
 from qa_testing_utils.exceptions import *
+from qa_testing_utils.logger import *
+from qa_testing_utils.logger import Context
 from qa_testing_utils.thread_utils import *
+from tenacity import (
+    before_sleep_log,
+    retry,
+    retry_if_exception_type,
+    stop_after_attempt,
+    wait_fixed,
+)
 
 
 @final

{qa_testing_utils-0.0.10 → qa_testing_utils-0.0.11}/tests/thread_utils_tests.py

@@ -2,9 +2,10 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+import time
 from datetime import timedelta
+
 from qa_testing_utils.thread_utils import sleep_for
-import time
 
 
 def should_sleep_for_specified_duration():

qa_testing_utils-0.0.10/src/qa_testing_utils/__init__.py

@@ -1 +0,0 @@
-__version__ = '0.0.10'

qa_testing_utils-0.0.10/src/qa_testing_utils/thread_utils.py

@@ -1,32 +0,0 @@
-# SPDX-FileCopyrightText: 2025 Adrian Herscu
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import concurrent.futures
-from threading import local
-import time
-from datetime import timedelta
-from typing import cast
-
-COMMON_EXECUTOR = concurrent.futures.ThreadPoolExecutor()
-
-
-def sleep_for(duration: timedelta):
-    """
-    Sleep for the specified duration.
-    Args:
-        duration (timedelta): The amount of time to sleep.
-    """
-    time.sleep(duration.total_seconds())
-
-
-class ThreadLocal[T]:
-    def __init__(self, default: T):
-        self._local = local()
-        self._local.value = default
-
-    def set(self, value: T) -> None:
-        self._local.value = value
-
-    def get(self) -> T:
-        return cast(T, self._local.value)

{qa_testing_utils-0.0.10 → qa_testing_utils-0.0.11}/tests/string_utils_tests.py

@@ -2,8 +2,8 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from enum import Enum
 import logging
+from enum import Enum
 from typing import List
 
 from qa_testing_utils.string_utils import *