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

qa_testing_utils/__init__.py

@@ -1 +1 @@
-__version__ = '0.0.7'
+__version__ = '0.0.9'

qa_testing_utils/conftest_helpers.py

@@ -0,0 +1,47 @@
+# SPDX-FileCopyrightText: 2025 Adrian Herscu
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import inspect
+import logging.config
+from pathlib import Path
+import sys
+from typing import Callable, Optional
+
+import pytest
+
+
+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.
+    """
+    caller_module = inspect.getmodule(inspect.stack()[1][0])
+    module_name = caller_module.__name__ if caller_module else "unknown"
+
+    if path.is_file():
+        logging.config.fileConfig(path)
+        logging.info(f"{module_name} loaded logs config from: {path}")
+    else:
+        sys.stderr.write(f"{module_name} couldn't find logs config file {path}")
+
+
+def makereport(
+        item: pytest.Item, call: pytest.CallInfo[None]) -> pytest.TestReport:
+    report = pytest.TestReport.from_item_and_call(item, call)
+
+    if call.when == "call":
+        report.sections.append(('body', get_test_body(item)))
+
+    return report
+
+
+def get_test_body(item: pytest.Item) -> str:
+    function: Optional[Callable[..., None]] = getattr(item, 'function', None)
+    if function is None:
+        return "No function found for this test item."
+
+    try:
+        return inspect.getsource(function)
+    except Exception as e:
+        return f"Could not get source code: {str(e)}"

qa_testing_utils/exception_utils.py

@@ -7,7 +7,7 @@ import logging
 from typing import Any, Callable
 
 from returns.maybe import Maybe, Nothing, Some
-from qa_testing_utils.object_utils import Supplier
+from qa_testing_utils.stream_utils import Supplier
 
 
 def safely[T](supplier: Supplier[T]) -> Maybe[T]:

qa_testing_utils/file_utils.py

@@ -88,7 +88,7 @@ def stream_file(
         Iterator[bytes]: the binary chunks stream
     """
     with file_path.open('rb') as f:
-        yield from iter(lambda: f.read(chunk_size), EMPTY_BYTE_STRING)
+        yield from iter(lambda: f.read(chunk_size), EMPTY_BYTES)
 
 
 def read_lines(
@@ -180,7 +180,7 @@ def crc32_of(file: BinaryIO, chunk_size: int = DEFAULT_BUFFER_SIZE) -> int:
     return crc_value & 0xFFFFFFFF  # ensure 32-bit unsigned
 
 
-def write_csv(file_path: Path, data_stream: Iterable[dict]):
+def write_csv(file_path: Path, data_stream: Iterable[dict[str, object]]):
     """
     Writes a stream of flattened telemetry packets to a CSV file.
 
@@ -189,8 +189,13 @@ def write_csv(file_path: Path, data_stream: Iterable[dict]):
         data_stream: Iterable of dictionaries representing the rows to be written.
     """
     stream = peekable(data_stream)  # Allow peeking to extract headers
+    try:
+        first_row: dict[str, object] = stream.peek()
+    except StopIteration:
+        # No data to write
+        return
     with file_path.open(mode="w", newline="") as csv_file:
         writer = csv.DictWriter(
-            csv_file, fieldnames=list(stream.peek().keys()))
+            csv_file, fieldnames=list(first_row.keys()))
         writer.writeheader()
         writer.writerows(stream)

qa_testing_utils/logger.py

@@ -8,7 +8,7 @@ from functools import cached_property, wraps
 from typing import Callable, ParamSpec, TypeVar, cast, final
 
 import allure
-from qa_testing_utils.string_utils import EMPTY, LF
+from qa_testing_utils.string_utils import EMPTY_STRING, LF
 
 
 def trace[T](value: T) -> T:
