qa-testing-utils 0.0.9__py3-none-any.whl → 0.0.11__py3-none-any.whl

qa_testing_utils/__init__.py

@@ -1 +1,88 @@
-__version__ = '0.0.9'
+# 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/_version.py

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

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/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/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/logger.py

@@ -4,11 +4,109 @@
 
 import inspect
 import logging
+from dataclasses import dataclass
 from functools import cached_property, wraps
-from typing import Callable, 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')
+
+
+@dataclass
+@final
+class Context:
+    """Per-thread context for reporting and logging, allowing dynamic formatting of messages."""
+    _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 _format(cls) -> Callable[[str], str]:
+        return cls._THREAD_LOCAL.get()._formatter
+
+    @classmethod
+    def set(cls, context_fn: Callable[[str], str]) -> None:
+        """Sets per-thread context function to be used for formatting report and log messages."""
+        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.
+
+        Also adds an Allure step for reporting. Use on methods where tracing is useful
+        for debugging or reporting.
+
+        Example:
+            @Context.traced
+            def my_method(self, x):
+                ...
+
+        Args:
+            func (Callable[P, R]): The function to be decorated.
+            *args (Any): Positional arguments to be passed to the function.
+            **kwargs (Any): Keyword arguments to be passed to the function.
+
+        Returns:
+            Callable[P, R]: The result of the function call.
+        """
+        @wraps(func)
+        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)
+            parameters = list(signature.parameters.keys())
+
+            if parameters and parameters[0] == 'self' and len(args) > 0:
+                instance = args[0]
+                logger = logging.getLogger(f"{instance.__class__.__name__}")
+                logger.debug(f">>> "
+                             + 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
+                    cls._format(
+                        f"{func.__name__} "
+                        f"{', '.join([str(arg) for arg in args[1:]])}")):
+                    result = func(*args, **kwargs)
+
+                if result == instance:
+                    logger.debug(f"<<< " + cls._format(f"{func.__name__}"))
+                else:
+                    logger.debug(
+                        f"<<< " + cls._format(f"{func.__name__} {result}"))
+
+                return result
+            else:
+                logger = logging.getLogger(func.__name__)
+                logger.debug(f">>> {func.__name__} {args} {kwargs}")
+                result = func(*args, **kwargs)
+                logger.debug(f"<<< {func.__name__} {result}")
+                return result
+
+        return wrapper
+
+
+# NOTE: python does not support static initializers, so we init here.
+Context._THREAD_LOCAL = ThreadLocal(Context.default())  # type: ignore
 
 
 def trace[T](value: T) -> T:
@@ -34,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__)
 
@@ -68,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
@@ -80,76 +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
-
-
-P = ParamSpec('P')
-R = TypeVar('R')
-
-
-def traced(func: Callable[P, R]) -> Callable[P, R]:
-    """
-    Decorator to log function entry, arguments, and return value at DEBUG level.
-
-    Also adds an Allure step for reporting. Use on methods where tracing is useful
-    for debugging or reporting.
-
-    Example:
-        @traced
-        def my_method(self, x):
-            ...
-
-    Args:
-        func (Callable[P, R]): The function to be decorated.
-        *args (Any): Positional arguments to be passed to the function.
-        **kwargs (Any): Keyword arguments to be passed to the function.
-
-    Returns:
-        Callable[P, R]: The result of the function call.
-    """
-    @wraps(func)
-    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)
-        parameters = list(signature.parameters.keys())
-
-        if parameters and parameters[0] == 'self' and len(args) > 0:
-            instance = args[0]
-            logger = logging.getLogger(f"{instance.__class__.__name__}")
-            logger.debug(
-                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
-                    f"{func.__name__} "
-                    f"{', '.join([str(arg) for arg in args[1:]])}"):
-                result = func(*args, **kwargs)
-
-            if result == instance:
-                logger.debug(f"<<< {func.__name__}")
-            else:
-                logger.debug(f"<<< {func.__name__} {result}")
-
-            return result
-        else:
-            logger = logging.getLogger(func.__name__)
-            logger.debug(f">>> {func.__name__} {args} {kwargs}")
-            result = func(*args, **kwargs)
-            logger.debug(f"<<< {func.__name__} {result}")
-            return result
-
-    return wrapper

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/object_utils.py

@@ -5,8 +5,16 @@
 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
@@ -158,6 +166,7 @@ class ToDictMixin:
         return flat_dict
 
 
+@final
 class SingletonMeta(type):
     """
     Thread-safe singleton metaclass.
@@ -200,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
@@ -227,12 +236,31 @@ 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
+
+    def __get__(self, instance: Any, owner: Any) -> T:
+        return self.fget(owner)

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/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/thread_utils.py

@@ -5,14 +5,56 @@
 import concurrent.futures
 import time
 from datetime import timedelta
+from threading import local
+from typing import Final, Optional, cast
 
-COMMON_EXECUTOR = concurrent.futures.ThreadPoolExecutor()
+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/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.9.dist-info → qa_testing_utils-0.0.11.dist-info}/METADATA

@@ -1,15 +1,15 @@
 Metadata-Version: 2.1
 Name: qa-testing-utils
-Version: 0.0.9
+Version: 0.0.11
 Summary: QA testing utilities
 Author-Email: Adrian Herscu <adrian.herscu@gmail.com>
 License: Apache-2.0
 Requires-Python: >=3.13
-Requires-Dist: pytest==8.3.5
+Requires-Dist: pytest==8.4.0
 Requires-Dist: PyHamcrest==2.1.0
 Requires-Dist: pyfunctional==1.5.0
 Requires-Dist: ppretty==1.3
