airbyte-cdk 6.45.9__py3-none-any.whl → 6.46.0__py3-none-any.whl

airbyte_cdk/sources/declarative/parsers/manifest_normalizer.py

@@ -0,0 +1,462 @@
+#
+# Copyright (c) 2025 Airbyte, Inc., all rights reserved.
+#
+
+import copy
+import hashlib
+import json
+from collections import defaultdict
+from itertools import chain
+from typing import Any, Callable, DefaultDict, Dict, Iterable, List, Optional, Tuple
+
+from airbyte_cdk.sources.declarative.parsers.custom_exceptions import ManifestNormalizationException
+
+# Type definitions for better readability
+ManifestType = Dict[str, Any]
+DefinitionsType = Dict[str, Any]
+DuplicateOccurancesType = List[Tuple[List[str], Dict[str, Any], Dict[str, Any]]]
+DuplicatesType = DefaultDict[str, DuplicateOccurancesType]
+
+# Configuration constants
+N_OCCURANCES = 2
+
+DEF_TAG = "definitions"
+LINKABLE_TAG = "linkable"
+LINKED_TAG = "linked"
+PROPERTIES_TAG = "properties"
+SCHEMA_LOADER_TAG = "schema_loader"
+SCHEMA_TAG = "schema"
+SCHEMAS_TAG = "schemas"
+STREAMS_TAG = "streams"
+
+
+def _get_linkable_schema_tags(schema: DefinitionsType) -> List[str]:
+    """
+    Extracts linkable tags from schema definitions.
+    This function identifies properties within a schema's definitions that are marked as linkable.
+    It traverses through each definition in the schema, examines its properties, and collects
+    the keys of properties that contain the LINKABLE_TAG.
+
+    Args:
+        schema (DefinitionsType): The schema definition dictionary to process
+
+    Returns:
+        List[str]: A deduplicated list of property keys that are marked as linkable
+    """
+
+    # the linkable scope: ['definitions.*']
+    schema_definitions = schema.get(DEF_TAG, {})
+
+    linkable_tags: List[str] = []
+    # Extract linkable keys from properties
+
+    extract_linkable_keys: Callable[[Dict[str, Dict[str, Any]]], List[str]] = lambda properties: [
+        key for key, value in properties.items() if LINKABLE_TAG in value.keys()
+    ]
+
+    # Process each root value to get its linkable keys
+    process_root: Callable[[Dict[str, Any]], List[str]] = lambda root_value: extract_linkable_keys(
+        root_value.get(PROPERTIES_TAG, {})
+    )
+
+    # Map the process_root function over all schema values and flatten the results
+    all_linkable_tags = chain.from_iterable(map(process_root, schema_definitions.values()))
+
+    # Add all found linkable tags to the tags list
+    linkable_tags.extend(all_linkable_tags)
+
+    # return unique tags only
+    return list(set(linkable_tags))
+
+
+class ManifestNormalizer:
+    """
+    This class is responsible for normalizing the manifest by appliying processing such as:
+     - removing duplicated definitions
+     - replacing them with references.
+
+    To extend the functionality, use the `normilize()` method to include any additional processing steps.
+    """
+
+    def __init__(
+        self,
+        resolved_manifest: ManifestType,
+        declarative_schema: DefinitionsType,
+    ) -> None:
+        self._resolved_manifest = resolved_manifest
+        self._declarative_schema = declarative_schema
+        self._normalized_manifest: ManifestType = copy.deepcopy(self._resolved_manifest)
+        # get the tags marked as `linkable` in the component schema
+        self._linkable_tags = _get_linkable_schema_tags(self._declarative_schema)
+
+    def to_json_str(self) -> str:
+        return json.dumps(self._normalized_manifest, indent=2)
+
+    def normalize(self) -> ManifestType:
+        """
+        Normalizes the manifest by deduplicating and resolving schema references.
+
+        This method processes the manifest in two steps:
+        1. Deduplicates elements within the manifest
+        2. Resolves and references schemas
+
+        Returns:
+            ManifestType: The normalized manifest if processing succeeds,
+                          or the original resolved manifest if normalization fails.
+
+        Raises:
+            ManifestNormalizationException: Caught internally and handled by returning the original manifest.
+        """
+        try:
+            self._deduplicate_minifest()
+            self._reference_schemas()
+
+            return self._normalized_manifest
+        except ManifestNormalizationException:
+            # if any error occurs, we just return the original manifest.
+            # TODO: enable debug logging
+            return self._resolved_manifest
+
+    def _get_manifest_streams(self) -> Iterable[Dict[str, Any]]:
+        """
+        Get the streams from the manifest.
+
+        Returns:
+            An Iterable of streams.
+        """
+
+        if STREAMS_TAG in self._normalized_manifest.keys():
+            for stream in self._normalized_manifest[STREAMS_TAG]:
+                yield stream
+
+        yield from []
+
+    def _deduplicate_minifest(self) -> None:
+        """
+        Find commonalities in the input JSON structure and refactor it to avoid redundancy.
+        """
+
+        try:
+            # prepare the `definitions` tag
+            self._prepare_definitions()
+            # replace duplicates with references, if any
+            self._handle_duplicates(self._collect_duplicates())
+        except Exception as e:
+            raise ManifestNormalizationException(str(e))
+
+    def _prepare_definitions(self) -> None:
+        """
+        Clean the definitions in the manifest by removing unnecessary properties.
+        This function modifies the manifest in place.
+        """
+
+        # Check if the definitions tag exists
+        if not DEF_TAG in self._normalized_manifest:
+            self._normalized_manifest[DEF_TAG] = {}
+
+        # Check if the linked tag exists
+        if not LINKED_TAG in self._normalized_manifest[DEF_TAG]:
+            self._normalized_manifest[DEF_TAG][LINKED_TAG] = {}
+
+        # remove everything from definitions tag except of `linked`, after processing
+        for key in list(self._normalized_manifest[DEF_TAG].keys()):
+            if key != LINKED_TAG:
+                self._normalized_manifest[DEF_TAG].pop(key, None)
+
+    def _extract_stream_schema(self, stream: Dict[str, Any]) -> None:
+        """
+        Extract the schema from the stream and add it to the `schemas` tag.
+        """
+
+        stream_name = stream["name"]
+        # copy the value of the SCHEMA_TAG to the SCHEMAS_TAG with the stream name as key
+        schema = stream.get(SCHEMA_LOADER_TAG, {}).get(SCHEMA_TAG)
+        if not SCHEMAS_TAG in self._normalized_manifest.keys():
+            self._normalized_manifest[SCHEMAS_TAG] = {}
+        # add stream schema to the SCHEMAS_TAG
+        if not stream_name in self._normalized_manifest[SCHEMAS_TAG].keys():
+            # add the schema to the SCHEMAS_TAG with the stream name as key
+            self._normalized_manifest[SCHEMAS_TAG][stream_name] = schema
+
+    def _reference_schemas(self) -> None:
+        """
+        Set the schema reference for the given stream in the manifest.
+        This function modifies the manifest in place.
+        """
+
+        # reference the stream schema for the stream to where it's stored
+        if SCHEMAS_TAG in self._normalized_manifest.keys():
+            for stream in self._get_manifest_streams():
+                self._extract_stream_schema(stream)
+                self._set_stream_schema_ref(stream)
+
+    def _set_stream_schema_ref(self, stream: Dict[str, Any]) -> None:
+        """
+        Set the schema reference for the given stream in the manifest.
+        This function modifies the manifest in place.
+        """
+        stream_name = stream["name"]
+        if SCHEMAS_TAG in self._normalized_manifest.keys():
+            if stream_name in self._normalized_manifest[SCHEMAS_TAG]:
+                stream[SCHEMA_LOADER_TAG][SCHEMA_TAG] = self._create_schema_ref(stream_name)
+
+    def _replace_duplicates_with_refs(self, duplicates: DuplicatesType) -> None:
+        """
+        Process duplicate objects and replace them with references.
+
+        Args:
+            duplicates: The duplicates dictionary collected from the given manifest.
+        """
+
+        for _, occurrences in duplicates.items():
+            type_key, key, value = self._get_occurance_samples(occurrences)
+            is_linked_def = self._is_linked_definition(type_key, key)
+
+            # Add to definitions if not there already
+            if not is_linked_def:
+                self._add_to_linked_definitions(type_key, key, value)
+
+            # Replace occurrences with references
+            for _, parent_obj, value in occurrences:
+                if is_linked_def:
+                    if value == self._get_linked_definition_value(type_key, key):
+                        parent_obj[key] = self._create_linked_definition_ref(type_key, key)
+                else:
+                    parent_obj[key] = self._create_linked_definition_ref(type_key, key)
+
+    def _handle_duplicates(self, duplicates: DuplicatesType) -> None:
+        """
+        Process the duplicates and replace them with references.
+
+        Args:
+            duplicates: The duplicates dictionary collected from the given manifest.
+        """
+
+        if len(duplicates) > 0:
+            self._replace_duplicates_with_refs(duplicates)
+
+    def _add_duplicate(
+        self,
+        duplicates: DuplicatesType,
+        current_path: List[str],
+        obj: Dict[str, Any],
+        value: Any,
+        key: Optional[str] = None,
+    ) -> None:
+        """
+        Adds a duplicate record of an observed object by computing a unique hash for the provided value.
+
+        This function computes a hash for the given value (or a dictionary composed of the key and value if a key is provided)
+        and appends a tuple containing the current path, the original object, and the value to the duplicates
+        dictionary under the corresponding hash.
+
+        Parameters:
+            duplicates (DuplicatesType): The dictionary to store duplicate records.
+            current_path (List[str]): The list of keys or indices representing the current location in the object hierarchy.
+            obj (Dict): The original dictionary object where the duplicate is observed.
+            value (Any): The value to be hashed and used for identifying duplicates.
+            key (Optional[str]): An optional key that, if provided, wraps the value in a dictionary before hashing.
+        """
+
+        # create hash for each duplicate observed
+        value_to_hash = {key: value} if key is not None else value
+        duplicates[self._hash_object(value_to_hash)].append((current_path, obj, value))
+
+    def _add_to_linked_definitions(
+        self,
+        type_key: str,
+        key: str,
+        value: Any,
+    ) -> None:
+        """
+        Add a value to the linked definitions under the specified key.
+
+        Args:
+            definitions: The definitions dictionary to modify
+            key: The key to use
+            value: The value to add
+        """
+        if type_key not in self._normalized_manifest[DEF_TAG][LINKED_TAG].keys():
+            self._normalized_manifest[DEF_TAG][LINKED_TAG][type_key] = {}
+
+        if key not in self._normalized_manifest[DEF_TAG][LINKED_TAG][type_key].keys():
+            self._normalized_manifest[DEF_TAG][LINKED_TAG][type_key][key] = value
+
+    def _collect_duplicates(self) -> DuplicatesType:
+        """
+        Traverse the JSON object and collect all potential duplicate values and objects.
+
+        Returns:
+            duplicates: A dictionary of duplicate objects.
+        """
+
+        def _collect(obj: Dict[str, Any], path: Optional[List[str]] = None) -> None:
+            """
+            The closure to recursively collect duplicates in the JSON object.
+
+            Args:
+                obj: The current object being analyzed.
+                path: The current path in the object hierarchy.
+            """
+
+            if not isinstance(obj, dict):
+                return
+
+            path = [] if path is None else path
+            # Check if the object is empty
+            for key, value in obj.items():
+                # do not collect duplicates from `definitions` tag
+                if key == DEF_TAG:
+                    continue
+
+                current_path = path + [key]
+
+                if isinstance(value, dict):
+                    # First process nested dictionaries
+                    _collect(value, current_path)
+                    # Process allowed-only component tags
+                    if key in self._linkable_tags:
+                        self._add_duplicate(duplicates, current_path, obj, value)
+
+                # handle primitive types
+                elif isinstance(value, (str, int, float, bool)):
+                    # Process allowed-only field tags
+                    if key in self._linkable_tags:
+                        self._add_duplicate(duplicates, current_path, obj, value, key)
+
+                # handle list cases
+                elif isinstance(value, list):
+                    for i, item in enumerate(value):
+                        _collect(item, current_path + [str(i)])
+
+        duplicates: DuplicatesType = defaultdict(list, {})
+        try:
+            if self._linkable_tags:
+                _collect(self._normalized_manifest)
+                # clean non-duplicates and sort based on the count of occurrences
+                return self._clean_and_sort_duplicates(duplicates)
+            return duplicates
+        except Exception as e:
+            raise ManifestNormalizationException(str(e))
+
+    def _clean_and_sort_duplicates(self, duplicates: DuplicatesType) -> DuplicatesType:
+        """
+        Clean non-duplicates and sort the duplicates by their occurrences.
+
+        Args:
+            duplicates: The duplicates dictionary to sort
+
+        Returns:
+            A sorted duplicates dictionary.
+        """
+
+        # clean non-duplicates
+        duplicates = defaultdict(
+            list,
+            {k: v for k, v in duplicates.items() if len(v) >= N_OCCURANCES},
+        )
+
+        # sort the duplicates by their occurrences, more frequent ones go first
+        duplicates = defaultdict(
+            list,
+            {k: v for k, v in sorted(duplicates.items(), key=lambda x: len(x[1]), reverse=True)},
+        )
+
+        return duplicates
+
+    def _hash_object(self, obj: Dict[str, Any]) -> str:
+        """
+        Create a unique hash for a dictionary object.
+
+        Args:
+            node: The dictionary to hash
+
+        Returns:
+            A hashed string
+        """
+
+        # Sort keys to ensure consistent hash for same content
+        return hashlib.md5(json.dumps(obj, sort_keys=True).encode()).hexdigest()
+
+    def _is_linked_definition(self, type_key: str, key: str) -> bool:
+        """
+        Check if the key already exists in the linked definitions.
+
+        Args:
+            key: The key to check
+            definitions: The definitions dictionary with definitions
+
+        Returns:
+            True if the key exists in the linked definitions, False otherwise
+        """
+
+        if type_key in self._normalized_manifest[DEF_TAG][LINKED_TAG].keys():
+            # Check if the key exists in the linked definitions
+            if key in self._normalized_manifest[DEF_TAG][LINKED_TAG][type_key].keys():
+                return True
+
+        return False
+
+    def _get_linked_definition_value(self, type_key: str, key: str) -> Any:
+        """
+        Get the value of a linked definition by its key.
+
+        Args:
+            key: The key to check
+            definitions: The definitions dictionary with definitions
+
+        Returns:
+            The value of the linked definition
+        """
+        if type_key in self._normalized_manifest[DEF_TAG][LINKED_TAG].keys():
+            if key in self._normalized_manifest[DEF_TAG][LINKED_TAG][type_key].keys():
+                return self._normalized_manifest[DEF_TAG][LINKED_TAG][type_key][key]
+        else:
+            raise ManifestNormalizationException(
+                f"Key {key} not found in linked definitions. Please check the manifest."
+            )
+
+    def _get_occurance_samples(self, occurrences: DuplicateOccurancesType) -> Tuple[str, str, Any]:
+        """
+        Get the key from the occurrences list.
+
+        Args:
+            occurrences: The occurrences list
+
+        Returns:
+            The key, type and value from the occurrences
+        """
+
+        # Take the value from the first occurrence, as they are the same
+        path, obj, value = occurrences[0]
+        return (
+            obj["type"],
+            path[-1],
+            value,
+        )  # Return the component's name as the last part of its path
+
+    def _create_linked_definition_ref(self, type_key: str, key: str) -> Dict[str, str]:
+        """
+        Create a reference object for the linked definitions using the specified key.
+
+        Args:
+            ref_key: The reference key to use
+
+        Returns:
+            A reference object in the proper format
+        """
+
+        return {"$ref": f"#/{DEF_TAG}/{LINKED_TAG}/{type_key}/{key}"}
+
+    def _create_schema_ref(self, key: str) -> Dict[str, str]:
+        """
+        Create a reference object for stream schema using the specified key.
+
+        Args:
+            key: The reference key to use
+
+        Returns:
+            A reference object in the proper format
+        """
+
+        return {"$ref": f"#/{SCHEMAS_TAG}/{key}"}

