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

qa_testing_utils/__init__.py

@@ -1 +1,88 @@
-__version__ = '0.0.10'
+# 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

@@ -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/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

@@ -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/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

@@ -3,17 +3,21 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import concurrent.futures
-from threading import local
 import time
 from datetime import timedelta
-from typing import cast
+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.
     """
@@ -21,12 +25,36 @@ def sleep_for(duration: timedelta):
 
 
 class ThreadLocal[T]:
-    def __init__(self, default: 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.10.dist-info → qa_testing_utils-0.0.11.dist-info}/METADATA

@@ -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.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.10.dist-info/RECORD

@@ -1,17 +0,0 @@
-qa_testing_utils-0.0.10.dist-info/METADATA,sha256=mz_7SpeT4TUL3rGDpNvD9ZuT8RQsJiKLcz-R_4fvuLs,480
-qa_testing_utils-0.0.10.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
-qa_testing_utils-0.0.10.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
-qa_testing_utils/__init__.py,sha256=r2Dgx1vmkvInceHz-V7SeB1ZwQnQHbcShDPVM9grMpw,22
-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=oOwYIKEXphFfjDW_vF_CTZhQOwr30UW4GAaFQtMS8V0,5822
-qa_testing_utils/logging.ini,sha256=ZcCKCnUiRl3IVB0ZK9fe79PsAXEMag7QwRpxmO4yBHE,834
-qa_testing_utils/matchers.py,sha256=WOPqtCPt5tFdn6JpyDDqPfPSHQvRMpv0uXCv6-2IqNE,12558
-qa_testing_utils/object_utils.py,sha256=xeh0bO1xoqo55dsx272_qTcKGx-DuirK0FWpdC5XmfY,7623
-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=h9h0ocUV1aBkl6pAqgWtLrTH94db_umjBkXLrtok4xE,733
-qa_testing_utils/tuple_utils.py,sha256=pIcJntr-PNvaOIP0Pv4sBwO7oIbTVFmGwr9Ic5nJDA0,1851
-qa_testing_utils-0.0.10.dist-info/RECORD,,