@@ -55,7 +55,15 @@ def logger[T:type](cls: T) -> T:
 
 class LoggerMixin:
     """
-    Yet another way of adding logging by deriving from this one.
+    Mixin that provides a `log` property for convenient class-based logging.
+
+    Inherit from this mixin to get a `self.log` logger named after the class.
+    Useful for adding debug/info/error logging to any class without boilerplate.
+
+    Example:
+        class MyClass(LoggerMixin):
+            def do_something(self):
+                self.log.info("Doing something")
     """
     @final
     @cached_property
@@ -91,8 +99,15 @@ R = TypeVar('R')
 
 def traced(func: Callable[P, R]) -> Callable[P, R]:
     """
-    Method decorator that logs the function call with its arguments and the
-    return value.
+    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.
@@ -117,7 +132,7 @@ def traced(func: Callable[P, R]) -> Callable[P, R]:
                 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}")
+                    for key, value in kwargs.items()) if kwargs else EMPTY_STRING}")
 
             with allure.step(  # type: ignore
                     f"{func.__name__} "

qa_testing_utils/logging.ini

@@ -0,0 +1,35 @@
+; SPDX-FileCopyrightText: 2025 Adrian Herscu
+;
+; SPDX-License-Identifier: Apache-2.0
+
+[handlers]
+; NOTE: each key here must have a handler_xxx section below
+keys=console,overwrite_file
+
+[handler_console]
+class=StreamHandler
+level=DEBUG
+formatter=time_level_thread_name_message
+args=(sys.stdout,)
+
+[handler_overwrite_file]
+class=FileHandler
+level=DEBUG
+formatter=time_level_thread_name_message
+args=('pytest.log', 'w')
+
+[formatters]
+; NOTE: each key here must have a formatter_xxx section below
+keys=time_level_thread_name_message
+
+[formatter_time_level_thread_name_message]
+format=%(asctime)s [%(levelname)-1.1s] [%(threadName)-10.10s]: %(name)-14.14s - %(message)s
+; NOTE don't need milliseconds meanwhile, otherwise append .%03d below
+datefmt=%H:%M:%S
+
+[loggers]
+keys=root
+
+[logger_root]
+level=DEBUG
+handlers=console,overwrite_file

qa_testing_utils/matchers.py

@@ -56,6 +56,15 @@ class ContainsStringIgnoringCase(BaseMatcher[str]):
 
 
 def contains_string_ignoring_case(substring: str) -> ContainsStringIgnoringCase:
+    """
+    Creates a matcher that checks if a given string contains the specified substring, ignoring case.
+
+    Args:
+        substring (str): The substring to search for within the target string, case-insensitively.
+
+    Returns:
+        ContainsStringIgnoringCase: A matcher object that evaluates whether the target string contains the specified substring, ignoring case.
+    """
     return ContainsStringIgnoringCase(substring)
 
 
@@ -70,12 +79,11 @@ class IsIteratorYielding[T](BaseMatcher[Iterator[T]]):
 
     @override
     def _matches(self, item: Iterable[T]) -> bool:
-        try:
-            for element in item:
-                if self.element_matcher.matches(element):
-                    return True
-        except TypeError:  # not an iterator
-            pass
+        for element in item:
+            if self.element_matcher.matches(element):
+                return True
+
+        # No matching element found
         return False
 
     @override
@@ -97,14 +105,12 @@ class IsStreamContainingEvery[T](BaseMatcher[Iterator[T]]):
 
     @override
     def _matches(self, item: Iterable[T]) -> bool:
-        try:
-            for element in item:
-                if not self.element_matcher.matches(element):
-                    return False  # One non-matching element means failure
-            return True  # All elements matched
-        except TypeError:  # not an iterator
-            pass
-        return False
+        for element in item:
+            if not self.element_matcher.matches(element):
+                return False  # One non-matching element means failure
+
+        # All elements matched
+        return True
 
     @override
     def describe_to(self, description: Description) -> None:
@@ -124,14 +130,12 @@ class IsIteratorYieldingAll[T](BaseMatcher[Iterator[T]]):
     @override
     def _matches(self, item: Iterable[T]) -> bool:
         unmatched_matchers = set(self.element_matchers)
-        try:
-            for element in item:
-                unmatched_matchers = {
-                    m for m in unmatched_matchers if not m.matches(element)}
-                if not unmatched_matchers:  # All matchers have been satisfied
-                    return True
-        except TypeError:  # not an iterator
-            pass
+        for element in item:
+            unmatched_matchers = {
+                m for m in unmatched_matchers if not m.matches(element)}
+            if not unmatched_matchers:  # All matchers have been satisfied
+                return True
+
         return False
 
     @override
@@ -154,38 +158,31 @@ class IsWithinDates(BaseMatcher[DateOrDateTime]):
         self.end_date = end_date
 
     def _matches(self, item: Optional[DateOrDateTime]) -> bool:
-        if not isinstance(item, (date, datetime)):
+        if item is None:
             return False
 
-        # Convert item to a consistent type for comparison
-        if isinstance(item, datetime):
-            item = item.date() if isinstance(
-                self.start_date, date) or isinstance(
-                self.end_date, date) else item
-        elif isinstance(item, date) and (isinstance(self.start_date, datetime) or isinstance(self.end_date, datetime)):
+        # Normalize item to datetime
+        if not isinstance(item, datetime):
             item = datetime.combine(item, datetime.min.time())
 
-        # Convert start_date and end_date to compatible types if they are not None
-        start = self.start_date
-        if start is not None:
-            start = start.date() if isinstance(
-                start, datetime) and isinstance(item, date) else start
+        # Normalize start_date and end_date to datetime
+        def to_datetime(value: Optional[DateOrDateTime]) -> Optional[datetime]:
+            if value is None:
+                return None
+            return value if isinstance(
+                value, datetime) else datetime.combine(
+                value, datetime.min.time())
 
-        end = self.end_date
-        if end is not None:
-            end = end.date() if isinstance(
-                end, datetime) and isinstance(
-                item, date) else end
+        start = to_datetime(self.start_date)
+        end = to_datetime(self.end_date)
 
-        # Perform the comparison, handling open-ended ranges
-        if start is None and end is not None:
-            return item <= end
-        elif start is not None and end is None:
-            return item >= start
-        elif start is not None and end is not None:
+        if start and end:
             return start <= item <= end
+        if start:
+            return item >= start
+        if end:
+            return item <= end
 
-        # If both start_date and end_date are None, return False (no valid range)
         return False
 
     def describe_to(self, description: Description) -> None:
@@ -201,6 +198,16 @@ class IsWithinDates(BaseMatcher[DateOrDateTime]):
 def within_dates(
         start_date: Optional[DateOrDateTime],
         end_date: Optional[DateOrDateTime]) -> IsWithinDates:
+    """
+    Creates an instance of IsWithinDates to check if a date or datetime value falls within the specified start and end dates.
+
+    Args:
+        start_date (Optional[DateOrDateTime]): The start of the date range. Can be None to indicate no lower bound.
+        end_date (Optional[DateOrDateTime]): The end of the date range. Can be None to indicate no upper bound.
+
+    Returns:
+        IsWithinDates: An instance configured with the provided start and end dates.
+    """
     return IsWithinDates(start_date, end_date)
 
 

qa_testing_utils/object_utils.py

@@ -5,13 +5,11 @@
 import threading
 from dataclasses import asdict, fields, is_dataclass, replace
 from enum import Enum
-from typing import (Any, Callable, Dict, Protocol, Type, final)
-
-# TODO: move to stream_utils module
-type Supplier[T] = Callable[[], T]
-type Predicate[T] = Callable[[T], bool]
+from typing import (Any, Dict, Optional, Protocol,
+                    final, runtime_checkable, ClassVar)
 
 
+@runtime_checkable
 class Valid(Protocol):
     """
     Specifies a method for validating objects.
