testit-python-commons 4.2.8__py3-none-any.whl

testit_python_commons/services/utils.py

@@ -0,0 +1,132 @@
+import inspect
+import logging
+import re
+import warnings
+from typing import TYPE_CHECKING
+
+from testit_python_commons.models.link import Link
+from testit_python_commons.models.link_type import LinkType
+from testit_python_commons.services.logger import adapter_logger
+
+if TYPE_CHECKING:
+    from testit_python_commons.models.link import Link
+
+
+class Utils:
+    @staticmethod
+    def uuid_check(uuid: str):
+        if not re.fullmatch(r'[a-zA-Z0-9]{8}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{12}', uuid):
+            logging.error(f'The wrong {uuid}!')
+            raise SystemExit
+
+        return uuid
+
+    @staticmethod
+    def url_check(url: str):
+        if not re.fullmatch(
+                r"^(ht|f)tp(s?)\:\/\/[0-9a-zA-Z]([-.\w]*[0-9a-zA-Z])*(:(0-9)*)*(\/?)"
+                r"([a-zA-Z0-9\-\.\?\,\'\/\\\+&%\$#_]*)?$",
+                url):
+            logging.error('The wrong URL!')
+            raise SystemExit
+
+        if url[-1] == '/':
+            return url[:-1]
+
+        return url
+
+    @staticmethod
+    def deprecated(message):
+        def deprecated_decorator(func):  # noqa: N802
+            def deprecated_func(*args, **kwargs):
+                warnings.warn(
+                    '"{}" is deprecated.\n{}'.format(func.__name__, message),
+                    category=DeprecationWarning,
+                    stacklevel=2)
+                warnings.simplefilter('default', DeprecationWarning)
+                return func(*args, **kwargs)
+
+            return deprecated_func
+
+        return deprecated_decorator
+
+    @staticmethod
+    def get_function_parameters(function, *args, **kwargs):
+        parameters = {}
+        args_default_values = inspect.getfullargspec(function).defaults
+
+        if args or args_default_values:
+            all_keys = inspect.getfullargspec(function).args
+            all_args = list(args)
+
+            if args_default_values:
+                all_args += list(args_default_values[len(args) - (len(all_keys) - len(args_default_values)):])
+
+            method_args = [arg_name for arg_name in all_keys if arg_name not in list(kwargs)]
+
+            if len(method_args) == len(all_args):
+                for index in range(0, len(method_args)):
+                    parameters[method_args[index]] = str(all_args[index])
+
+        if kwargs:
+            for key, parameter in kwargs.items():
+                parameters[key] = str(parameter)
+
+        return parameters
+
+    @staticmethod
+    def exclude_self_parameter(all_parameters: dict) -> dict:
+        if all_parameters.get('self') is not None:
+            all_parameters.pop('self')
+        return all_parameters
+
+    @staticmethod
+    def collect_parameters_in_string_attribute(attribute: str, all_parameters: dict) -> str:
+        param_keys = []
+
+        if attribute:
+            param_keys = re.findall(r"\{(.*?)\}", attribute)
+
+        if len(param_keys) > 0:
+            for param_key in param_keys:
+                parameter = all_parameters.get(param_key)
+
+                if parameter is not None:
+                    attribute = attribute.replace("{" + param_key + "}", str(parameter))
+
+        return attribute
+
+    @staticmethod
+    @adapter_logger
+    def convert_link_dict_to_link_model(link_dict: dict) -> "Link":
+        from testit_python_commons.models.link import Link
+
+        link_model = Link()
+        link_model.set_url(link_dict['url'])
+
+        if 'title' in link_dict:
+            link_model.set_title(link_dict['title'])
+
+        if 'type' in link_dict:
+            link_model.set_link_type(link_dict.get('type', LinkType.RELATED))
+
+        if 'description' in link_dict:
+            link_model.set_description(link_dict['description'])
+
+        return link_model
+
+    @staticmethod
+    @adapter_logger
+    def convert_body_of_attachment(body):
+        if isinstance(body, bytes):
+            return body
+
+        return str(body).encode('utf-8')
+
+    @staticmethod
+    @adapter_logger
+    def convert_value_str_to_bool(value: str) -> bool:
+        if value:
+            return value == 'true'
+
+        return False

