airbyte-cdk 0.0.0.dev0__py3-none-any.whl

airbyte_cdk/test/mock_http/mocker.py

@@ -0,0 +1,185 @@
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
+
+import contextlib
+import functools
+from collections import defaultdict
+from enum import Enum
+from types import TracebackType
+from typing import Callable, Dict, Iterable, List, Optional, Union
+
+import requests_mock
+
+from airbyte_cdk.test.mock_http.matcher import HttpRequestMatcher
+from airbyte_cdk.test.mock_http.request import HttpRequest
+from airbyte_cdk.test.mock_http.response import HttpResponse
+
+
+class SupportedHttpMethods(str, Enum):
+    GET = "get"
+    PATCH = "patch"
+    POST = "post"
+    PUT = "put"
+    DELETE = "delete"
+
+
+class HttpMocker(contextlib.ContextDecorator):
+    """
+    WARNING 1: This implementation only works if the lib used to perform HTTP requests is `requests`.
+
+    WARNING 2: Given multiple requests that are not mutually exclusive, the request will match the first one. This can happen in scenarios
+    where the same request is added twice (in which case there will always be an exception because we will never match the second
+    request) or in a case like this:
+    ```
+    http_mocker.get(HttpRequest(_A_URL, headers={"less_granular": "1", "more_granular": "2"}), <...>)
+    http_mocker.get(HttpRequest(_A_URL, headers={"less_granular": "1"}), <...>)
+    requests.get(_A_URL, headers={"less_granular": "1", "more_granular": "2"})
+    ```
+    In the example above, the matcher would match the second mock as requests_mock iterate over the matcher in reverse order (see
+    https://github.com/jamielennox/requests-mock/blob/c06f124a33f56e9f03840518e19669ba41b93202/requests_mock/adapter.py#L246) even
+    though the request sent is a better match for the first `http_mocker.get`.
+    """
+
+    def __init__(self) -> None:
+        self._mocker = requests_mock.Mocker()
+        self._matchers: Dict[SupportedHttpMethods, List[HttpRequestMatcher]] = defaultdict(list)
+
+    def __enter__(self) -> "HttpMocker":
+        self._mocker.__enter__()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[BaseException],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        self._mocker.__exit__(exc_type, exc_val, exc_tb)
+
+    def _validate_all_matchers_called(self) -> None:
+        for matcher in self._get_matchers():
+            if not matcher.has_expected_match_count():
+                raise ValueError(f"Invalid number of matches for `{matcher}`")
+
+    def _mock_request_method(
+        self,
+        method: SupportedHttpMethods,
+        request: HttpRequest,
+        responses: Union[HttpResponse, List[HttpResponse]],
+    ) -> None:
+        if isinstance(responses, HttpResponse):
+            responses = [responses]
+
+        matcher = HttpRequestMatcher(request, len(responses))
+        if matcher in self._matchers[method]:
+            raise ValueError(f"Request {matcher.request} already mocked")
+        self._matchers[method].append(matcher)
+
+        getattr(self._mocker, method)(
+            requests_mock.ANY,
+            additional_matcher=self._matches_wrapper(matcher),
+            response_list=[
+                {
+                    self._get_body_field(response): response.body,
+                    "status_code": response.status_code,
+                    "headers": response.headers,
+                }
+                for response in responses
+            ],
+        )
+
+    @staticmethod
+    def _get_body_field(response: HttpResponse) -> str:
+        return "text" if isinstance(response.body, str) else "content"
+
+    def get(self, request: HttpRequest, responses: Union[HttpResponse, List[HttpResponse]]) -> None:
+        self._mock_request_method(SupportedHttpMethods.GET, request, responses)
+
+    def patch(
+        self, request: HttpRequest, responses: Union[HttpResponse, List[HttpResponse]]
+    ) -> None:
+        self._mock_request_method(SupportedHttpMethods.PATCH, request, responses)
+
+    def post(
+        self, request: HttpRequest, responses: Union[HttpResponse, List[HttpResponse]]
+    ) -> None:
+        self._mock_request_method(SupportedHttpMethods.POST, request, responses)
+
+    def put(self, request: HttpRequest, responses: Union[HttpResponse, List[HttpResponse]]) -> None:
+        self._mock_request_method(SupportedHttpMethods.PUT, request, responses)
+
+    def delete(
+        self, request: HttpRequest, responses: Union[HttpResponse, List[HttpResponse]]
+    ) -> None:
+        self._mock_request_method(SupportedHttpMethods.DELETE, request, responses)
+
+    @staticmethod
+    def _matches_wrapper(
+        matcher: HttpRequestMatcher,
+    ) -> Callable[[requests_mock.request._RequestObjectProxy], bool]:
+        def matches(requests_mock_request: requests_mock.request._RequestObjectProxy) -> bool:
+            # query_params are provided as part of `requests_mock_request.url`
+            http_request = HttpRequest(
+                requests_mock_request.url,
+                query_params={},
+                headers=requests_mock_request.headers,
+                body=requests_mock_request.body,
+            )
+            return matcher.matches(http_request)
+
+        return matches
+
+    def assert_number_of_calls(self, request: HttpRequest, number_of_calls: int) -> None:
+        corresponding_matchers = list(
+            filter(lambda matcher: matcher.request is request, self._get_matchers())
+        )
+        if len(corresponding_matchers) != 1:
+            raise ValueError(
+                f"Was expecting only one matcher to match the request but got `{corresponding_matchers}`"
+            )
+
+        assert corresponding_matchers[0].actual_number_of_matches == number_of_calls
+
+    # trying to type that using callables provides the error `incompatible with return type "_F" in supertype "ContextDecorator"`
+    def __call__(self, f):  # type: ignore
+        @functools.wraps(f)
+        def wrapper(*args, **kwargs):  # type: ignore  # this is a very generic wrapper that does not need to be typed
+            with self:
+                assertion_error = None
+
+                kwargs["http_mocker"] = self
+                try:
+                    result = f(*args, **kwargs)
+                except requests_mock.NoMockAddress as no_mock_exception:
+                    matchers_as_string = "\n\t".join(
+                        map(lambda matcher: str(matcher.request), self._get_matchers())
+                    )
+                    raise ValueError(
+                        f"No matcher matches {no_mock_exception.args[0]} with headers `{no_mock_exception.request.headers}` "
+                        f"and body `{no_mock_exception.request.body}`. "
+                        f"Matchers currently configured are:\n\t{matchers_as_string}."
+                    ) from no_mock_exception
+                except AssertionError as test_assertion:
+                    assertion_error = test_assertion
+
+                # We validate the matchers before raising the assertion error because we want to show the tester if an HTTP request wasn't
+                # mocked correctly
+                try:
+                    self._validate_all_matchers_called()
+                except ValueError as http_mocker_exception:
+                    # This seems useless as it catches ValueError and raises ValueError but without this, the prevailing error message in
+                    # the output is the function call that failed the assertion, whereas raising `ValueError(http_mocker_exception)`
+                    # like we do here provides additional context for the exception.
+                    raise ValueError(http_mocker_exception) from None
+                if assertion_error:
+                    raise assertion_error
+                return result
+
+        return wrapper
+
+    def _get_matchers(self) -> Iterable[HttpRequestMatcher]:
+        for matchers in self._matchers.values():
+            yield from matchers
+
+    def clear_all_matchers(self) -> None:
+        """Clears all stored matchers by resetting the _matchers list to an empty state."""
+        self._matchers = defaultdict(list)

