airbyte-cdk 6.48.7.dev2__py3-none-any.whl → 6.48.8__py3-none-any.whl

airbyte_cdk/test/standard_tests/_job_runner.py

@@ -56,12 +56,15 @@ class IConnector(Protocol):
 
 def run_test_job(
     connector: IConnector | type[IConnector] | Callable[[], IConnector],
-    verb: Literal["read", "check", "discover"],
-    test_scenario: ConnectorTestScenario,
+    verb: Literal["spec", "read", "check", "discover"],
     *,
+    test_scenario: ConnectorTestScenario | None = None,
     catalog: ConfiguredAirbyteCatalog | dict[str, Any] | None = None,
 ) -> entrypoint_wrapper.EntrypointOutput:
     """Run a test scenario from provided CLI args and return the result."""
+    # Use default (empty) scenario if not provided:
+    test_scenario = test_scenario or ConnectorTestScenario()
+
     if not connector:
         raise ValueError("Connector is required")
 
@@ -81,14 +84,14 @@ def run_test_job(
         )
 
     args: list[str] = [verb]
-    if test_scenario.config_path:
-        args += ["--config", str(test_scenario.config_path)]
-    elif test_scenario.config_dict:
+    config_dict = test_scenario.get_config_dict(empty_if_missing=True)
+    if config_dict and verb != "spec":
+        # Write the config to a temp json file and pass the path to the file as an argument.
         config_path = (
             Path(tempfile.gettempdir()) / "airbyte-test" / f"temp_config_{uuid.uuid4().hex}.json"
         )
         config_path.parent.mkdir(parents=True, exist_ok=True)
-        config_path.write_text(orjson.dumps(test_scenario.config_dict).decode())
+        config_path.write_text(orjson.dumps(config_dict).decode())
         args += ["--config", str(config_path)]
 
     catalog_path: Path | None = None

airbyte_cdk/test/standard_tests/connector_base.py

@@ -24,7 +24,7 @@ from airbyte_cdk.test.standard_tests._job_runner import IConnector, run_test_job
 from airbyte_cdk.test.standard_tests.models import (
     ConnectorTestScenario,
 )
-from airbyte_cdk.test.standard_tests.test_resources import (
+from airbyte_cdk.utils.connector_paths import (
     ACCEPTANCE_TEST_CONFIG,
     find_connector_root,
 )
@@ -89,7 +89,7 @@ class ConnectorTestSuiteBase(abc.ABC):
     @classmethod
     def create_connector(
         cls,
-        scenario: ConnectorTestScenario,
+        scenario: ConnectorTestScenario | None,
     ) -> IConnector:
         """Instantiate the connector class."""
         connector = cls.connector  # type: ignore
@@ -147,28 +147,35 @@ class ConnectorTestSuiteBase(abc.ABC):
         This has to be a separate function because pytest does not allow
         parametrization of fixtures with arguments from the test class itself.
         """
-        category = "connection"
+        categories = ["connection", "spec"]
         all_tests_config = yaml.safe_load(cls.acceptance_test_config_path.read_text())
         if "acceptance_tests" not in all_tests_config:
             raise ValueError(
                 f"Acceptance tests config not found in {cls.acceptance_test_config_path}."
                 f" Found only: {str(all_tests_config)}."
             )
-        if category not in all_tests_config["acceptance_tests"]:
-            return []
-        if "tests" not in all_tests_config["acceptance_tests"][category]:
-            raise ValueError(f"No tests found for category {category}")
-
-        tests_scenarios = [
-            ConnectorTestScenario.model_validate(test)
-            for test in all_tests_config["acceptance_tests"][category]["tests"]
-            if "iam_role" not in test["config_path"]
-        ]
+
+        test_scenarios: list[ConnectorTestScenario] = []
+        for category in categories:
+            if (
+                category not in all_tests_config["acceptance_tests"]
+                or "tests" not in all_tests_config["acceptance_tests"][category]
+            ):
+                continue
+
+            test_scenarios.extend(
+                [
+                    ConnectorTestScenario.model_validate(test)
+                    for test in all_tests_config["acceptance_tests"][category]["tests"]
+                    if "config_path" in test and "iam_role" not in test["config_path"]
+                ]
+            )
+
         connector_root = cls.get_connector_root_dir().absolute()
-        for test in tests_scenarios:
+        for test in test_scenarios:
             if test.config_path:
                 test.config_path = connector_root / test.config_path
             if test.configured_catalog_path:
                 test.configured_catalog_path = connector_root / test.configured_catalog_path
 
-        return tests_scenarios
+        return test_scenarios

airbyte_cdk/test/standard_tests/declarative_sources.py

@@ -12,7 +12,7 @@ from airbyte_cdk.sources.declarative.concurrent_declarative_source import (
 from airbyte_cdk.test.standard_tests._job_runner import IConnector
 from airbyte_cdk.test.standard_tests.models import ConnectorTestScenario
 from airbyte_cdk.test.standard_tests.source_base import SourceTestSuiteBase
-from airbyte_cdk.test.standard_tests.test_resources import MANIFEST_YAML
+from airbyte_cdk.utils.connector_paths import MANIFEST_YAML
 
 
 def md5_checksum(file_path: Path) -> str:
@@ -64,7 +64,7 @@ class DeclarativeSourceTestSuite(SourceTestSuiteBase):
     @classmethod
     def create_connector(
         cls,
-        scenario: ConnectorTestScenario,
+        scenario: ConnectorTestScenario | None,
     ) -> IConnector:
         """Create a connector scenario for the test suite.
 
@@ -73,9 +73,13 @@ class DeclarativeSourceTestSuite(SourceTestSuiteBase):
 
         Subclasses should not need to override this method.
         """
-        config: dict[str, Any] = scenario.get_config_dict()
-
+        scenario = scenario or ConnectorTestScenario()  # Use default (empty) scenario if None
         manifest_dict = yaml.safe_load(cls.manifest_yaml_path.read_text())
+        config = {
+            "__injected_manifest": manifest_dict,
+        }
+        config.update(scenario.get_config_dict(empty_if_missing=True))
+
         if cls.components_py_path and cls.components_py_path.exists():
             os.environ["AIRBYTE_ENABLE_UNSAFE_CODE"] = "true"
             config["__injected_components_py"] = cls.components_py_path.read_text()

airbyte_cdk/test/standard_tests/models/scenario.py

@@ -43,18 +43,29 @@ class ConnectorTestScenario(BaseModel):
     file_types: AcceptanceTestFileTypes | None = None
     status: Literal["succeed", "failed"] | None = None
 
-    def get_config_dict(self) -> dict[str, Any]:
+    def get_config_dict(
+        self,
+        *,
+        empty_if_missing: bool,
+    ) -> dict[str, Any]:
         """Return the config dictionary.
 
         If a config dictionary has already been loaded, return it. Otherwise, load
         the config file and return the dictionary.
+
+        If `self.config_dict` and `self.config_path` are both `None`:
+        - return an empty dictionary if `empty_if_missing` is True
+        - raise a ValueError if `empty_if_missing` is False
         """
-        if self.config_dict:
+        if self.config_dict is not None:
             return self.config_dict
 
-        if self.config_path:
+        if self.config_path is not None:
             return cast(dict[str, Any], yaml.safe_load(self.config_path.read_text()))
 
+        if empty_if_missing:
+            return {}
+
         raise ValueError("No config dictionary or path provided.")
 
     @property

airbyte_cdk/test/standard_tests/source_base.py

@@ -64,6 +64,30 @@ class SourceTestSuiteBase(ConnectorTestSuiteBase):
             test_scenario=scenario,
         )
 
+    def test_spec(self) -> None:
+        """Standard test for `spec`.
+
+        This test does not require a `scenario` input, since `spec`
+        does not require any inputs.
+
+        We assume `spec` should always succeed and it should always generate
+        a valid `SPEC` message.
+
+        Note: the parsing of messages by type also implicitly validates that
+        the generated `SPEC` message is valid JSON.
+        """
+        result = run_test_job(
+            verb="spec",
+            test_scenario=None,
+            connector=self.create_connector(scenario=None),
+        )
+        # If an error occurs, it will be raised above.
+
+        assert len(result.spec_messages) == 1, (
+            "Expected exactly 1 spec message but got {len(result.spec_messages)}",
+            result.errors,
+        )
+
     def test_basic_read(
         self,
         scenario: ConnectorTestScenario,

airbyte_cdk/test/standard_tests/util.py

@@ -12,7 +12,7 @@ from airbyte_cdk.test.standard_tests.declarative_sources import (
 )
 from airbyte_cdk.test.standard_tests.destination_base import DestinationTestSuiteBase
 from airbyte_cdk.test.standard_tests.source_base import SourceTestSuiteBase
-from airbyte_cdk.test.standard_tests.test_resources import (
+from airbyte_cdk.utils.connector_paths import (
     METADATA_YAML,
     find_connector_root_from_name,
 )

airbyte_cdk/utils/connector_paths.py

@@ -0,0 +1,223 @@
+# Copyright (c) 2025 Airbyte, Inc., all rights reserved.
+"""Resources and utilities for locating Airbyte Connectors."""
+
+from contextlib import suppress
+from pathlib import Path
+
+ACCEPTANCE_TEST_CONFIG = "acceptance-test-config.yml"
+MANIFEST_YAML = "manifest.yaml"
+METADATA_YAML = "metadata.yaml"
+
+
+def resolve_airbyte_repo_root(
+    from_dir: Path,
+) -> Path:
+    """Resolve the Airbyte repository root directory.
+
+    This function will resolve the Airbyte repository root directory based on the
+    current working directory. If the current working directory is not within the
+    Airbyte repository, it will look for the 'airbyte' or 'airbyte-enterprise'
+    directory in the parent directories.
+
+    Sibling directories are also considered, so if the working directory is '~/repos/airbyte-cdk',
+    it will find the 'airbyte' directory in '~/repos/airbyte'. The 'airbyte' directory
+    will be preferred over 'airbyte-enterprise' if both are present as sibling directories and
+    neither is a parent directory.
+
+    If we reach the root of the filesystem without finding the 'airbyte' directory,
+    a FileNotFoundError will be raised.
+
+    Raises:
+        FileNotFoundError: If the Airbyte repository root directory cannot be found.
+    """
+
+    def _is_airbyte_repo_root(path: Path) -> bool:
+        """Check if the given path is the Airbyte repository root."""
+        return all(
+            [
+                (path.name == "airbyte" or path.name == "airbyte-enterprise"),
+                (path / "airbyte-integrations").is_dir(),
+            ]
+        )
+
+    def _find_in_adjacent_dirs(current_dir: Path) -> Path | None:
+        """Check if 'airbyte' or 'airbyte-enterprise' exists as a sibling, parent, or child."""
+        # Check parents
+        parent_dir = current_dir.parent
+        if _is_airbyte_repo_root(parent_dir):
+            return parent_dir
+
+        # Check siblings
+        if _is_airbyte_repo_root(parent_dir / "airbyte"):
+            return parent_dir / "airbyte"
+        if _is_airbyte_repo_root(parent_dir / "airbyte-enterprise"):
+            return parent_dir / "airbyte-enterprise"
+
+        # Check children only if no "airbyte" or "airbyte-enterprise" in parent
+        if not any(
+            [
+                "airbyte" in current_dir.parts,
+                "airbyte-enterprise" in current_dir.parts,
+            ]
+        ):
+            if _is_airbyte_repo_root(current_dir / "airbyte"):
+                return current_dir / "airbyte"
+            if _is_airbyte_repo_root(current_dir / "airbyte-enterprise"):
+                return current_dir / "airbyte-enterprise"
+
+        return None
+
+    current_dir = from_dir.resolve().absolute()
+    while current_dir != current_dir.parent:  # abort when we reach file system root
+        found_dir = _find_in_adjacent_dirs(current_dir)
+        if found_dir:
+            return found_dir
+
+        # Move up one directory
+        current_dir = current_dir.parent
+
+    raise FileNotFoundError(
+        f"Could not find the Airbyte repository root directory. Current directory: {from_dir}"
+    )
+
+
+def resolve_connector_name_and_directory(
+    connector_ref: str | Path | None = None,
+    *,
+    connector_directory: Path | None = None,
+) -> tuple[str, Path]:
+    """Resolve the connector name and directory.
+
+    This function will resolve the connector name and directory based on the provided
+    reference. If no input ref is provided, it will look within the
+    current working directory. If the current working directory is not a connector
+    directory (e.g. starting with 'source-') and no connector name or path is provided,
+    the process will fail.
+    If ref is sent as a string containing "/" or "\\", it will be treated as a path to the
+    connector directory.
+
+    raises:
+        ValueError: If the connector name or directory cannot be resolved.
+        FileNotFoundError: If the connector directory does not exist or cannot be found.
+    """
+    connector_name: str | None = None
+
+    # Resolve connector_ref to connector_name or connector_directory (if provided)
+    if connector_ref:
+        if isinstance(connector_ref, str):
+            if "/" in connector_ref or "\\" in connector_ref:
+                # If the connector name is a path, treat it as a directory
+                connector_directory = Path(connector_ref)
+            else:
+                # Otherwise, treat it as a connector name
+                connector_name = connector_ref
+        elif isinstance(connector_ref, Path):
+            connector_directory = connector_ref
+        else:
+            raise ValueError(
+                "connector_ref must be a string or Path. "
+                f"Received type '{type(connector_ref).__name__}': {connector_ref!r}",
+            )
+
+    if not connector_directory:
+        if connector_name:
+            connector_directory = find_connector_root_from_name(connector_name)
+        else:
+            cwd = Path().resolve().absolute()
+            if cwd.name.startswith("source-") or cwd.name.startswith("destination-"):
+                connector_directory = cwd
+            else:
+                raise ValueError(
+                    "The 'connector' input must be provided if not "
+                    "running from a connector directory. "
+                    f"Could not infer connector directory from: {cwd}"
+                )
+
+    if not connector_name:
+        connector_name = connector_directory.name
+
+    if connector_directory:
+        connector_directory = connector_directory.resolve().absolute()
+    elif connector_name:
+        connector_directory = find_connector_root_from_name(connector_name)
+    else:
+        raise ValueError(
+            f"Could not infer connector_name or connector_directory from input ref: {connector_ref}",
+        )
+
+    return connector_name, connector_directory
+
+
+def resolve_connector_name(
+    connector_directory: Path,
+) -> str:
+    """Resolve the connector name.
+
+    This function will resolve the connector name based on the provided connector directory.
+    If the current working directory is not a connector directory
+    (e.g. starting with 'source-'), the process will fail.
+
+    Raises:
+        FileNotFoundError: If the connector directory does not exist or cannot be found.
+    """
+    if not connector_directory:
+        raise FileNotFoundError(
+            "Connector directory does not exist or cannot be found. Please provide a valid "
+            "connector directory."
+        )
+    connector_name = connector_directory.absolute().name
+    if not connector_name.startswith("source-") and not connector_name.startswith("destination-"):
+        raise ValueError(
+            f"Connector directory '{connector_name}' does not look like a valid connector directory. "
+            f"Full path: {connector_directory.absolute()}"
+        )
+    return connector_name
+
+
+def find_connector_root(from_paths: list[Path]) -> Path:
+    """Find the root directory of the connector."""
+    for path in from_paths:
+        # 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, *path.parents]:
+            if (parent / METADATA_YAML).exists():
+                return parent
+            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 the provided directories: "
+        f"'{str(from_paths)}'."
+    )
+
+
+def find_connector_root_from_name(connector_name: str) -> Path:
+    """Find the root directory of the connector from its name."""
+    with suppress(FileNotFoundError):
+        return find_connector_root([Path(connector_name)])
+
+    # If the connector name is not found, check if we are in the airbyte monorepo
+    # and try to find the connector root from the current directory.
+
+    cwd: Path = Path().absolute()
+
+    try:
+        airbyte_repo_root: Path = resolve_airbyte_repo_root(cwd)
+    except FileNotFoundError as ex:
+        raise FileNotFoundError(
+            "Could not find connector root directory relative and we are not in the airbyte repo."
+        ) from ex
+
+    expected_connector_dir: Path = (
+        airbyte_repo_root / "airbyte-integrations" / "connectors" / connector_name
+    )
+    if not expected_connector_dir.exists():
+        raise FileNotFoundError(
+            f"Could not find connector directory '{expected_connector_dir}' relative to the airbyte repo."
+        )
+
+    return expected_connector_dir

airbyte_cdk/utils/docker.py

@@ -12,14 +12,10 @@ from enum import Enum
 from pathlib import Path
 
 import click
+import requests
 
 from airbyte_cdk.models.connector_metadata import ConnectorLanguage, MetadataFile
-from airbyte_cdk.utils.docker_image_templates import (
-    DOCKERIGNORE_TEMPLATE,
-    JAVA_CONNECTOR_DOCKERFILE_TEMPLATE,
-    MANIFEST_ONLY_DOCKERFILE_TEMPLATE,
-    PYTHON_CONNECTOR_DOCKERFILE_TEMPLATE,
-)
+from airbyte_cdk.utils.connector_paths import resolve_airbyte_repo_root
 
 
 @dataclass(kw_only=True)
@@ -145,6 +141,7 @@ def build_connector_image(
     tag: str,
     primary_arch: ArchEnum = ArchEnum.ARM64,  # Assume MacBook M series by default
     no_verify: bool = False,
+    dockerfile_override: Path | None = None,
 ) -> None:
     """Build a connector Docker image.
 
@@ -167,10 +164,36 @@ def build_connector_image(
         ConnectorImageBuildError: If the image build or tag operation fails.
     """
     connector_kebab_name = connector_name
-    connector_snake_name = connector_kebab_name.replace("-", "_")
 
-    dockerfile_path = connector_directory / "build" / "docker" / "Dockerfile"
-    dockerignore_path = connector_directory / "build" / "docker" / "Dockerfile.dockerignore"
+    if dockerfile_override:
+        dockerfile_path = dockerfile_override
+    else:
+        dockerfile_path = connector_directory / "build" / "docker" / "Dockerfile"
+        dockerignore_path = connector_directory / "build" / "docker" / "Dockerfile.dockerignore"
+        try:
+            dockerfile_text, dockerignore_text = get_dockerfile_templates(
+                metadata=metadata,
+                connector_directory=connector_directory,
+            )
+        except FileNotFoundError:
+            # If the Dockerfile and .dockerignore are not found in the connector directory,
+            # download the templates from the Airbyte repo. This is a fallback
+            # in case the Airbyte repo not checked out locally.
+            try:
+                dockerfile_text, dockerignore_text = _download_dockerfile_defs(
+                    connector_language=metadata.data.language,
+                )
+            except requests.HTTPError as e:
+                raise ConnectorImageBuildError(
+                    build_args=[],
+                    error_text=(
+                        "Could not locate local dockerfile templates and "
+                        f"failed to download Dockerfile templates from github: {e}"
+                    ),
+                ) from e
+
+        dockerfile_path.write_text(dockerfile_text)
+        dockerignore_path.write_text(dockerignore_text)
 
     extra_build_script: str = ""
     build_customization_path = connector_directory / "build_customization.py"
@@ -185,14 +208,9 @@ def build_connector_image(
         )
 
     base_image = metadata.data.connectorBuildOptions.baseImage
-
-    dockerfile_path.write_text(get_dockerfile_template(metadata))
-    dockerignore_path.write_text(DOCKERIGNORE_TEMPLATE)
-
     build_args: dict[str, str | None] = {
         "BASE_IMAGE": base_image,
-        "CONNECTOR_SNAKE_NAME": connector_snake_name,
-        "CONNECTOR_KEBAB_NAME": connector_kebab_name,
+        "CONNECTOR_NAME": connector_kebab_name,
         "EXTRA_BUILD_SCRIPT": extra_build_script,
     }
 
@@ -246,31 +264,100 @@ def build_connector_image(
         sys.exit(0)
 
 
-def get_dockerfile_template(
+def _download_dockerfile_defs(
+    connector_language: ConnectorLanguage,
+) -> tuple[str, str]:
+    """Download the Dockerfile and .dockerignore templates for the specified connector language.
+
+    We use the requests library to download from the master branch hosted on GitHub.
+
+    Args:
+        connector_language: The language of the connector.
+
+    Returns:
+        A tuple containing the Dockerfile and .dockerignore templates as strings.
+
+    Raises:
+        ValueError: If the connector language is not supported.
+        requests.HTTPError: If the download fails.
+    """
+    print("Downloading Dockerfile and .dockerignore templates from GitHub...")
+    # Map ConnectorLanguage to template directory
+    language_to_template_suffix = {
+        ConnectorLanguage.PYTHON: "python-connector",
+        ConnectorLanguage.JAVA: "java-connector",
+        ConnectorLanguage.MANIFEST_ONLY: "manifest-only-connector",
+    }
+
+    if connector_language not in language_to_template_suffix:
+        raise ValueError(f"Unsupported connector language: {connector_language}")
+
+    template_suffix = language_to_template_suffix[connector_language]
+    base_url = f"https://github.com/airbytehq/airbyte/raw/master/docker-images/"
+
+    dockerfile_url = f"{base_url}/Dockerfile.{template_suffix}"
+    dockerignore_url = f"{base_url}/Dockerfile.{template_suffix}.dockerignore"
+
+    dockerfile_resp = requests.get(dockerfile_url)
+    dockerfile_resp.raise_for_status()
+    dockerfile_text = dockerfile_resp.text
+
+    dockerignore_resp = requests.get(dockerignore_url)
+    dockerignore_resp.raise_for_status()
+    dockerignore_text = dockerignore_resp.text
+
+    return dockerfile_text, dockerignore_text
+
+
+def get_dockerfile_templates(
     metadata: MetadataFile,
-) -> str:
+    connector_directory: Path,
+) -> tuple[str, str]:
     """Get the Dockerfile template for the connector.
 
     Args:
         metadata: The metadata of the connector.
         connector_name: The name of the connector.
 
+    Raises:
+        ValueError: If the connector language is not supported.
+        FileNotFoundError: If the Dockerfile or .dockerignore is not found.
+
     Returns:
-        The Dockerfile template as a string.
+        A tuple containing the Dockerfile and .dockerignore templates as strings.
     """
-    if metadata.data.language == ConnectorLanguage.PYTHON:
-        return PYTHON_CONNECTOR_DOCKERFILE_TEMPLATE
-
-    if metadata.data.language == ConnectorLanguage.MANIFEST_ONLY:
-        return MANIFEST_ONLY_DOCKERFILE_TEMPLATE
-
-    if metadata.data.language == ConnectorLanguage.JAVA:
-        return JAVA_CONNECTOR_DOCKERFILE_TEMPLATE
+    if metadata.data.language not in [
+        ConnectorLanguage.PYTHON,
+        ConnectorLanguage.MANIFEST_ONLY,
+        ConnectorLanguage.JAVA,
+    ]:
+        raise ValueError(
+            f"Unsupported connector language: {metadata.data.language}. "
+            "Please check the connector's metadata file."
+        )
 
-    raise ValueError(
-        f"Unsupported connector language: {metadata.data.language}. "
-        "Please check the connector's metadata file."
+    airbyte_repo_root = resolve_airbyte_repo_root(
+        from_dir=connector_directory,
+    )
+    # airbyte_repo_root successfully resolved
+    dockerfile_path = (
+        airbyte_repo_root / "docker-images" / f"Dockerfile.{metadata.data.language.value}-connector"
     )
+    dockerignore_path = (
+        airbyte_repo_root
+        / "docker-images"
+        / f"Dockerfile.{metadata.data.language.value}-connector.dockerignore"
+    )
+    if not dockerfile_path.exists():
+        raise FileNotFoundError(
+            f"Dockerfile for {metadata.data.language.value} connector not found at {dockerfile_path}"
+        )
+    if not dockerignore_path.exists():
+        raise FileNotFoundError(
+            f".dockerignore for {metadata.data.language.value} connector not found at {dockerignore_path}"
+        )
+
+    return dockerfile_path.read_text(), dockerignore_path.read_text()
 
 
 def run_docker_command(

{airbyte_cdk-6.48.7.dev2.dist-info → airbyte_cdk-6.48.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: airbyte-cdk
-Version: 6.48.7.dev2
+Version: 6.48.8
 Summary: A framework for writing Airbyte Connectors.
 Home-page: https://airbyte.com
 License: MIT
@@ -23,7 +23,7 @@ Provides-Extra: sql
 Provides-Extra: vector-db-based
 Requires-Dist: Jinja2 (>=3.1.2,<3.2.0)
 Requires-Dist: PyYAML (>=6.0.1,<7.0.0)
-Requires-Dist: airbyte-protocol-models-dataclasses (==0.15.0.dev1746621859)
+Requires-Dist: airbyte-protocol-models-dataclasses (>=0.15,<0.16)
 Requires-Dist: anyascii (>=0.3.2,<0.4.0)
 Requires-Dist: avro (>=1.11.2,<1.13.0) ; extra == "file-based"
 Requires-Dist: backoff