testit_python_commons/step.py

@@ -0,0 +1,101 @@
+from datetime import datetime
+import logging
+from functools import wraps
+from typing import Any, Callable, TypeVar
+
+from testit_python_commons.models.step_result import StepResult
+from testit_python_commons.services import (
+    TmsPluginManager,
+    Utils
+)
+
+
+Func = TypeVar("Func", bound=Callable[..., Any])
+
+
+# if we return title: "", it will be replaced to
+# step name in fact later
+def step(*args, **kwargs):
+    if len(args) == 0:
+        return StepContext("", None, {})
+
+    if callable(args[0]):
+        function = args[0]
+        return StepContext(function.__name__, None, {})(function)
+    else:
+        title = get_title(args, kwargs)
+        description = get_description(args, kwargs)
+
+        return StepContext(title, description, {})
+
+
+def get_title(args: tuple, kwargs: dict):
+    if 'title' in kwargs:
+        return kwargs['title']
+
+    if len(args) > 0:
+        if isinstance(args[0], str):
+            return args[0]
+
+        logging.error(f'Cannot to get step title: {args[1]}. The title must be of string type.')
+
+
+def get_description(args: tuple, kwargs: dict):
+    if 'description' in kwargs:
+        return kwargs['description']
+
+    if len(args) > 1:
+        if isinstance(args[1], str):
+            return args[1]
+        logging.error(f'Cannot to get step description: {args[1]}. The description must be of string type.')
+
+
+class StepContext:
+    def __init__(self, title, description, parameters):
+        self.__title = title
+        self.__description = description
+        self.__parameters = parameters
+
+    def __enter__(self):
+        self.__start_time = round(datetime.utcnow().timestamp() * 1000)
+        self.__step_result = StepResult()
+
+        self.__title = Utils.collect_parameters_in_string_attribute(self.__title, self.__parameters)
+        self.__description = Utils.collect_parameters_in_string_attribute(self.__description, self.__parameters)
+
+        self.__step_result\
+            .set_title(self.__title)\
+            .set_description(self.__description)\
+            .set_parameters(
+                Utils.exclude_self_parameter(self.__parameters)
+            )
+
+        logging.debug(f'Step "{self.__title}" was started')
+
+        TmsPluginManager.get_step_manager().start_step(self.__step_result)
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        outcome = 'Failed' if exc_type \
+            else TmsPluginManager.get_plugin_manager().hook.get_pytest_check_outcome()[0] if \
+            hasattr(TmsPluginManager.get_plugin_manager().hook, 'get_pytest_check_outcome') \
+            else 'Passed'
+        duration = round(datetime.utcnow().timestamp() * 1000) - self.__start_time
+
+        self.__step_result\
+            .set_outcome(outcome)\
+            .set_duration(duration)
+
+        TmsPluginManager.get_step_manager().stop_step()
+
+    def __call__(self, function: Func) -> Func:
+        @wraps(function)
+        def impl(*args, **kwargs):
+            __tracebackhide__ = True
+            parameters = Utils.get_function_parameters(function, *args, **kwargs)
+
+            title = self.__title if self.__title else function.__name__
+
+            with StepContext(title, self.__description, parameters):
+                return function(*args, **kwargs)
+
+        return impl

testit_python_commons/utils/__init__.py

@@ -0,0 +1,3 @@
+from .html_escape_utils import HtmlEscapeUtils
+
+__all__ = ['HtmlEscapeUtils'] 

testit_python_commons/utils/html_escape_utils.py