airbyte_cdk/test/mock_http/request.py

@@ -0,0 +1,103 @@
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
+
+import json
+from typing import Any, List, Mapping, Optional, Union
+from urllib.parse import parse_qs, urlencode, urlparse
+
+ANY_QUERY_PARAMS = "any query_parameters"
+
+
+def _is_subdict(small: Mapping[str, str], big: Mapping[str, str]) -> bool:
+    return dict(big, **small) == big
+
+
+class HttpRequest:
+    def __init__(
+        self,
+        url: str,
+        query_params: Optional[Union[str, Mapping[str, Union[str, List[str]]]]] = None,
+        headers: Optional[Mapping[str, str]] = None,
+        body: Optional[Union[str, bytes, Mapping[str, Any]]] = None,
+    ) -> None:
+        self._parsed_url = urlparse(url)
+        self._query_params = query_params
+        if not self._parsed_url.query and query_params:
+            self._parsed_url = urlparse(f"{url}?{self._encode_qs(query_params)}")
+        elif self._parsed_url.query and query_params:
+            raise ValueError(
+                "If query params are provided as part of the url, `query_params` should be empty"
+            )
+
+        self._headers = headers or {}
+        self._body = body
+
+    @staticmethod
+    def _encode_qs(query_params: Union[str, Mapping[str, Union[str, List[str]]]]) -> str:
+        if isinstance(query_params, str):
+            return query_params
+        return urlencode(query_params, doseq=True)
+
+    def matches(self, other: Any) -> bool:
+        """
+        If the body of any request is a Mapping, we compare as Mappings which means that the order is not important.
+        If the body is a string, encoding ISO-8859-1 will be assumed
+        Headers only need to be a subset of `other` in order to match
+        """
+        if isinstance(other, HttpRequest):
+            # if `other` is a mapping, we match as an object and formatting is not considers
+            if isinstance(self._body, Mapping) or isinstance(other._body, Mapping):
+                body_match = self._to_mapping(self._body) == self._to_mapping(other._body)
+            else:
+                body_match = self._to_bytes(self._body) == self._to_bytes(other._body)
+
+            return (
+                self._parsed_url.scheme == other._parsed_url.scheme
+                and self._parsed_url.hostname == other._parsed_url.hostname
+                and self._parsed_url.path == other._parsed_url.path
+                and (
+                    ANY_QUERY_PARAMS in (self._query_params, other._query_params)
+                    or parse_qs(self._parsed_url.query) == parse_qs(other._parsed_url.query)
+                )
+                and _is_subdict(other._headers, self._headers)
+                and body_match
+            )
+        return False
+
+    @staticmethod
+    def _to_mapping(
+        body: Optional[Union[str, bytes, Mapping[str, Any]]],
+    ) -> Optional[Mapping[str, Any]]:
+        if isinstance(body, Mapping):
+            return body
+        elif isinstance(body, bytes):
+            return json.loads(body.decode())  # type: ignore  # assumes return type of Mapping[str, Any]
+        elif isinstance(body, str):
+            return json.loads(body)  # type: ignore  # assumes return type of Mapping[str, Any]
+        return None
+
+    @staticmethod
+    def _to_bytes(body: Optional[Union[str, bytes]]) -> bytes:
+        if isinstance(body, bytes):
+            return body
+        elif isinstance(body, str):
+            # `ISO-8859-1` is the default encoding used by requests
+            return body.encode("ISO-8859-1")
+        return b""
+
+    def __str__(self) -> str:
+        return f"{self._parsed_url} with headers {self._headers} and body {self._body!r})"
+
+    def __repr__(self) -> str:
+        return (
+            f"HttpRequest(request={self._parsed_url}, headers={self._headers}, body={self._body!r})"
+        )
+
+    def __eq__(self, other: Any) -> bool:
+        if isinstance(other, HttpRequest):
+            return (
+                self._parsed_url == other._parsed_url
+                and self._query_params == other._query_params
+                and self._headers == other._headers
+                and self._body == other._body
+            )
+        return False

airbyte_cdk/test/mock_http/response.py

@@ -0,0 +1,28 @@
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
+
+from types import MappingProxyType
+from typing import Mapping, Union
+
+
+class HttpResponse:
+    def __init__(
+        self,
+        body: Union[str, bytes],
+        status_code: int = 200,
+        headers: Mapping[str, str] = MappingProxyType({}),
+    ):
+        self._body = body
+        self._status_code = status_code
+        self._headers = headers
+
+    @property
+    def body(self) -> Union[str, bytes]:
+        return self._body
+
+    @property
+    def status_code(self) -> int:
+        return self._status_code
+
+    @property
+    def headers(self) -> Mapping[str, str]:
+        return self._headers

airbyte_cdk/test/mock_http/response_builder.py

@@ -0,0 +1,237 @@
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
+
+import functools
+import json
+from abc import ABC, abstractmethod
+from pathlib import Path as FilePath
+from typing import Any, Dict, List, Optional, Union
+
+from airbyte_cdk.test.mock_http.response import HttpResponse
+from airbyte_cdk.test.utils.data import get_unit_test_folder
+
+
+def _extract(path: List[str], response_template: Dict[str, Any]) -> Any:
+    return functools.reduce(lambda a, b: a[b], path, response_template)
+
+
+def _replace_value(dictionary: Dict[str, Any], path: List[str], value: Any) -> None:
+    current = dictionary
+    for key in path[:-1]:
+        current = current[key]
+    current[path[-1]] = value
+
+
+def _write(dictionary: Dict[str, Any], path: List[str], value: Any) -> None:
+    current = dictionary
+    for key in path[:-1]:
+        current = current.setdefault(key, {})
+    current[path[-1]] = value
+
+
+class Path(ABC):
+    @abstractmethod
+    def write(self, template: Dict[str, Any], value: Any) -> None:
+        pass
+
+    @abstractmethod
+    def update(self, template: Dict[str, Any], value: Any) -> None:
+        pass
+
+    def extract(self, template: Dict[str, Any]) -> Any:
+        pass
+
+
+class FieldPath(Path):
+    def __init__(self, field: str):
+        self._path = [field]
+
+    def write(self, template: Dict[str, Any], value: Any) -> None:
+        _write(template, self._path, value)
+
+    def update(self, template: Dict[str, Any], value: Any) -> None:
+        _replace_value(template, self._path, value)
+
+    def extract(self, template: Dict[str, Any]) -> Any:
+        return _extract(self._path, template)
+
+    def __str__(self) -> str:
+        return f"FieldPath(field={self._path[0]})"
+
+
+class NestedPath(Path):
+    def __init__(self, path: List[str]):
+        self._path = path
+
+    def write(self, template: Dict[str, Any], value: Any) -> None:
+        _write(template, self._path, value)
+
+    def update(self, template: Dict[str, Any], value: Any) -> None:
+        _replace_value(template, self._path, value)
+
+    def extract(self, template: Dict[str, Any]) -> Any:
+        return _extract(self._path, template)
+
+    def __str__(self) -> str:
+        return f"NestedPath(path={self._path})"
+
+
+class PaginationStrategy(ABC):
+    @abstractmethod
+    def update(self, response: Dict[str, Any]) -> None:
+        pass
+
+
+class FieldUpdatePaginationStrategy(PaginationStrategy):
+    def __init__(self, path: Path, value: Any):
+        self._path = path
+        self._value = value
+
+    def update(self, response: Dict[str, Any]) -> None:
+        self._path.update(response, self._value)
+
+
+class RecordBuilder:
+    def __init__(
+        self,
+        template: Dict[str, Any],
+        id_path: Optional[Path],
+        cursor_path: Optional[Union[FieldPath, NestedPath]],
+    ):
+        self._record = template
+        self._id_path = id_path
+        self._cursor_path = cursor_path
+
+        self._validate_template()
+
+    def _validate_template(self) -> None:
+        paths_to_validate = [
+            ("_id_path", self._id_path),
+            ("_cursor_path", self._cursor_path),
+        ]
+        for field_name, field_path in paths_to_validate:
+            self._validate_field(field_name, field_path)
+
+    def _validate_field(self, field_name: str, path: Optional[Path]) -> None:
+        try:
+            if path and not path.extract(self._record):
+                raise ValueError(
+                    f"{field_name} `{path}` was provided but it is not part of the template `{self._record}`"
+                )
+        except (IndexError, KeyError) as exception:
+            raise ValueError(
+                f"{field_name} `{path}` was provided but it is not part of the template `{self._record}`"
+            ) from exception
+
+    def with_id(self, identifier: Any) -> "RecordBuilder":
+        self._set_field("id", self._id_path, identifier)
+        return self
+
+    def with_cursor(self, cursor_value: Any) -> "RecordBuilder":
+        self._set_field("cursor", self._cursor_path, cursor_value)
+        return self
+
+    def with_field(self, path: Path, value: Any) -> "RecordBuilder":
+        path.write(self._record, value)
+        return self
+
+    def _set_field(self, field_name: str, path: Optional[Path], value: Any) -> None:
+        if not path:
+            raise ValueError(
+                f"{field_name}_path was not provided and hence, the record {field_name} can't be modified. Please provide `id_field` while "
+                f"instantiating RecordBuilder to leverage this capability"
+            )
+        path.update(self._record, value)
+
+    def build(self) -> Dict[str, Any]:
+        return self._record
+
+
+class HttpResponseBuilder:
+    def __init__(
+        self,
+        template: Dict[str, Any],
+        records_path: Union[FieldPath, NestedPath],
+        pagination_strategy: Optional[PaginationStrategy],
+    ):
+        self._response = template
+        self._records: List[RecordBuilder] = []
+        self._records_path = records_path
+        self._pagination_strategy = pagination_strategy
+        self._status_code = 200
+
+    def with_record(self, record: RecordBuilder) -> "HttpResponseBuilder":
+        self._records.append(record)
+        return self
+
+    def with_pagination(self) -> "HttpResponseBuilder":
+        if not self._pagination_strategy:
+            raise ValueError(
+                "`pagination_strategy` was not provided and hence, fields related to the pagination can't be modified. Please provide "
+                "`pagination_strategy` while instantiating ResponseBuilder to leverage this capability"
+            )
+        self._pagination_strategy.update(self._response)
+        return self
+
+    def with_status_code(self, status_code: int) -> "HttpResponseBuilder":
+        self._status_code = status_code
+        return self
+
+    def build(self) -> HttpResponse:
+        self._records_path.update(self._response, [record.build() for record in self._records])
+        return HttpResponse(json.dumps(self._response), self._status_code)
+
+
+def _get_unit_test_folder(execution_folder: str) -> FilePath:
+    # FIXME: This function should be removed after the next CDK release to avoid breaking amazon-seller-partner test code.
+    return get_unit_test_folder(execution_folder)
+
+
+def find_template(resource: str, execution_folder: str) -> Dict[str, Any]:
+    response_template_filepath = str(
+        get_unit_test_folder(execution_folder)
+        / "resource"
+        / "http"
+        / "response"
+        / f"{resource}.json"
+    )
+    with open(response_template_filepath, "r") as template_file:
+        return json.load(template_file)  # type: ignore  # we assume the dev correctly set up the resource file
+
+
+def find_binary_response(resource: str, execution_folder: str) -> bytes:
+    response_filepath = str(
+        get_unit_test_folder(execution_folder) / "resource" / "http" / "response" / f"{resource}"
+    )
+    with open(response_filepath, "rb") as response_file:
+        return response_file.read()  # type: ignore  # we assume the dev correctly set up the resource file
+
+
+def create_record_builder(
+    response_template: Dict[str, Any],
+    records_path: Union[FieldPath, NestedPath],
+    record_id_path: Optional[Path] = None,
+    record_cursor_path: Optional[Union[FieldPath, NestedPath]] = None,
+) -> RecordBuilder:
+    """
+    This will use the first record define at `records_path` as a template for the records. If more records are defined, they will be ignored
+    """
+    try:
+        record_template = records_path.extract(response_template)[0]
+        if not record_template:
+            raise ValueError(
+                f"Could not extract any record from template at path `{records_path}`. "
+                f"Please fix the template to provide a record sample or fix `records_path`."
+            )
+        return RecordBuilder(record_template, record_id_path, record_cursor_path)
+    except (IndexError, KeyError):
+        raise ValueError(
+            f"Error while extracting records at path `{records_path}` from response template `{response_template}`"
+        )
+
+
+def create_response_builder(
+    response_template: Dict[str, Any],
+    records_path: Union[FieldPath, NestedPath],
+    pagination_strategy: Optional[PaginationStrategy] = None,
+) -> HttpResponseBuilder:
+    return HttpResponseBuilder(response_template, records_path, pagination_strategy)