@@ -29,15 +27,20 @@ class Valid(Protocol):
 
 class ImmutableMixin:
     """
-    Enforces immutability by overriding __setattr__ to raise AttributeError.
+    Mixin to enforce immutability after initialization.
 
-    This implementation does not work with the WithMixin if the attributes are
-    initialized with default values.
+    Overrides __setattr__ to raise AttributeError if an attribute is modified after being set.
+    Intended for use with non-dataclasses. For dataclasses, use `@dataclass(frozen=True)`.
 
-    It also does not work when applied to a super type for which the __init__
-    is overridden.
+    Limitations:
+        - Does not work with WithMixin if attributes have default values.
+        - Does not work if applied to a superclass with a custom __init__.
 
-    Use it with non-dataclasses.
+    Example:
+        class MyImmutable(ImmutableMixin):
+            foo: int = 1
+        obj = MyImmutable()
+        obj.foo = 2  # Raises AttributeError
     """
 
     def __setattr__(self, key: str, value: Any) -> None:
@@ -49,19 +52,21 @@ class ImmutableMixin:
 
 class WithMixin:
     '''
-    Supports immutability by copying on change.
-
-    For example, instead of mutating like this::
+    Mixin to support copy-on-change (functional update) for objects.
 
-        obj.field = a_new_value
+    Instead of mutating an object, use `with_()` to create a copy with updated fields:
+        obj2 = obj.with_(field=new_value)
 
-    use::
+    Works with both plain Python classes and dataclasses.
 
-        dup_object_with_changes = obj.with_(field=a_new_value)
+    Example:
+        @dataclass(frozen=True)
+        class Point(WithMixin):
+            x: int
+            y: int
 
-    This will ensure that the changes are applied on a duplicate of `obj`.
-
-    Can be applied on plain Python classes, and on `dataclases` too.
+        p1 = Point(1, 2)
+        p2 = p1.with_(x=3)  # p2 is Point(3, 2)
     '''
     @final
     def with_[T:WithMixin](self: T, **changes: Any) -> T:
@@ -82,18 +87,37 @@ class WithMixin:
 
 
 class ToDictMixin:
+    """
+    Mixin to add serialization methods to dataclasses.
+
+    Provides:
+        - to_dict(): Recursively converts a dataclass (and nested dataclasses) to a dictionary.
+        - flatten(): Flattens nested structure for CSV or flat serialization.
+
+    Example:
+        @dataclass
+        class User(ToDictMixin):
+            name: str
+            age: int
+
+        user = User("Alice", 30)
+        user.to_dict()  # {'name': 'Alice', 'age': 30}
+    """
 
     def to_dict(self) -> Dict[str, Any]:
         """
         Converts a dataclass instance (with nested dataclasses) to a dictionary.
         """
-        def convert(value):
+        from typing import cast
+
+        def convert(value: Any) -> Any:
             if isinstance(value, ToDictMixin):
                 return value.to_dict()
             elif isinstance(value, list):
-                return [convert(v) for v in value]
+                # Provide a type hint for v
+                return [convert(v) for v in cast(list[Any], value)]
             elif isinstance(value, dict):
-                return {k: convert(v) for k, v in value.items()}
+                return {k: convert(v) for k, v in value.items()}  # type: ignore
             return value
 
         if not is_dataclass(self):
@@ -105,20 +129,20 @@ class ToDictMixin:
         """
         Flattens the nested structure into a flat dictionary for CSV serialization.
         """
-        flat_dict = {}
+        flat_dict: Dict[str, Any] = {}
 
-        def flatten_value(key: str, value: Any):
+        def flatten_value(key: str, value: Any) -> None:
             if isinstance(value, ToDictMixin):
                 # Flatten nested ToDictMixin dataclasses
                 nested_flat = value.flatten(prefix=f"{key}_")
                 flat_dict.update(nested_flat)
             elif isinstance(value, list):
                 # Serialize lists as JSON strings or expand into multiple columns
-                for idx, item in enumerate(value):
+                for idx, item in enumerate(value):  # type: ignore
                     flat_dict[f"{key}[{idx}]"] = item
             elif isinstance(value, dict):
                 # Serialize dicts as JSON strings or expand into multiple columns
-                for sub_key, sub_val in value.items():
+                for sub_key, sub_val in value.items():  # type: ignore
                     flat_dict[f"{key}_{sub_key}"] = sub_val
             else:
                 # Directly add non-nested fields
@@ -136,27 +160,41 @@ class ToDictMixin:
 
 class SingletonMeta(type):
     """
-    A thread-safe implementation of a Singleton metaclass.
+    Thread-safe singleton metaclass.
+
+    Ensures only one instance of a class exists per process.
+    Use by setting `metaclass=SingletonMeta` on your class.
     """
-    _instances: Dict[Type['SingletonBase'], 'SingletonBase'] = {}
-    _lock: threading.Lock = threading.Lock()  # Ensure thread-safety
+    _instances: ClassVar[Dict[type, object]] = {}
+    _lock: ClassVar[threading.Lock] = threading.Lock()  # Ensure thread-safety
 
-    def __call__(cls, *args: Any, **kwargs: Any) -> 'SingletonBase':
+    def __call__(
+            cls: type,
+            *args: Any, **kwargs: Any) -> "SingletonBase":
         with SingletonMeta._lock:
             if cls not in SingletonMeta._instances:
-                instance = super().__call__(*args, **kwargs)
+                instance = super().__call__(*args, **kwargs)  # type: ignore
                 SingletonMeta._instances[cls] = instance
-        return SingletonMeta._instances[cls]
+        return SingletonMeta._instances[cls]  # type: ignore[return-value]
 
 
 class SingletonBase(metaclass=SingletonMeta):
     """
     Base class for singletons using SingletonMeta.
+
+    Inherit from this class to make your class a singleton.
     """
     pass
 
 
 class InvalidValueException(ValueError):
+    """
+    Raised when an object fails validation via the Valid protocol.
+
+    Example:
+        if not obj.is_valid():
+            raise InvalidValueException(obj)
+    """
     pass
 
 
@@ -168,18 +206,33 @@ def valid[T:Valid](value: T) -> T:
         value (T:Valid): the object
 
     Raises:
-        TypeError: if the object does not support the Valid protocol
         InvalidValueException: if the object is invalid
 
     Returns:
         T:Valid: the validated object
     """
-    if not (hasattr(value, 'is_valid') and callable(
-            getattr(value, 'is_valid'))):
-        raise TypeError(
-            f"{value.__class__.__name__} does not conform to the Valid protocol")
-
     if value.is_valid():
         return value
-    else:
-        raise InvalidValueException(value)
+
+    raise InvalidValueException(value)
+
+
+def require_not_none[T](
+        value: Optional[T],
+        message: str = "Value must not be None") -> T:
+    """
+    Ensures that the provided value is not None.
+
+    Args:
+        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.
+    """
+    if value is None:
+        raise ValueError(message)
+    return value

qa_testing_utils/stream_utils.py

@@ -2,16 +2,43 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import Iterator
+from typing import Callable, Iterator
 
-from qa_testing_utils.object_utils import Predicate
+
+"""
+A generic callable type alias representing a supplier of values of type T.
+
+A Supplier is a function that takes no arguments and returns a value of type T.
+This is useful for lazy evaluation, deferred computation, or providing values on demand.
+
+Example:
+    def random_int_supplier() -> int:
+        import random
+        return random.randint(1, 100)
+
+    supplier: Supplier[int] = random_int_supplier
+"""
+type Supplier[T] = Callable[[], T]
+
+"""
+A generic callable type alias representing a predicate (boolean-valued function) over values of type T.
+
+A Predicate is a function that takes a single argument of type T and returns a boolean.
+It is commonly used for filtering, validation, or conditional logic.
+
+Example:
+    def is_even(n: int) -> bool:
+        return n % 2 == 0
+
+    even_predicate: Predicate[int] = is_even
+"""
+type Predicate[T] = Callable[[T], bool]
 
 
 def process_next[T](i: Iterator[T], p: Predicate[T]) -> Iterator[T]:
-    # DELETEME -- not needed so far
     """