@@ -0,0 +1,219 @@
+import os
+import re
+import logging
+from typing import Any, List, Optional, Union
+from datetime import datetime, date, time, timedelta
+from decimal import Decimal
+from uuid import UUID
+
+
+class HtmlEscapeUtils:
+    """
+    HTML escape utilities for preventing XSS attacks.
+    Escapes HTML tags in strings and objects using reflection.
+    """
+    
+    NO_ESCAPE_HTML_ENV_VAR = "NO_ESCAPE_HTML"
+    
+    # Regex pattern to detect HTML tags (requires at least one non-whitespace character after <)
+    # This ensures empty <> brackets are not considered HTML tags
+    _HTML_TAG_PATTERN = re.compile(r'<\S.*?(?:>|/>)')
+    
+    # Regex patterns to escape only non-escaped characters
+    # Using negative lookbehind to avoid double escaping
+    _LESS_THAN_PATTERN = re.compile('<')
+    _GREATER_THAN_PATTERN = re.compile('>')
+    
+    @staticmethod
+    def escape_html_tags(text: Optional[str]) -> Optional[str]:
+        """
+        Escapes HTML tags to prevent XSS attacks.
+        First checks if the string contains HTML tags using regex pattern.
+        Only performs escaping if HTML tags are detected.
+        Escapes all < as \\< and > as \\> only if they are not already escaped.
+        Uses regex with negative lookbehind to avoid double escaping.
+        
+        Args:
+            text: The text to escape
+            
+        Returns:
+            Escaped text or original text if escaping is disabled
+        """
+        if text is None:
+            return None
+            
+        # Check if escaping is disabled via environment variable
+        no_escape_html = os.environ.get(HtmlEscapeUtils.NO_ESCAPE_HTML_ENV_VAR, "").lower()
+        if no_escape_html == "true":
+            return text
+            
+        # First check if the string contains HTML tags
+        if not HtmlEscapeUtils._HTML_TAG_PATTERN.search(text):
+            return text  # No HTML tags found, return original string
+            
+        # Use regex with negative lookbehind to escape only non-escaped characters
+        result = HtmlEscapeUtils._LESS_THAN_PATTERN.sub('&lt;', text)
+        result = HtmlEscapeUtils._GREATER_THAN_PATTERN.sub('&gt;', result)
+        
+        return result
+    
+    @staticmethod
+    def escape_html_in_object(obj: Any) -> Any:
+        """
+        Escapes HTML tags in all string attributes of an object using reflection.
+        Also processes list attributes: if list of objects - calls escape_html_in_object_list,
+        if list of strings - escapes each string.
+        Can be disabled by setting NO_ESCAPE_HTML environment variable to "true".
+        
+        Args:
+            obj: The object to process
+            
+        Returns:
+            The processed object with escaped strings
+        """
+        if obj is None:
+            return None
+            
+        # Check if escaping is disabled via environment variable
+        no_escape_html = os.environ.get(HtmlEscapeUtils.NO_ESCAPE_HTML_ENV_VAR, "").lower()
+        if no_escape_html == "true":
+            return obj
+            
+        try:
+            HtmlEscapeUtils._process_object_attributes(obj)
+        except Exception as e:
+            # Silently ignore reflection errors
+            logging.debug(f"Error processing object attributes: {e}")
+            
+        return obj
+    
+    @staticmethod
+    def escape_html_in_object_list(obj_list: Optional[List[Any]]) -> Optional[List[Any]]:
+        """
+        Escapes HTML tags in all string attributes of objects in a list using reflection.
+        Can be disabled by setting NO_ESCAPE_HTML environment variable to "true".
+        
+        Args:
+            obj_list: The list of objects to process
+            
+        Returns:
+            The processed list with escaped strings in all objects
+        """
+        if obj_list is None:
+            return None
+            
+        # Check if escaping is disabled via environment variable
+        no_escape_html = os.environ.get(HtmlEscapeUtils.NO_ESCAPE_HTML_ENV_VAR, "").lower()
+        if no_escape_html == "true":
+            return obj_list
+            
+        for obj in obj_list:
+            HtmlEscapeUtils.escape_html_in_object(obj)
+            
+        return obj_list
+    
+    @staticmethod
+    def _process_object_attributes(obj: Any) -> None:
+        """
+        Process all attributes of an object for HTML escaping.
+        """
+        # Handle dictionary-like objects (common in API models)
+        if hasattr(obj, '__dict__'):
+            for attr_name in dir(obj):
+                # Skip private/protected attributes and methods
+                if attr_name.startswith('_') or callable(getattr(obj, attr_name, None)):
+                    continue
+                if (
+                    attr_name.startswith("external_id")
+                    or attr_name.startswith("externalId")
+                    or attr_name.startswith("auto_test_external_id")
+                    or attr_name.startswith("autoTestExternalId")
+                ):
+                    continue
+                    
+                try:
+                    value = getattr(obj, attr_name)
+                    HtmlEscapeUtils._process_attribute_value(obj, attr_name, value)
+                except Exception as e:
+                    # Silently ignore attribute errors
+                    logging.debug(f"Error processing attribute {attr_name}: {e}")
+                    
+        # Handle dictionary objects
+        elif isinstance(obj, dict):
+            for key, value in obj.items():
+                if isinstance(value, str):
+                    obj[key] = HtmlEscapeUtils.escape_html_tags(value)
+                elif isinstance(value, list):
+                    HtmlEscapeUtils._process_list(value)
+                elif not HtmlEscapeUtils._is_simple_type(type(value)):
+                    HtmlEscapeUtils.escape_html_in_object(value)
+    
+    @staticmethod
+    def _process_attribute_value(obj: Any, attr_name: str, value: Any) -> None:
+        """
+        Process a single attribute value for HTML escaping.
+        """
+        if isinstance(value, str):
+            # Escape string attributes
+            try:
+                setattr(obj, attr_name, HtmlEscapeUtils.escape_html_tags(value))
+            except AttributeError:
+                # Attribute might be read-only
+                pass
+        elif isinstance(value, list):
+            HtmlEscapeUtils._process_list(value)
+        elif value is not None and not HtmlEscapeUtils._is_simple_type(type(value)):
+            # Process nested objects (but not simple types)
+            HtmlEscapeUtils.escape_html_in_object(value)
+    
+    @staticmethod
+    def _process_list(lst: List[Any]) -> None:
+        """
+        Process a list for HTML escaping.
+        """
+        if not lst:
+            return
+            
+        first_element = lst[0]
+        
+        if isinstance(first_element, str):
+            # List of strings - escape each string
+            for i, item in enumerate(lst):
+                if isinstance(item, str):
+                    lst[i] = HtmlEscapeUtils.escape_html_tags(item)
+        elif first_element is not None:
+            # List of objects - process each object
+            for item in lst:
+                HtmlEscapeUtils.escape_html_in_object(item)
+    
+    @staticmethod
+    def _is_simple_type(obj_type: type) -> bool:
+        """
+        Checks if a type is a simple type that doesn't need HTML escaping.
+        
+        Args:
+            obj_type: Type to check
+            
+        Returns:
+            True if it's a simple type
+        """
+        simple_types = {
+            # Basic types
+            bool, int, float, complex, bytes, bytearray,
+            # String type (handled separately)
+            str,
+            # Date/time types
+            datetime, date, time, timedelta,
+            # Other common types
+            Decimal, UUID,
+            # None type
+            type(None)
+        }
+        
+        return (
+            obj_type in simple_types or
+            # Check for enums
+            (hasattr(obj_type, '__bases__') and any(
+                base.__name__ == 'Enum' for base in obj_type.__bases__
+            ))
+        ) 