airbyte_cdk/test/state_builder.py

@@ -0,0 +1,33 @@
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
+
+from typing import Any, List
+
+from airbyte_cdk.models import (
+    AirbyteStateBlob,
+    AirbyteStateMessage,
+    AirbyteStateType,
+    AirbyteStreamState,
+    StreamDescriptor,
+)
+
+
+class StateBuilder:
+    def __init__(self) -> None:
+        self._state: List[AirbyteStateMessage] = []
+
+    def with_stream_state(self, stream_name: str, state: Any) -> "StateBuilder":
+        self._state.append(
+            AirbyteStateMessage(
+                type=AirbyteStateType.STREAM,
+                stream=AirbyteStreamState(
+                    stream_state=state
+                    if isinstance(state, AirbyteStateBlob)
+                    else AirbyteStateBlob(state),
+                    stream_descriptor=StreamDescriptor(**{"name": stream_name}),
+                ),
+            )
+        )
+        return self
+
+    def build(self) -> List[AirbyteStateMessage]:
+        return self._state

airbyte_cdk/test/utils/__init__.py

@@ -0,0 +1 @@
+# Copyright (c) 2024 Airbyte, Inc., all rights reserved.

airbyte_cdk/test/utils/data.py

@@ -0,0 +1,24 @@
+# Copyright (c) 2024 Airbyte, Inc., all rights reserved.
+
+from pydantic import FilePath
+
+
+def get_unit_test_folder(execution_folder: str) -> FilePath:
+    path = FilePath(execution_folder)
+    while path.name != "unit_tests":
+        if path.name == path.root or path.name == path.drive:
+            raise ValueError(
+                f"Could not find `unit_tests` folder as a parent of {execution_folder}"
+            )
+        path = path.parent
+    return path
+
+
+def read_resource_file_contents(resource: str, test_location: str) -> str:
+    """Read the contents of a test data file from the test resource folder."""
+    file_path = str(
+        get_unit_test_folder(test_location) / "resource" / "http" / "response" / f"{resource}"
+    )
+    with open(file_path) as f:
+        response = f.read()
+    return response