-    Processes next items per specified predicate. Useful, for cases in which
-    first item in a stream decides the meaning of rest of items.
+    Processes next items per specified predicate. Useful for cases in which
+    the first item in a stream decides the meaning of the rest of the items.
 
     Args:
         i (Iterator[T]): the iterator to process

qa_testing_utils/string_utils.py

@@ -6,12 +6,12 @@ from typing import Callable, Type
 
 from ppretty import ppretty  # type: ignore
 
-EMPTY = ""
+EMPTY_STRING = ""
 SPACE = " "
 DOT = "."
 LF = "\n"
 UTF_8 = "utf-8"
-EMPTY_BYTE_STRING = b''
+EMPTY_BYTES = b''
 
 
 def to_string[T](indent: str = '    ',

qa_testing_utils/thread_utils.py

@@ -10,4 +10,9 @@ 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())

{qa_testing_utils-0.0.7.dist-info → qa_testing_utils-0.0.9.dist-info}/METADATA

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

qa_testing_utils-0.0.9.dist-info/RECORD

@@ -0,0 +1,17 @@
+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,,

qa_testing_utils-0.0.7.dist-info/RECORD

@@ -1,15 +0,0 @@
-qa_testing_utils-0.0.7.dist-info/METADATA,sha256=bxP3fCjJCJTkV3YtRfd6Mbwp_v3UlsFekYcqBo3a-cQ,479
-qa_testing_utils-0.0.7.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
-qa_testing_utils-0.0.7.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
-qa_testing_utils/__init__.py,sha256=7sNbee72r3qCAVloFm2RRWCTa9gVjMS7nCJcJ-URzl4,21
-qa_testing_utils/exception_utils.py,sha256=fQ1UtFJg5SHEc2XhH8NHHX6aY7btkauKHQKhfr_1jQI,1340
-qa_testing_utils/exceptions.py,sha256=_s7es20G9-ET2HeLqU0yhuDAXpnQQs_ecjBmztz94Pk,441
-qa_testing_utils/file_utils.py,sha256=LGZBB6xqadpEpqY4HXKcrxCj2D3OCzyvGvZsCk6NQus,6311
-qa_testing_utils/logger.py,sha256=bWmJrPyHmg6sA_Qmjk-Guxwoa4g2VfulcIwRAWFZ5d8,4123
-qa_testing_utils/matchers.py,sha256=qd-wczEsjvdn1mYfBq7-lvYiW6sUOnQlKJgFiK-6F1I,12510
-qa_testing_utils/object_utils.py,sha256=0CtfGPrR-s9d2OHlOwfzUfWH-NLvS7rwelSvM2mS6Rg,5807
-qa_testing_utils/stream_utils.py,sha256=vIhXY2nO2NjfyLV0Uirw9XJcDlh2DAFJp2RCfQXcHrk,729
-qa_testing_utils/string_utils.py,sha256=L2hRnwnRciaW5rwY_kmuBRb9zC65VPyAGcYt-HnXt18,2616
-qa_testing_utils/thread_utils.py,sha256=73oW55OAJNqoZ-6y7B7te07CLLT4y-9sQJ831fcWpUk,293
-qa_testing_utils/tuple_utils.py,sha256=pIcJntr-PNvaOIP0Pv4sBwO7oIbTVFmGwr9Ic5nJDA0,1851
-qa_testing_utils-0.0.7.dist-info/RECORD,,