airbyte_cdk/sources/declarative/parsers/manifest_reference_resolver.py

@@ -3,7 +3,7 @@
 #
 
 import re
-from typing import Any, Mapping, Set, Tuple, Union
+from typing import Any, Dict, Mapping, Set, Tuple, Union
 
 from airbyte_cdk.sources.declarative.parsers.custom_exceptions import (
     CircularReferenceException,
@@ -99,7 +99,7 @@ class ManifestReferenceResolver:
     until we find a key with the given path, or until there is nothing to traverse.
     """
 
-    def preprocess_manifest(self, manifest: Mapping[str, Any]) -> Mapping[str, Any]:
+    def preprocess_manifest(self, manifest: Mapping[str, Any]) -> Dict[str, Any]:
         """
         :param manifest: incoming manifest that could have references to previously defined components
         :return:

airbyte_cdk/sources/declarative/parsers/model_to_component_factory.py

@@ -2194,11 +2194,20 @@ class ModelToComponentFactory:
 
         api_budget = self._api_budget
 
+        # Removes QueryProperties components from the interpolated mappings because it has been designed
+        # to be used by the SimpleRetriever and will be resolved from the provider from the slice directly
+        # instead of through jinja interpolation
+        request_parameters: Optional[Union[str, Mapping[str, str]]]
+        if isinstance(model.request_parameters, Mapping):
+            request_parameters = self._remove_query_properties(model.request_parameters)
+        else:
+            request_parameters = model.request_parameters
+
         request_options_provider = InterpolatedRequestOptionsProvider(
             request_body_data=model.request_body_data,
             request_body_json=model.request_body_json,
             request_headers=model.request_headers,
-            request_parameters=model.request_parameters,
+            request_parameters=request_parameters,
             query_properties_key=query_properties_key,
             config=config,
             parameters=model.parameters or {},
@@ -2818,6 +2827,10 @@ class ModelToComponentFactory:
             else None
         )
 
+        if model.transform_before_filtering is None:
+            # default to False if not set
+            model.transform_before_filtering = False
+
         assert model.transform_before_filtering is not None  # for mypy
 
         transform_before_filtering = model.transform_before_filtering
@@ -2832,6 +2845,10 @@ class ModelToComponentFactory:
             )
             transform_before_filtering = True
 