testit_python_commons-4.2.8.dist-info/METADATA

@@ -0,0 +1,52 @@
+Metadata-Version: 2.4
+Name: testit-python-commons
+Version: 4.2.8
+Summary: Python commons for Test IT
+Home-page: https://github.com/testit-tms/adapters-python/
+Author: Integration team
+Author-email: integrations@testit.software
+License: Apache-2.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Description-Content-Type: text/markdown
+Requires-Dist: pluggy
+Requires-Dist: tomli
+Requires-Dist: testit-api-client==7.5.10
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary
+
+# Sync Storage Integration
+
+This library includes built-in support for Sync Storage, enabling coordinated test execution across multiple workers in distributed testing environments.
+
+See [SYNC_STORAGE_INTEGRATION.md](SYNC_STORAGE_INTEGRATION.md) for detailed documentation on how the integration works.
+
+# How to enable debug logging?
+1. Add in **connection_config.ini** file from the root directory of the project:
+```
+[debug]
+__DEV = true
+```
+
+## How to install local modified version?
+```
+cd adapters-python/testit-python-commons
+pip install .
+```
+## How to install version from some branch?
+```
+git+https://github.com/testit-tms/adapters-python.git@develop#subdirectory=testit-python-commons
+```

testit_python_commons-4.2.8.dist-info/RECORD

@@ -0,0 +1,71 @@
+testit.py,sha256=DfWIpqiZdbZV86cKB15RrhP1orXoJA0iwVygrsdzJJk,1196
+api_client_syncstorage/__init__.py,sha256=TMIJrgGlinBK8e0cypc0XKhIC4ct8R_jWRmPMBP1N3A,800
+api_client_syncstorage/api_client.py,sha256=gdOnIiftQhdPO_lcf00TSX3in-JCs-bwj6iS0wOXXxA,39233
+api_client_syncstorage/configuration.py,sha256=bToukJ5xUvtBdmQmW7Gr08t2VPgmOqRqimQQoS43u1c,16352
+api_client_syncstorage/exceptions.py,sha256=3Zyo7lsgd-CSojT0d0VCGzvw5ulCzmUI-rxMkn7WrkI,5068
+api_client_syncstorage/model_utils.py,sha256=yg46dGZOh6Kkikc4QzwYrp2uu17wQQ8ZghFLN-D1_kE,82603
+api_client_syncstorage/rest.py,sha256=qE5FWqE4GTY3ZYfyxcUyl2Kd80zMU5iWBmGfGnlb_MA,14406
+api_client_syncstorage/api/__init__.py,sha256=Zt4IuzQj6ZZTwYv0ByWm6_r85lxI2c50JFC-sfbLVAI,229
+api_client_syncstorage/api/completion_api.py,sha256=APWxrPI_socgRCwPf45tuIVZqFVUxyqvCYuesLDDLpg,10971
+api_client_syncstorage/api/health_api.py,sha256=Ys0tH60sPTRjoIOqNcfvRzmc-zAg8PhAuNccYHFaO7E,5495
+api_client_syncstorage/api/system_api.py,sha256=1TCm34iirvxWHhiltIPn9uAeVwXdt7Ysu7iYwiqrF-E,5488
+api_client_syncstorage/api/test_results_api.py,sha256=TIkd7Qw0sJSX3nmb-UKld2fy8YH6r8Y8aMlblan2RGo,6634
+api_client_syncstorage/api/workers_api.py,sha256=2GZaHh0SwaN8psnoXDigO0WKjquVTqpjL8Hm1q-OrWA,11434
+api_client_syncstorage/apis/__init__.py,sha256=6U-f1CkuYJ4Lbw3zPLOic57M6rMfOogb_Fl7WKWvXOo,762
+api_client_syncstorage/model/__init__.py,sha256=lNQhU3Bvbw-e5SeWD-O5bNV3osq2Oqrrdtgv66_zP2E,356
+api_client_syncstorage/model/completion_response.py,sha256=pDLOFYaRCcae4lKn41946Dz55SCL5he56rf65khQ_oc,11649
+api_client_syncstorage/model/health_status_response.py,sha256=5QdakodopMAkglgAClDlc1GrQ6YTP8UIX68nz36_PZM,11672
+api_client_syncstorage/model/register_request.py,sha256=QypQd9875gu6vDIZnpbfxZtreFcGrxTYb_PPHtOtbVQ,12044
+api_client_syncstorage/model/register_response.py,sha256=bPYwzcmd420iujmD8rPqQGwnzLF4L0SjvF5OCgbgAJk,12215
+api_client_syncstorage/model/set_worker_status_request.py,sha256=PQ3zmajfxm4apHOBeW-XUUCLOPCBjSPCgFOmAdQPPOo,11834
+api_client_syncstorage/model/set_worker_status_response.py,sha256=r1yLLLJHq7_eA5wi3fX0n_PC47hjUn5s2B1eCPBJZ2Q,11646
+api_client_syncstorage/model/shutdown_response.py,sha256=vswOqfTGQUtwGCyVUOkG3NGQwigRoWCW-eiK5mZSB08,11625
+api_client_syncstorage/model/test_result_cut_api_model.py,sha256=DU48FsOjf9Feey9uhx-XI9hTFdfZISTd0OIzSTy3gX0,12405
+api_client_syncstorage/model/test_result_save_response.py,sha256=Q7J6WD6Yzx6TWYOszU-0Qb3IkKRXUYWmvFiRQ3zGzGk,11643
+api_client_syncstorage/models/__init__.py,sha256=-Wa3--s7VgbP9o6_RY33g1lXm5J-1PSqLw7VcpPZsaY,1131
+testit_python_commons/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+testit_python_commons/app_properties.py,sha256=0o7G24OMdcyv7eZUAaZjyvuEp1z9QVVlnDMIra-wXQQ,9891
+testit_python_commons/decorators.py,sha256=QI8qMjDincTRZmcZByP5y5wHsf_Fwd1oc67WuWAacCA,5988
+testit_python_commons/dynamic_methods.py,sha256=WKHHA6Uj61tWXI3DphALYOi2BV6TnQKvQy0-Vt2JR2I,8816
+testit_python_commons/step.py,sha256=CYUs_S8opmRg1tsTY1dVJOPzzt-HYR3_uLTBpYtHSfQ,3244
+testit_python_commons/client/__init__.py,sha256=zSJhxDHzWWTFHJ0s8bqCaBtM5FK2GcPgZxaKdI8zf-o,165
+testit_python_commons/client/api_client.py,sha256=9UWO-4l_nLwhvSjksMdgyB6W4dPaufgjAn-ScQauVbc,22082
+testit_python_commons/client/client_configuration.py,sha256=1M-OrROU3Xj0YGsUX4venG-l6Ewr43LNvUcyFfY57ys,2776
+testit_python_commons/client/converter.py,sha256=R_BYE2qjJIRAuV2bDzlWD3zLbhi2QDTfTRjGVG-vqLw,23966
+testit_python_commons/client/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+testit_python_commons/client/helpers/bulk_autotest_helper.py,sha256=a3vwfdfzzvAnxY0s6o-WHkohKjNwogEAkmU1W81G-Bk,10805
+testit_python_commons/client/helpers/threads_manager.py,sha256=TUJmvem5WMPWjZR-Hl0gzaiE49iRPkkCHNBBIsJbkcE,3507
+testit_python_commons/client/models/__init__.py,sha256=4c3yNkadtebFF1eEZw7JmfwcLtOim2zHkwbZIHvCK0A,284
+testit_python_commons/client/models/threads_for_create_and_result.py,sha256=AsasSnjECjBOgTryk6MqDp2AGHsQd1AfiwL7McAqYa4,1456
+testit_python_commons/client/models/threads_for_update_and_result.py,sha256=IFPQ4YHjzj1eG6W_bSYMm6ic2oGThrliNtW_lKSIiAE,2127
+testit_python_commons/configurations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+testit_python_commons/configurations/properties_names.py,sha256=DcMkFmJuyvRXylLjP3HgJTjiaXsNSJ0ZmQjKYgM1v00,2364
+testit_python_commons/models/__init__.py,sha256=qtwpjoKOOaTCiRHiG0TlOWWQ26AFw7dumt4yV-u0LcE,90
+testit_python_commons/models/adapter_mode.py,sha256=4U3IlRvjoDCe6WJ6AS4HaiP2nS9ntXIMOUmKGKcblWE,87
+testit_python_commons/models/fixture.py,sha256=_KO-sWKHloHY1MFowp1anE3Dp5-ebdUeO8AAsLMNids,661
+testit_python_commons/models/link.py,sha256=7TX7APxgRHMk6OJBGWrkcRs3GOiOcBKV1379PfOIl9k,1258
+testit_python_commons/models/link_type.py,sha256=n5XaVXu4s2KQDp9vPaO10wRKSfm4NlAYyFFqKg9yIMM,211
+testit_python_commons/models/outcome_type.py,sha256=WAAuPRTopmYPczd-Gd0IrE7SGDZOIZKFDwxkywVrTJM,111
+testit_python_commons/models/status_type.py,sha256=lm4Hp02Z5Wo1mOaaMDjzBD1W0BE6gtwjBMPdhxuO_5U,152
+testit_python_commons/models/step_result.py,sha256=T9BbcPB6BCz3ZkrWXy2Z2Guj2wecvKJX1oIrG-yJH4I,2209
+testit_python_commons/models/test_result.py,sha256=z6OB3V_whCQDJvr4jQdgVanoJSoeKh8ZXgPAACkNrdw,7515
+testit_python_commons/models/test_result_with_all_fixture_step_results_model.py,sha256=aI5nfJ_4EAhzZg7eIV1JhSf9i3EENiRiuQuqJvSUs3M,866
+testit_python_commons/services/__init__.py,sha256=yVVmiCgMyike_8OoNPiHLNoMqKhCDlWYhvmGW0IRHJM,1197
+testit_python_commons/services/adapter_manager.py,sha256=imAogzM7IVv1970lyz3sQXbPvxzVF6nWeKXu4NWVMKE,11435
+testit_python_commons/services/adapter_manager_configuration.py,sha256=KyLhB_iNUQaVEurfLQ0RANIZfhJPB19c_WUkGpqf0xo,1619
+testit_python_commons/services/fixture_manager.py,sha256=PCSLBEPa3yJVbCPsMt_Y5badWLAhKrJsZTaUesq7oNI,2006
+testit_python_commons/services/fixture_storage.py,sha256=nAIW0p9lVvVWtiVdFNqaD7-gCBislY8DLrfdlh8OqFw,1205
+testit_python_commons/services/logger.py,sha256=E4LmykJeEHPIzuRjJShAuo2WvObfBBwOgBjYnaQi4C4,810
+testit_python_commons/services/plugin_manager.py,sha256=IIPJZSCJrOKQWfm0kmL9jWG9XbXB2mX-Zb4GNjuJcIA,3491
+testit_python_commons/services/retry.py,sha256=bXyX3YmQbjDIQVi9OH0Q4xZm7zKUx0vLcDNV2dQya6k,2470
+testit_python_commons/services/step_manager.py,sha256=pKTtEgpwOS_KJV_9kcBmKA8WRJkWvvdye_Y0ot0AKw0,1103
+testit_python_commons/services/step_result_storage.py,sha256=4axfi2dnP3LABlEql9k6lydftOgDFV3c2cXN-1uEvXU,633
+testit_python_commons/services/utils.py,sha256=5LBymIxEC1AKtGQz-S1-ipo3OYR-JzRUAC4WWFQylHc,4060
+testit_python_commons/services/sync_storage/__init__.py,sha256=Qmjs6Xk5l-i5FFItk0-XPrlVK_HkDuX6FD8FID1iKu0,154
+testit_python_commons/services/sync_storage/sync_storage_runner.py,sha256=93OXrGlGKik9359j8novwtG_hud8VL_Ksznts8sRdjE,20546
+testit_python_commons/utils/__init__.py,sha256=CUHziylwvFAuKyUM1tCp13ik5Z2Mw-VK8n7c92aVy-I,78
+testit_python_commons/utils/html_escape_utils.py,sha256=wx20lAVrMvhNiQ7bEu_f-SGqDBp85D-EBL2sgTmnJPY,8135
+testit_python_commons-4.2.8.dist-info/METADATA,sha256=dn4GF2OOlJh4U9g4LCq9KgWnHfccCHZFjyBM5cRXcyg,1662
+testit_python_commons-4.2.8.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+testit_python_commons-4.2.8.dist-info/top_level.txt,sha256=4uNwwrEWiX5vbjEzjHv6VhG67pQlpitKiuCjeSAwCkU,52
+testit_python_commons-4.2.8.dist-info/RECORD,,

testit_python_commons-4.2.8.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

testit_python_commons-4.2.8.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+api_client_syncstorage
+testit
+testit_python_commons