-Requires-Dist: allure-pytest==2.14.2
+Requires-Dist: allure-pytest==2.14.3
 Requires-Dist: more-itertools==10.7.0
 Requires-Dist: returns==0.25.0
 Description-Content-Type: text/markdown

qa_testing_utils-0.0.11.dist-info/RECORD

@@ -0,0 +1,18 @@
+qa_testing_utils-0.0.11.dist-info/METADATA,sha256=TtxoTs7IaCSVV2hynTF-MQcvIM1vI9DCSmjBECTTTIs,480
+qa_testing_utils-0.0.11.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
+qa_testing_utils-0.0.11.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+qa_testing_utils/__init__.py,sha256=1iHT5E3nkIIl4RwihbpM4K-RGPKlsIY4wPkR0_UTeCk,2436
+qa_testing_utils/_version.py,sha256=BkvGdgIByn5SRGserbTFWSVZfsbl4zCa8iLXMuX-QKg,22
+qa_testing_utils/conftest_helpers.py,sha256=aOtDrTUp18d0Z40FJE0UT4MFvmn_R5ywf8kuWhlK4As,2133
+qa_testing_utils/exception_utils.py,sha256=RHrYDDo5TeZi9LXk8XEl_Eg6s91c8tTua9m2qEuNwwo,1316
+qa_testing_utils/exceptions.py,sha256=_s7es20G9-ET2HeLqU0yhuDAXpnQQs_ecjBmztz94Pk,441
+qa_testing_utils/file_utils.py,sha256=9aPDY03Uw_lMxZ9Zuhovv-ePbVQhqjiEnY4C-8-vqSg,6486
+qa_testing_utils/logger.py,sha256=DwaR31GvA16zJGxF2yQuyNeR-3jUg0M3kb5uoa57b9k,6547
+qa_testing_utils/logging.ini,sha256=ZcCKCnUiRl3IVB0ZK9fe79PsAXEMag7QwRpxmO4yBHE,834
+qa_testing_utils/matchers.py,sha256=H8SEs-JCqP_ZoPZdJDddMOxYZ9IshWB_zedLM1wVkWI,13030
+qa_testing_utils/object_utils.py,sha256=yj_mng4sFZEhzX1pJbFXd3xAbA_tinCAfGvP4Tv4qGU,7898
+qa_testing_utils/stream_utils.py,sha256=1dxDL89ZJE-_UeQSX4p3xLnHqUvZHxP-SvG2roWtUjo,1535
+qa_testing_utils/string_utils.py,sha256=0ojTg65To8ibNDpqdGFUoAW7veZUDs2qSayuwWvpuFA,2714
+qa_testing_utils/thread_utils.py,sha256=koOi8aFBQlXDjj_eV_sNM9c5brPJtjQKRP2kY_M5rac,1577
+qa_testing_utils/tuple_utils.py,sha256=0BbvlzeQFjlSuNvBTi92ybCj2Qxk3RO7l06n5BJ3TVI,2416
+qa_testing_utils-0.0.11.dist-info/RECORD,,

qa_testing_utils-0.0.9.dist-info/RECORD

@@ -1,17 +0,0 @@
-qa_testing_utils-0.0.9.dist-info/METADATA,sha256=FEqqeR5_qM1chBwuVr-RtgDyGg3TptUXtK5OLWpqFpU,479
-qa_testing_utils-0.0.9.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
-qa_testing_utils-0.0.9.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
-qa_testing_utils/__init__.py,sha256=lZoBoCrPmDHiztV57wRru9CSJWCzBJ4qzAHBIoqWxZQ,21
-qa_testing_utils/conftest_helpers.py,sha256=Hcpbc1CFNANFfVDyu9Elf5TB5tX4zSHzHSrRhlsHGsM,1408
-qa_testing_utils/exception_utils.py,sha256=iPa-EE1gvKLxzEB3KzNMWGHaS7xEH_B3Yxd8KWiMROA,1340
-qa_testing_utils/exceptions.py,sha256=_s7es20G9-ET2HeLqU0yhuDAXpnQQs_ecjBmztz94Pk,441
-qa_testing_utils/file_utils.py,sha256=a6VPIbSZQVuOEnrprzlj-YTtfMskNzuClnhECRN2CPw,6444
-qa_testing_utils/logger.py,sha256=840RhoO5AHewqEBNa6A2WbWb8DF-AFrasMPDSPH6JNM,4625
-qa_testing_utils/logging.ini,sha256=ZcCKCnUiRl3IVB0ZK9fe79PsAXEMag7QwRpxmO4yBHE,834
-qa_testing_utils/matchers.py,sha256=WOPqtCPt5tFdn6JpyDDqPfPSHQvRMpv0uXCv6-2IqNE,12558
-qa_testing_utils/object_utils.py,sha256=CNbRVB3RAmjeGDRQe9cDsSF_iuZY6vENvZj2pwB_mS0,7393
-qa_testing_utils/stream_utils.py,sha256=zYa2UDfrWsXwRP6nrG87uGkkUZPBLATHXBgu7GUk3Aw,1536
-qa_testing_utils/string_utils.py,sha256=tU1VfmzcS_Zqj4hqzdr6kWdM5dpdlRhiBNiwJAbBDVg,2617
-qa_testing_utils/thread_utils.py,sha256=3Ecyg-bnkcPyT_r9xVWS79uv1BTgXxeIJJZhT3tXorM,416
-qa_testing_utils/tuple_utils.py,sha256=pIcJntr-PNvaOIP0Pv4sBwO7oIbTVFmGwr9Ic5nJDA0,1851
-qa_testing_utils-0.0.9.dist-info/RECORD,,