airbyte_cdk/test/utils/http_mocking.py

@@ -0,0 +1,16 @@
+# Copyright (c) 2024 Airbyte, Inc., all rights reserved.
+
+import re
+from typing import Any, Mapping
+
+from requests_mock import Mocker
+
+
+def register_mock_responses(
+    mocker: Mocker, http_calls: list[Mapping[str, Mapping[str, Any]]]
+) -> None:
+    """Register a list of HTTP request-response pairs."""
+    for call in http_calls:
+        request, response = call["request"], call["response"]
+        matcher = re.compile(request["url"]) if request["is_regex"] else request["url"]
+        mocker.register_uri(request["method"], matcher, **response)

airbyte_cdk/test/utils/manifest_only_fixtures.py

@@ -0,0 +1,59 @@
+# Copyright (c) 2024 Airbyte, Inc., all rights reserved.
+
+
+import importlib.util
+from pathlib import Path
+from types import ModuleType
+
+import pytest
+
+# The following fixtures are used to load a manifest-only connector's components module and manifest file.
+# They can be accessed from any test file in the connector's unit_tests directory by importing them as follows:
+
+# from airbyte_cdk.test.utils.manifest_only_fixtures import components_module, connector_dir, manifest_path
+
+# individual components can then be referenced as: components_module.<CustomComponentClass>
+
+
+@pytest.fixture(scope="session")
+def connector_dir(request: pytest.FixtureRequest) -> Path:
+    """Return the connector's root directory."""
+
+    current_dir = Path(request.config.invocation_params.dir)
+
+    # If the tests are run locally from the connector's unit_tests directory, return the parent (connector) directory
+    if current_dir.name == "unit_tests":
+        return current_dir.parent
+    # In CI, the tests are run from the connector directory itself
+    return current_dir
+
+
+@pytest.fixture(scope="session")
+def components_module(connector_dir: Path) -> ModuleType | None:
+    """Load and return the components module from the connector directory.
+
+    This assumes the components module is located at <connector_dir>/components.py.
+    """
+    components_path = connector_dir / "components.py"
+    if not components_path.exists():
+        return None
+
+    components_spec = importlib.util.spec_from_file_location("components", components_path)
+    if components_spec is None:
+        return None
+
+    components_module = importlib.util.module_from_spec(components_spec)
+    if components_spec.loader is None:
+        return None
+
+    components_spec.loader.exec_module(components_module)
+    return components_module
+
+
+@pytest.fixture(scope="session")
+def manifest_path(connector_dir: Path) -> Path:
+    """Return the path to the connector's manifest file."""
+    path = connector_dir / "manifest.yaml"
+    if not path.exists():
+        raise FileNotFoundError(f"Manifest file not found at {path}")
+    return path