+        if model.schema_normalization is None:
+            # default to no schema normalization if not set
+            model.schema_normalization = SchemaNormalizationModel.None_
+
         schema_normalization = (
             TypeTransformer(SCHEMA_TRANSFORMER_TYPE_MAPPING[model.schema_normalization])
             if isinstance(model.schema_normalization, SchemaNormalizationModel)
@@ -2938,16 +2955,9 @@ class ModelToComponentFactory:
                 # When translating JSON schema into Pydantic models, enforcing types for arrays containing both
                 # concrete string complex object definitions like QueryProperties would get resolved to Union[str, Any].
                 # This adds the extra validation that we couldn't get for free in Pydantic model generation
-                if (
-                    isinstance(request_parameter, Mapping)
-                    and request_parameter.get("type") == "QueryProperties"
-                ):
+                if isinstance(request_parameter, QueryPropertiesModel):
                     query_properties_key = key
                     query_properties_definitions.append(request_parameter)
-                elif not isinstance(request_parameter, str):
-                    raise ValueError(
-                        f"Each element of request_parameters should be of type str or QueryProperties, but received {request_parameter.get('type')}"
-                    )
 
             if len(query_properties_definitions) > 1:
                 raise ValueError(
@@ -2955,17 +2965,8 @@ class ModelToComponentFactory:
                 )
 
             if len(query_properties_definitions) == 1:
-                query_properties = self.create_component(
-                    model_type=QueryPropertiesModel,
-                    component_definition=query_properties_definitions[0],
-                    config=config,
-                )
-
-            # Removes QueryProperties components from the interpolated mappings because it will be resolved in
-            # the provider from the slice directly instead of through jinja interpolation
-            if isinstance(model.requester.request_parameters, Mapping):
-                model.requester.request_parameters = self._remove_query_properties(
-                    model.requester.request_parameters
+                query_properties = self._create_component_from_model(
+                    model=query_properties_definitions[0], config=config
                 )
 
         requester = self._create_component_from_model(
@@ -3088,13 +3089,12 @@ class ModelToComponentFactory:
 
     @staticmethod
     def _remove_query_properties(
-        request_parameters: Mapping[str, Union[Any, str]],
-    ) -> Mapping[str, Union[Any, str]]:
+        request_parameters: Mapping[str, Union[str, QueryPropertiesModel]],
+    ) -> Mapping[str, str]:
         return {
             parameter_field: request_parameter
             for parameter_field, request_parameter in request_parameters.items()
-            if not isinstance(request_parameter, Mapping)
-            or not request_parameter.get("type") == "QueryProperties"
+            if not isinstance(request_parameter, QueryPropertiesModel)
         }
 
     def create_state_delegating_stream(

airbyte_cdk/sources/file_based/file_record_data.py

@@ -14,7 +14,7 @@ class FileRecordData(BaseModel):
     """
 
     folder: str
-    filename: str
+    file_name: str
     bytes: int
     source_uri: str
     id: Optional[str] = None

airbyte_cdk/test/standard_tests/connector_base.py

@@ -4,7 +4,9 @@
 from __future__ import annotations
 
 import abc
+import importlib
 import inspect
+import os
 import sys
 from collections.abc import Callable
 from pathlib import Path
@@ -22,17 +24,61 @@ from airbyte_cdk.test.standard_tests._job_runner import IConnector, run_test_job
 from airbyte_cdk.test.standard_tests.models import (
     ConnectorTestScenario,
 )
-
-ACCEPTANCE_TEST_CONFIG = "acceptance-test-config.yml"
-MANIFEST_YAML = "manifest.yaml"
+from airbyte_cdk.test.standard_tests.test_resources import (
+    ACCEPTANCE_TEST_CONFIG,
+    find_connector_root,
+)
 
 
 class ConnectorTestSuiteBase(abc.ABC):
     """Base class for connector test suites."""
 
-    connector: type[IConnector] | Callable[[], IConnector] | None = None
+    connector: type[IConnector] | Callable[[], IConnector] | None  # type: ignore [reportRedeclaration]
     """The connector class or a factory function that returns an scenario of IConnector."""
 
+    @classproperty  # type: ignore [no-redef]
+    def connector(cls) -> type[IConnector] | Callable[[], IConnector] | None:
+        """Get the connector class for the test suite.
+
+        This assumes a python connector and should be overridden by subclasses to provide the
+        specific connector class to be tested.
+        """
+        connector_root = cls.get_connector_root_dir()
+        connector_name = connector_root.absolute().name
+
+        expected_module_name = connector_name.replace("-", "_").lower()
+        expected_class_name = connector_name.replace("-", "_").title().replace("_", "")
+
+        # dynamically import and get the connector class: <expected_module_name>.<expected_class_name>
+
+        cwd_snapshot = Path().absolute()
+        os.chdir(connector_root)
+
+        # Dynamically import the module
+        try:
+            module = importlib.import_module(expected_module_name)
+        except ModuleNotFoundError as e:
+            raise ImportError(f"Could not import module '{expected_module_name}'.") from e
+        finally:
+            # Change back to the original working directory
+            os.chdir(cwd_snapshot)
+
+        # Dynamically get the class from the module
+        try:
+            return cast(type[IConnector], getattr(module, expected_class_name))
+        except AttributeError as e:
+            # We did not find it based on our expectations, so let's check if we can find it
+            # with a case-insensitive match.
+            matching_class_name = next(
+                (name for name in dir(module) if name.lower() == expected_class_name.lower()),
+                None,
+            )
+            if not matching_class_name:
+                raise ImportError(
+                    f"Module '{expected_module_name}' does not have a class named '{expected_class_name}'."
+                ) from e
+            return cast(type[IConnector], getattr(module, matching_class_name))
+
     @classmethod
     def get_test_class_dir(cls) -> Path:
         """Get the file path that contains the class."""
@@ -81,27 +127,7 @@ class ConnectorTestSuiteBase(abc.ABC):
     @classmethod
     def get_connector_root_dir(cls) -> Path:
         """Get the root directory of the connector."""
-        for parent in cls.get_test_class_dir().parents:
-            if (parent / MANIFEST_YAML).exists():
-                return parent
-            if (parent / ACCEPTANCE_TEST_CONFIG).exists():
-                return parent
-            if parent.name == "airbyte_cdk":
-                break
-        # If we reach here, we didn't find the manifest file in any parent directory
-        # Check if the manifest file exists in the current directory
-        for parent in Path.cwd().parents:
-            if (parent / MANIFEST_YAML).exists():
-                return parent
-            if (parent / ACCEPTANCE_TEST_CONFIG).exists():
-                return parent
-            if parent.name == "airbyte_cdk":
-                break
-
-        raise FileNotFoundError(
-            "Could not find connector root directory relative to "
-            f"'{str(cls.get_test_class_dir())}' or '{str(Path.cwd())}'."
-        )
+        return find_connector_root([cls.get_test_class_dir(), Path.cwd()])
 
     @classproperty
     def acceptance_test_config_path(cls) -> Path: