airbyte-cdk 6.6.2__tar.gz → 6.6.4__tar.gz

{airbyte_cdk-6.6.2 → airbyte_cdk-6.6.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: airbyte-cdk
-Version: 6.6.2
+Version: 6.6.4
 Summary: A framework for writing Airbyte Connectors.
 Home-page: https://airbyte.com
 License: MIT
@@ -37,7 +37,7 @@ Requires-Dist: fastavro (>=1.8.0,<1.9.0) ; extra == "file-based"
 Requires-Dist: genson (==1.3.0)
 Requires-Dist: isodate (>=0.6.1,<0.7.0)
 Requires-Dist: jsonref (>=0.2,<0.3)
-Requires-Dist: jsonschema (>=3.2.0,<3.3.0)
+Requires-Dist: jsonschema (>=4.17.3,<4.18.0)
 Requires-Dist: langchain (==0.1.16) ; extra == "vector-db-based"
 Requires-Dist: langchain_core (==0.1.42)
 Requires-Dist: markdown ; extra == "file-based"
@@ -60,6 +60,7 @@ Requires-Dist: python-dateutil
 Requires-Dist: python-snappy (==0.7.3) ; extra == "file-based"
 Requires-Dist: python-ulid (>=3.0.0,<4.0.0)
 Requires-Dist: pytz (==2024.1)
+Requires-Dist: rapidfuzz (>=3.10.1,<4.0.0)
 Requires-Dist: requests
 Requires-Dist: requests_cache
 Requires-Dist: serpyco-rs (>=1.10.2,<2.0.0)

airbyte_cdk-6.6.4/airbyte_cdk/cli/source_declarative_manifest/__init__.py

@@ -0,0 +1,6 @@
+from airbyte_cdk.cli.source_declarative_manifest._run import run
+
+
+__all__ = [
+    "run",
+]

airbyte_cdk-6.6.4/airbyte_cdk/cli/source_declarative_manifest/_run.py

@@ -0,0 +1,223 @@
+# Copyright (c) 2024 Airbyte, Inc., all rights reserved.
+"""Defines the `source-declarative-manifest` connector, which installs alongside CDK.
+
+This file was originally imported from the dedicated connector directory, under the
+`airbyte` monorepo.
+
+Usage:
+
+```
+pipx install airbyte-cdk
+source-declarative-manifest --help
+source-declarative-manifest spec
+...
+```
+"""
+
+from __future__ import annotations
+
+import json
+import pkgutil
+import sys
+import traceback
+from collections.abc import Mapping
+from datetime import datetime
+from pathlib import Path
+from typing import Any, cast
+
+from airbyte_cdk.entrypoint import AirbyteEntrypoint, launch
+from airbyte_cdk.models import (
+    AirbyteErrorTraceMessage,
+    AirbyteMessage,
+    AirbyteMessageSerializer,
+    AirbyteStateMessage,
+    AirbyteTraceMessage,
+    ConfiguredAirbyteCatalog,
+    ConnectorSpecificationSerializer,
+    TraceType,
+    Type,
+)
+from airbyte_cdk.sources.declarative.concurrent_declarative_source import (
+    ConcurrentDeclarativeSource,
+)
+from airbyte_cdk.sources.declarative.yaml_declarative_source import YamlDeclarativeSource
+from airbyte_cdk.sources.source import TState
+from orjson import orjson
+
+
+class SourceLocalYaml(YamlDeclarativeSource):
+    """
+    Declarative source defined by a yaml file in the local filesystem
+    """
+
+    def __init__(
+        self,
+        catalog: ConfiguredAirbyteCatalog | None,
+        config: Mapping[str, Any] | None,
+        state: TState,
+        **kwargs: Any,
+    ) -> None:
+        """
+        HACK!
+            Problem: YamlDeclarativeSource relies on the calling module name/path to find the yaml file.
+            Implication: If you call YamlDeclarativeSource directly it will look for the yaml file in the wrong place. (e.g. the airbyte-cdk package)
+            Solution: Subclass YamlDeclarativeSource from the same location as the manifest to load.
+
+            When can we remove this?
+                When the airbyte-cdk is updated to not rely on the calling module name/path to find the yaml file.
+                When all manifest connectors are updated to use the new airbyte-cdk.
+                When all manifest connectors are updated to use the source-declarative-manifest as the base image.
+        """
+        super().__init__(
+            catalog=catalog,
+            config=config,
+            state=state,
+            path_to_yaml="manifest.yaml",
+        )
+
+
+def _is_local_manifest_command(args: list[str]) -> bool:
+    # Check for a local manifest.yaml file
+    return Path("/airbyte/integration_code/source_declarative_manifest/manifest.yaml").exists()
+
+
+def handle_command(args: list[str]) -> None:
+    if _is_local_manifest_command(args):
+        handle_local_manifest_command(args)
+    else:
+        handle_remote_manifest_command(args)
+
+
+def _get_local_yaml_source(args: list[str]) -> SourceLocalYaml:
+    try:
+        config, catalog, state = _parse_inputs_into_config_catalog_state(args)
+        return SourceLocalYaml(config=config, catalog=catalog, state=state)
+    except Exception as error:
+        print(
+            orjson.dumps(
+                AirbyteMessageSerializer.dump(
+                    AirbyteMessage(
+                        type=Type.TRACE,
+                        trace=AirbyteTraceMessage(
+                            type=TraceType.ERROR,
+                            emitted_at=int(datetime.now().timestamp() * 1000),
+                            error=AirbyteErrorTraceMessage(
+                                message=f"Error starting the sync. This could be due to an invalid configuration or catalog. Please contact Support for assistance. Error: {error}",
+                                stack_trace=traceback.format_exc(),
+                            ),
+                        ),
+                    )
+                )
+            ).decode()
+        )
+        raise error
+
+
+def handle_local_manifest_command(args: list[str]) -> None:
+    source = _get_local_yaml_source(args)
+    launch(
+        source=source,
+        args=args,
+    )
+
+
+def handle_remote_manifest_command(args: list[str]) -> None:
+    """Overrides the spec command to return the generalized spec for the declarative manifest source.
+
+    This is different from a typical low-code, but built and published separately source built as a ManifestDeclarativeSource,
+    because that will have a spec method that returns the spec for that specific source. Other than spec,
+    the generalized connector behaves the same as any other, since the manifest is provided in the config.
+    """
+    if args[0] == "spec":
+        json_spec = pkgutil.get_data(
+            "airbyte_cdk.cli.source_declarative_manifest",
+            "spec.json",
+        )
+        if json_spec is None:
+            raise FileNotFoundError(
+                "Could not find `spec.json` file for source-declarative-manifest"
+            )
+
+        spec_obj = json.loads(json_spec)
+        spec = ConnectorSpecificationSerializer.load(spec_obj)
+
+        message = AirbyteMessage(type=Type.SPEC, spec=spec)
+        print(AirbyteEntrypoint.airbyte_message_to_string(message))
+    else:
+        source = create_declarative_source(args)
+        launch(
+            source=source,
+            args=args,
+        )
+
+
+def create_declarative_source(args: list[str]) -> ConcurrentDeclarativeSource:
+    """Creates the source with the injected config.
+
+    This essentially does what other low-code sources do at build time, but at runtime,
+    with a user-provided manifest in the config. This better reflects what happens in the
+    connector builder.
+    """
+    try:
+        config, catalog, state = _parse_inputs_into_config_catalog_state(args)
+        if "__injected_declarative_manifest" not in config:
+            raise ValueError(
+                f"Invalid config: `__injected_declarative_manifest` should be provided at the root of the config but config only has keys {list(config.keys())}"
+            )
+        return ConcurrentDeclarativeSource(
+            config=config,
+            catalog=catalog,
+            state=state,
+            source_config=cast(dict[str, Any], config["__injected_declarative_manifest"]),
+        )
+    except Exception as error:
+        print(
+            orjson.dumps(
+                AirbyteMessageSerializer.dump(
+                    AirbyteMessage(
+                        type=Type.TRACE,
+                        trace=AirbyteTraceMessage(
+                            type=TraceType.ERROR,
+                            emitted_at=int(datetime.now().timestamp() * 1000),
+                            error=AirbyteErrorTraceMessage(
+                                message=f"Error starting the sync. This could be due to an invalid configuration or catalog. Please contact Support for assistance. Error: {error}",
+                                stack_trace=traceback.format_exc(),
+                            ),
+                        ),
+                    )
+                )
+            ).decode()
+        )
+        raise error
+
+
+def _parse_inputs_into_config_catalog_state(
+    args: list[str],
+) -> tuple[
+    Mapping[str, Any] | None,
+    ConfiguredAirbyteCatalog | None,
+    list[AirbyteStateMessage],
+]:
+    parsed_args = AirbyteEntrypoint.parse_args(args)
+    config = (
+        ConcurrentDeclarativeSource.read_config(parsed_args.config)
+        if hasattr(parsed_args, "config")
+        else None
+    )
+    catalog = (
+        ConcurrentDeclarativeSource.read_catalog(parsed_args.catalog)
+        if hasattr(parsed_args, "catalog")
+        else None
+    )
+    state = (
+        ConcurrentDeclarativeSource.read_state(parsed_args.state)
+        if hasattr(parsed_args, "state")
+        else []
+    )
+
+    return config, catalog, state
+
+
+def run() -> None:
+    args: list[str] = sys.argv[1:]
+    handle_command(args)

airbyte_cdk-6.6.4/airbyte_cdk/cli/source_declarative_manifest/spec.json

@@ -0,0 +1,17 @@
+{
+  "documentationUrl": "https://docs.airbyte.com/integrations/sources/low-code",
+  "connectionSpecification": {
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "title": "Low-code source spec",
+    "type": "object",
+    "required": ["__injected_declarative_manifest"],
+    "additionalProperties": true,
+    "properties": {
+      "__injected_declarative_manifest": {
+        "title": "Low-code manifest",
+        "type": "object",
+        "description": "The low-code manifest that defines the components of the source."
+      }
+    }
+  }
+}

{airbyte_cdk-6.6.2 → airbyte_cdk-6.6.4}/airbyte_cdk/sources/declarative/manifest_declarative_source.py

@@ -5,10 +5,10 @@
 import json
 import logging
 import pkgutil
-import re
 from copy import deepcopy
 from importlib import metadata
-from typing import Any, Dict, Iterator, List, Mapping, Optional, Tuple
+from typing import Any, Dict, Iterator, List, Mapping, Optional
+from packaging.version import Version, InvalidVersion
 
 import yaml
 from airbyte_cdk.models import (
@@ -245,45 +245,54 @@ class ManifestDeclarativeSource(DeclarativeSource):
                 "Validation against json schema defined in declarative_component_schema.yaml schema failed"
             ) from e
 
-        cdk_version = metadata.version("airbyte_cdk")
-        cdk_major, cdk_minor, cdk_patch = self._get_version_parts(cdk_version, "airbyte-cdk")
-        manifest_version = self._source_config.get("version")
-        if manifest_version is None:
+        cdk_version_str = metadata.version("airbyte_cdk")
+        cdk_version = self._parse_version(cdk_version_str, "airbyte-cdk")
+        manifest_version_str = self._source_config.get("version")
+        if manifest_version_str is None:
             raise RuntimeError(
                 "Manifest version is not defined in the manifest. This is unexpected since it should be a required field. Please contact support."
             )
-        manifest_major, manifest_minor, manifest_patch = self._get_version_parts(
-            manifest_version, "manifest"
-        )
+        manifest_version = self._parse_version(manifest_version_str, "manifest")
 
-        if cdk_version.startswith("0.0.0"):
+        if (cdk_version.major, cdk_version.minor, cdk_version.micro) == (0, 0, 0):
             # Skipping version compatibility check on unreleased dev branch
             pass
-        elif cdk_major < manifest_major or (
-            cdk_major == manifest_major and cdk_minor < manifest_minor
+        elif (cdk_version.major, cdk_version.minor) < (
+            manifest_version.major,
+            manifest_version.minor,
         ):
             raise ValidationError(
-                f"The manifest version {manifest_version} is greater than the airbyte-cdk package version ({cdk_version}). Your "
+                f"The manifest version {manifest_version!s} is greater than the airbyte-cdk package version ({cdk_version!s}). Your "
                 f"manifest may contain features that are not in the current CDK version."
             )
-        elif manifest_major == 0 and manifest_minor < 29:
+        elif (manifest_version.major, manifest_version.minor) < (0, 29):
             raise ValidationError(
                 f"The low-code framework was promoted to Beta in airbyte-cdk version 0.29.0 and contains many breaking changes to the "
-                f"language. The manifest version {manifest_version} is incompatible with the airbyte-cdk package version "
-                f"{cdk_version} which contains these breaking changes."
+                f"language. The manifest version {manifest_version!s} is incompatible with the airbyte-cdk package version "
+                f"{cdk_version!s} which contains these breaking changes."
             )
 
     @staticmethod
-    def _get_version_parts(version: str, version_type: str) -> Tuple[int, int, int]:
-        """
-        Takes a semantic version represented as a string and splits it into a tuple of its major, minor, and patch versions.
+    def _parse_version(
+        version: str,
+        version_type: str,
+    ) -> Version:
+        """Takes a semantic version represented as a string and splits it into a tuple.
+
+        The fourth part (prerelease) is not returned in the tuple.
+
+        Returns:
+            Version: the parsed version object
         """
-        version_parts = re.split(r"\.", version)
-        if len(version_parts) != 3 or not all([part.isdigit() for part in version_parts]):
+        try:
+            parsed_version = Version(version)
+        except InvalidVersion as ex:
             raise ValidationError(
-                f"The {version_type} version {version} specified is not a valid version format (ex. 1.2.3)"
-            )
-        return tuple(int(part) for part in version_parts)  # type: ignore # We already verified there were 3 parts and they are all digits
+                f"The {version_type} version '{version}' is not a valid version format."
+            ) from ex
+        else:
+            # No exception
+            return parsed_version
 
     def _stream_configs(self, manifest: Mapping[str, Any]) -> List[Dict[str, Any]]:
         # This has a warning flag for static, but after we finish part 4 we'll replace manifest with self._source_config

airbyte_cdk-6.6.4/airbyte_cdk/test/utils/__init__.py

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

{airbyte_cdk-6.6.2 → airbyte_cdk-6.6.4}/pyproject.toml

@@ -23,7 +23,7 @@ classifiers = [
 keywords = ["airbyte", "connector-development-kit", "cdk"]
 
 # Python CDK uses dynamic versioning: https://github.com/mtkennerly/poetry-dynamic-versioning
-version = "6.6.2"  # Version will be calculated dynamically.
+version = "6.6.4"  # Version will be calculated dynamically.
 
 [tool.poetry-dynamic-versioning]
 enable = false
@@ -40,7 +40,7 @@ genson = "1.3.0"
 isodate = "~0.6.1"
 Jinja2 = "~3.1.2"
 jsonref = "~0.2"
-jsonschema = "~3.2.0"
+jsonschema = "~4.17.3"  # 4.18 has some significant breaking changes: https://github.com/python-jsonschema/jsonschema/releases/tag/v4.18.0
 pandas = "2.2.2"
 pendulum = "<3.0.0"
 psutil = "6.1.0"
@@ -49,6 +49,7 @@ pyrate-limiter = "~3.1.0"
 python-dateutil = "*"
 python-ulid = "^3.0.0"
 PyYAML = "^6.0.1"
+rapidfuzz = "^3.10.1"
 requests = "*"
 requests_cache = "*"
 wcmatch = "10.0"
@@ -104,6 +105,10 @@ sphinx-docs = ["Sphinx", "sphinx-rtd-theme"]
 vector-db-based = ["langchain", "openai", "cohere", "tiktoken"]
 sql = ["sqlalchemy"]
 
+[tool.poetry.scripts]
+
+source-declarative-manifest = "airbyte_cdk.cli.source_declarative_manifest:run"
+
 [tool.isort]
 skip = ["__init__.py"]  # TODO: Remove after this is fixed: https://github.com/airbytehq/airbyte-python-cdk/issues/12