airbyte-cdk 6.60.0.post27.dev16505983549__tar.gz → 6.60.0.post29.dev16508987644__tar.gz

{airbyte_cdk-6.60.0.post27.dev16505983549 → airbyte_cdk-6.60.0.post29.dev16508987644}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: airbyte-cdk
-Version: 6.60.0.post27.dev16505983549
+Version: 6.60.0.post29.dev16508987644
 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.17.1,<0.18.0)
+Requires-Dist: airbyte-protocol-models-pdv2 (>=0.18.0,<0.19.0)
 Requires-Dist: anyascii (>=0.3.2,<0.4.0)
 Requires-Dist: avro (>=1.11.2,<1.13.0) ; extra == "file-based"
 Requires-Dist: backoff

{airbyte_cdk-6.60.0.post27.dev16505983549 → airbyte_cdk-6.60.0.post29.dev16508987644}/airbyte_cdk/cli/source_declarative_manifest/_run.py

@@ -35,9 +35,9 @@ from airbyte_cdk.models import (
     AirbyteStateMessage,
     AirbyteTraceMessage,
     ConfiguredAirbyteCatalog,
-    ConnectorSpecificationSerializer,
     TraceType,
     Type,
+    ab_connector_spec_from_string,
     ab_message_to_string,
 )
 from airbyte_cdk.sources.declarative.concurrent_declarative_source import (
@@ -147,8 +147,7 @@ def handle_remote_manifest_command(args: list[str]) -> None:
                 "Could not find `spec.json` file for source-declarative-manifest"
             )
 
-        spec_obj = json.loads(json_spec)
-        spec = ConnectorSpecificationSerializer.load(spec_obj)
+        spec = ab_connector_spec_from_string(json_spec.decode("utf-8"))
 
         message = AirbyteMessage(type=Type.SPEC, spec=spec)
         print(ab_message_to_string(message))

{airbyte_cdk-6.60.0.post27.dev16505983549 → airbyte_cdk-6.60.0.post29.dev16508987644}/airbyte_cdk/connector.py

@@ -15,7 +15,6 @@ import yaml
 from airbyte_cdk.models import (
     AirbyteConnectionStatus,
     ConnectorSpecification,
-    ConnectorSpecificationSerializer,
 )
 
 
@@ -95,7 +94,7 @@ class BaseConnector(ABC, Generic[TConfig]):
         else:
             raise FileNotFoundError("Unable to find spec.yaml or spec.json in the package.")
 
-        return ConnectorSpecificationSerializer.load(spec_obj)
+        return ConnectorSpecification.model_validate(spec_obj)
 
     @abstractmethod
     def check(self, logger: logging.Logger, config: TConfig) -> AirbyteConnectionStatus:

{airbyte_cdk-6.60.0.post27.dev16505983549 → airbyte_cdk-6.60.0.post29.dev16508987644}/airbyte_cdk/connector_builder/main.py

@@ -22,8 +22,6 @@ from airbyte_cdk.models import (
     AirbyteMessage,
     AirbyteStateMessage,
     ConfiguredAirbyteCatalog,
-    ConfiguredAirbyteCatalogSerializer,
-    ab_message_to_string,
 )
 from airbyte_cdk.sources.declarative.manifest_declarative_source import ManifestDeclarativeSource
 from airbyte_cdk.sources.source import Source
@@ -53,7 +51,7 @@ def get_config_and_catalog_from_args(
 
     command = config["__command"]
     if command == "test_read":
-        catalog = ConfiguredAirbyteCatalogSerializer.load(BaseConnector.read_config(catalog_path))
+        catalog = ConfiguredAirbyteCatalog.model_validate(BaseConnector.read_config(catalog_path))
         state = Source.read_state(state_path)
     else:
         catalog = None

{airbyte_cdk-6.60.0.post27.dev16505983549 → airbyte_cdk-6.60.0.post29.dev16508987644}/airbyte_cdk/destinations/destination.py

@@ -16,8 +16,9 @@ from airbyte_cdk.exception_handler import init_uncaught_exception_handler
 from airbyte_cdk.models import (
     AirbyteMessage,
     ConfiguredAirbyteCatalog,
-    ConfiguredAirbyteCatalogSerializer,
     Type,
+    ab_configured_catalog_from_string,
+    ab_configured_catalog_to_string,
     ab_message_from_string,
     ab_message_to_string,
 )
@@ -59,9 +60,7 @@ class Destination(Connector, ABC):
         configured_catalog_path: str,
         input_stream: io.TextIOWrapper,
     ) -> Iterable[AirbyteMessage]:
-        catalog = ConfiguredAirbyteCatalogSerializer.load(
-            orjson.loads(open(configured_catalog_path).read())
-        )
+        catalog = ab_configured_catalog_from_string(open(configured_catalog_path).read())
         input_messages = self._parse_input_stream(input_stream)
         logger.info("Begin writing to the destination...")
         yield from self.write(

{airbyte_cdk-6.60.0.post27.dev16505983549 → airbyte_cdk-6.60.0.post29.dev16508987644}/airbyte_cdk/models/__init__.py

@@ -50,9 +50,10 @@ from .airbyte_protocol import (
     Type,
 )
 from .airbyte_protocol_serializers import (
-    AirbyteStateMessageSerializer,
-    ConfiguredAirbyteCatalogSerializer,
-    ConnectorSpecificationSerializer,
+    ab_configured_catalog_from_string,
+    ab_configured_catalog_to_string,
+    ab_connector_spec_from_string,
+    ab_connector_spec_to_string,
     ab_message_from_string,
     ab_message_to_string,
 )

{airbyte_cdk-6.60.0.post27.dev16505983549 → airbyte_cdk-6.60.0.post29.dev16508987644}/airbyte_cdk/models/airbyte_protocol.py

@@ -6,4 +6,4 @@ import sys
 from dataclasses import InitVar, dataclass
 from typing import Annotated, Any, Dict, List, Mapping, Optional, Union
 
-from airbyte_protocol_dataclasses.models import *  # noqa: F403  # Allow '*'
+from airbyte_protocol.models import *  # noqa: F403  # Allow '*'

airbyte_cdk-6.60.0.post29.dev16508987644/airbyte_cdk/models/airbyte_protocol_serializers.py

@@ -0,0 +1,181 @@
+# Copyright (c) 2024 Airbyte, Inc., all rights reserved.
+import json
+import logging
+import sys
+from enum import Enum
+from typing import Any, Callable, Dict, Type, TypeVar, cast
+
+import dacite
+import orjson
+from pydantic import ValidationError
+
+from airbyte_cdk.connector_builder.test_reader.helpers import airbyte_message_to_json
+
+from .airbyte_protocol import (  # type: ignore[attr-defined] # all classes are imported to airbyte_protocol via *
+    AirbyteCatalog,
+    AirbyteMessage,
+    AirbyteStateBlob,
+    AirbyteStateMessage,
+    AirbyteStream,
+    AirbyteStreamState,
+    ConfiguredAirbyteCatalog,
+    ConfiguredAirbyteStream,
+    ConnectorSpecification,
+)
+
+USE_RUST_BACKEND = sys.platform != "emscripten"
+"""When run in WASM, use the pure Python backend for serpyco."""
+
+_HAS_LOGGED_FOR_SERIALIZATION_ERROR = False
+"""Track if we have logged an error for serialization issues."""
+
+T = TypeVar("T")
+
+logger = logging.getLogger("airbyte")
+
+# Making this a no-op for now:
+
+
+def ab_message_to_string(
+    message: AirbyteMessage,
+) -> str:
+    """
+    Convert an AirbyteMessage to a JSON string.
+
+    Args:
+        message (AirbyteMessage): The Airbyte message to convert.
+
+    Returns:
+        str: JSON string representation of the AirbyteMessage.
+    """
+    return message.model_dump_json()
+
+
+def ab_message_from_string(
+    message_json: str,
+) -> AirbyteMessage:
+    """
+    Convert a JSON string to an AirbyteMessage.
+
+    Args:
+        message_str (str): The JSON string to convert.
+
+    Returns:
+        AirbyteMessage: The deserialized AirbyteMessage.
+    """
+    try:
+        return AirbyteMessage.model_validate_json(message_json)
+    except ValidationError as e:
+        raise ValueError(f"Invalid AirbyteMessage format: {e}") from e
+    except orjson.JSONDecodeError as e:
+        raise ValueError(f"Failed to decode JSON: {e}") from e
+
+
+def ab_connector_spec_from_string(
+    spec_json: str,
+) -> ConnectorSpecification:
+    """
+    Convert a JSON string to a ConnectorSpecification.
+
+    Args:
+        spec_str (str): The JSON string to convert.
+
+    Returns:
+        ConnectorSpecification: The deserialized ConnectorSpecification.
+    """
+    try:
+        return ConnectorSpecification.model_validate_json(spec_json)
+    except ValidationError as e:
+        raise ValueError(f"Invalid ConnectorSpecification format: {e}") from e
+    except orjson.JSONDecodeError as e:
+        raise ValueError(f"Failed to decode JSON: {e}") from e
+
+
+def ab_connector_spec_to_string(
+    spec: ConnectorSpecification,
+) -> str:
+    """
+    Convert a ConnectorSpecification to a JSON string.
+
+    Args:
+        spec (ConnectorSpecification): The ConnectorSpecification to convert.
+
+    Returns:
+        str: JSON string representation of the ConnectorSpecification.
+    """
+    return spec.model_dump_json()
+
+
+def ab_configured_catalog_to_string(
+    catalog: ConfiguredAirbyteCatalog,
+) -> str:
+    """
+    Convert a ConfiguredAirbyteCatalog to a JSON string.
+
+    Args:
+        catalog (ConfiguredAirbyteCatalog): The ConfiguredAirbyteCatalog to convert.
+
+    Returns:
+        str: JSON string representation of the ConfiguredAirbyteCatalog.
+    """
+    return catalog.model_dump_json()
+
+
+def ab_configured_catalog_from_string(
+    catalog_json: str,
+) -> ConfiguredAirbyteCatalog:
+    """
+    Convert a JSON string to a ConfiguredAirbyteCatalog.
+
+    Args:
+        catalog_json (str): The JSON string to convert.
+
+    Returns:
+        ConfiguredAirbyteCatalog: The deserialized ConfiguredAirbyteCatalog.
+    """
+    try:
+        return ConfiguredAirbyteCatalog.model_validate_json(catalog_json)
+    except ValidationError as e:
+        raise ValueError(f"Invalid ConfiguredAirbyteCatalog format: {e}") from e
+    except orjson.JSONDecodeError as e:
+        raise ValueError(f"Failed to decode JSON: {e}") from e
+
+
+def ab_state_message_from_string(
+    state_json: str,
+) -> AirbyteStateMessage:
+    """
+    Convert a JSON string to an AirbyteStateMessage.
+
+    Args:
+        state_json (str): The JSON string to convert.
+
+    Returns:
+        AirbyteStateMessage: The deserialized AirbyteStateMessage.
+    """
+    try:
+        return AirbyteStateMessage.model_validate_json(state_json)
+    except ValidationError as e:
+        raise ValueError(f"Invalid AirbyteStateMessage format: {e}") from e
+    except orjson.JSONDecodeError as e:
+        raise ValueError(f"Failed to decode JSON: {e}") from e
+
+
+def ab_state_blob_from_string(
+    state_blob_json: str,
+) -> AirbyteStateBlob:
+    """
+    Convert a JSON string to an AirbyteStateBlob.
+
+    Args:
+        state_blob_json (str): The JSON string to convert.
+
+    Returns:
+        AirbyteStateBlob: The deserialized AirbyteStateBlob.
+    """
+    try:
+        return AirbyteStateBlob.model_validate_json(state_blob_json)
+    except ValidationError as e:
+        raise ValueError(f"Invalid AirbyteStateBlob format: {e}") from e
+    except orjson.JSONDecodeError as e:
+        raise ValueError(f"Failed to decode JSON: {e}") from e

{airbyte_cdk-6.60.0.post27.dev16505983549 → airbyte_cdk-6.60.0.post29.dev16508987644}/airbyte_cdk/sources/declarative/spec/spec.py

@@ -8,8 +8,8 @@ from typing import Any, List, Mapping, MutableMapping, Optional
 from airbyte_cdk.models import (
     AdvancedAuth,
     ConnectorSpecification,
-    ConnectorSpecificationSerializer,
 )
+from airbyte_cdk.models.airbyte_protocol_serializers import ab_connector_spec_from_string
 from airbyte_cdk.sources.declarative.models.declarative_component_schema import AuthFlow
 from airbyte_cdk.sources.declarative.transformations.config_transformations.config_transformation import (
     ConfigTransformation,
@@ -59,7 +59,7 @@ class Spec:
             obj["advanced_auth"] = self.advanced_auth.dict()
 
         # We remap these keys to camel case because that's the existing format expected by the rest of the platform
-        return ConnectorSpecificationSerializer.load(obj)
+        return ConnectorSpecification.model_validate(obj)
 
     def migrate_config(self, config: MutableMapping[str, Any]) -> None:
         """

{airbyte_cdk-6.60.0.post27.dev16505983549 → airbyte_cdk-6.60.0.post29.dev16508987644}/airbyte_cdk/sources/source.py

@@ -12,9 +12,7 @@ from airbyte_cdk.models import (
     AirbyteCatalog,
     AirbyteMessage,
     AirbyteStateMessage,
-    AirbyteStateMessageSerializer,
     ConfiguredAirbyteCatalog,
-    ConfiguredAirbyteCatalogSerializer,
 )
 
 TState = TypeVar("TState")
@@ -72,7 +70,7 @@ class Source(
             state_obj = BaseConnector._read_json_file(state_path)
             if state_obj:
                 for state in state_obj:  # type: ignore  # `isinstance(state_obj, List)` ensures that this is a list
-                    parsed_message = AirbyteStateMessageSerializer.load(state)
+                    parsed_message = AirbyteStateMessage.model_validate(state)
                     if (
                         not parsed_message.stream
                         and not parsed_message.data
@@ -87,7 +85,7 @@ class Source(
     # can be overridden to change an input catalog
     @classmethod
     def read_catalog(cls, catalog_path: str) -> ConfiguredAirbyteCatalog:
-        return ConfiguredAirbyteCatalogSerializer.load(cls._read_json_file(catalog_path))
+        return ConfiguredAirbyteCatalog.model_validate(cls._read_json_file(catalog_path))
 
     @property
     def name(self) -> str:

{airbyte_cdk-6.60.0.post27.dev16505983549 → airbyte_cdk-6.60.0.post29.dev16508987644}/airbyte_cdk/test/entrypoint_wrapper.py

@@ -37,16 +37,19 @@ from airbyte_cdk.models import (
     AirbyteLogMessage,
     AirbyteMessage,
     AirbyteStateMessage,
-    AirbyteStateMessageSerializer,
     AirbyteStreamState,
     AirbyteStreamStatus,
     ConfiguredAirbyteCatalog,
-    ConfiguredAirbyteCatalogSerializer,
     Level,
     TraceType,
     Type,
+    ab_configured_catalog_from_string,
+    ab_configured_catalog_to_string,
+    ab_connector_spec_from_string,
+    ab_connector_spec_to_string,
     ab_message_from_string,
     ab_message_to_string,
+    ab_state_message_to_string,
 )
 from airbyte_cdk.sources import Source
 from airbyte_cdk.test.models.scenario import ExpectedOutcome
@@ -449,7 +452,7 @@ def read(
         config_file = make_file(tmp_directory_path / "config.json", config)
         catalog_file = make_file(
             tmp_directory_path / "catalog.json",
-            orjson.dumps(ConfiguredAirbyteCatalogSerializer.dump(catalog)).decode(),
+            ab_configured_catalog_to_string(catalog),
         )
         args = [
             "read",
@@ -461,15 +464,13 @@ def read(
         if debug:
             args.append("--debug")
         if state is not None:
-            args.extend(
-                [
-                    "--state",
-                    make_file(
-                        tmp_directory_path / "state.json",
-                        f"[{','.join([orjson.dumps(AirbyteStateMessageSerializer.dump(stream_state)).decode() for stream_state in state])}]",
-                    ),
-                ]
-            )
+            args.extend([
+                "--state",
+                make_file(
+                    tmp_directory_path / "state.json",
+                    f"[{','.join([ab_state_message_to_string(stream_state) for stream_state in state])}]",
+                ),
+            ])
 
         return _run_command(
             source,

{airbyte_cdk-6.60.0.post27.dev16505983549 → airbyte_cdk-6.60.0.post29.dev16508987644}/pyproject.toml

@@ -23,14 +23,14 @@ classifiers = [
 keywords = ["airbyte", "connector-development-kit", "cdk"]
 
 # Python CDK uses dynamic versioning: https://github.com/mtkennerly/poetry-dynamic-versioning
-version = "6.60.0.post27.dev16505983549"  # Version will be calculated dynamically.
+version = "6.60.0.post29.dev16508987644"  # Version will be calculated dynamically.
 
 [tool.poetry-dynamic-versioning]
 enable = false
 
 [tool.poetry.dependencies]
 python = ">=3.10,<3.13"
-airbyte-protocol-models-dataclasses = "^0.17.1"
+airbyte-protocol-models-pdv2 = "^0.18.0"
 
 backoff = "*"
 boltons = "^25.0.0"

airbyte_cdk-6.60.0.post27.dev16505983549/airbyte_cdk/models/airbyte_protocol_serializers.py

@@ -1,181 +0,0 @@
-# Copyright (c) 2024 Airbyte, Inc., all rights reserved.
-import json
-import logging
-import sys
-from enum import Enum
-from typing import Any, Callable, Dict, Type, TypeVar, cast
-
-import dacite
-import orjson
-from pydantic import ValidationError
-
-from .airbyte_protocol import (  # type: ignore[attr-defined] # all classes are imported to airbyte_protocol via *
-    AirbyteCatalog,
-    AirbyteMessage,
-    AirbyteStateBlob,
-    AirbyteStateMessage,
-    AirbyteStream,
-    AirbyteStreamState,
-    ConfiguredAirbyteCatalog,
-    ConfiguredAirbyteStream,
-    ConnectorSpecification,
-)
-
-USE_RUST_BACKEND = sys.platform != "emscripten"
-"""When run in WASM, use the pure Python backend for serpyco."""
-
-_HAS_LOGGED_FOR_SERIALIZATION_ERROR = False
-"""Track if we have logged an error for serialization issues."""
-
-T = TypeVar("T")
-
-logger = logging.getLogger("airbyte")
-
-
-class CustomSerializer:
-    """Custom serializer that mimics serpyco-rs Serializer API"""
-
-    def __init__(
-        self,
-        model_class: Type[T],
-        omit_none: bool = False,
-        custom_type_resolver: Callable | None = None,
-    ):
-        self.model_class = model_class
-        self.omit_none = omit_none
-        self.custom_type_resolver = custom_type_resolver
-
-    def dump(self, obj: T) -> Dict[str, Any]:
-        """Convert dataclass to dictionary, omitting None values if configured"""
-        if hasattr(obj, "__dict__"):
-            result = {}
-            for key, value in obj.__dict__.items():
-                if self.omit_none and value is None:
-                    continue
-                # Handle custom types like AirbyteStateBlob
-                if self.custom_type_resolver and hasattr(value, "__class__"):
-                    custom_handler = self.custom_type_resolver(value.__class__)
-                    if custom_handler:
-                        value = custom_handler.serialize(value)
-                # Recursively handle nested objects
-                if hasattr(value, "__dict__"):
-                    value = self._serialize_nested(value)
-                elif isinstance(value, list):
-                    value = [
-                        self._serialize_nested(item) if hasattr(item, "__dict__") else item
-                        for item in value
-                    ]
-                result[key] = value
-            return result
-        return obj.__dict__ if hasattr(obj, "__dict__") else {}
-
-    def load(self, data: Dict[str, Any]) -> T:
-        """Convert dictionary to dataclass instance"""
-        # Handle custom types
-        return dacite.from_dict(data_class=self.model_class, data=data)
-
-    def _serialize_nested(self, obj: Any) -> Any:
-        """Helper to serialize nested objects"""
-        if hasattr(obj, "__dict__"):
-            result = {}
-            for key, value in obj.__dict__.items():
-                if self.omit_none and value is None:
-                    continue
-                result[key] = value
-            return result
-        return obj
-
-
-if USE_RUST_BACKEND:
-    from serpyco_rs import CustomType, Serializer  # type: ignore[import]
-
-SERIALIZER = Serializer if USE_RUST_BACKEND else CustomSerializer
-
-# Making this a no-op for now:
-custom_type_resolver = None
-
-# No idea why this is here. Commenting out for now.
-# def custom_type_resolver(t: type) -> AirbyteStateBlobType | None:
-#     return AirbyteStateBlobType() if t is AirbyteStateBlob else None
-#
-# class AirbyteStateBlobType(CustomType[AirbyteStateBlob, Dict[str, Any]]):
-#     def serialize(self, value: AirbyteStateBlob) -> Dict[str, Any]:
-#         # cant use orjson.dumps() directly because private attributes are excluded, e.g. "__ab_full_refresh_sync_complete"
-#         return {k: v for k, v in value.__dict__.items()}
-
-#     def deserialize(self, value: Dict[str, Any]) -> AirbyteStateBlob:
-#         return AirbyteStateBlob(value)
-
-#     def get_json_schema(self) -> Dict[str, Any]:
-#         return {"type": "object"}
-
-# Create serializer instances maintaining the same API
-AirbyteStateMessageSerializer = SERIALIZER(
-    AirbyteStateMessage, omit_none=True, custom_type_resolver=custom_type_resolver
-)
-AirbyteMessageSerializer = SERIALIZER(
-    AirbyteMessage, omit_none=True, custom_type_resolver=custom_type_resolver
-)
-ConfiguredAirbyteCatalogSerializer = SERIALIZER(ConfiguredAirbyteCatalog, omit_none=True)
-ConnectorSpecificationSerializer = SERIALIZER(ConnectorSpecification, omit_none=True)
-
-
-def _custom_json_serializer(val: object) -> str:
-    """Handle custom serialization needs for AirbyteMessage."""
-    if isinstance(val, Enum):
-        return str(val.value)
-
-    return str(val)
-
-
-def ab_message_to_string(
-    message: AirbyteMessage,
-) -> str:
-    """
-    Convert an AirbyteMessage to a JSON string.
-
-    Args:
-        message (AirbyteMessage): The Airbyte message to convert.
-
-    Returns:
-        str: JSON string representation of the AirbyteMessage.
-    """
-    global _HAS_LOGGED_FOR_SERIALIZATION_ERROR
-    dict_obj = AirbyteMessageSerializer.dump(message)
-
-    try:
-        return orjson.dumps(
-            dict_obj,
-            default=_custom_json_serializer,
-        ).decode()
-    except Exception as exception:
-        if not _HAS_LOGGED_FOR_SERIALIZATION_ERROR:
-            logger.warning(
-                f"There was an error during the serialization of an AirbyteMessage: `{exception}`. This might impact the sync performances."
-            )
-            _HAS_LOGGED_FOR_SERIALIZATION_ERROR = True
-        return json.dumps(
-            dict_obj,
-            default=_custom_json_serializer,
-        )
-
-
-def ab_message_from_string(
-    message_str: str,
-) -> AirbyteMessage:
-    """
-    Convert a JSON string to an AirbyteMessage.
-
-    Args:
-        message_str (str): The JSON string to convert.
-
-    Returns:
-        AirbyteMessage: The deserialized AirbyteMessage.
-    """
-    try:
-        message_dict = orjson.loads(message_str)
-        return AirbyteMessageSerializer.load(message_dict)
-    except ValidationError as e:
-        raise ValueError(f"Invalid AirbyteMessage format: {e}") from e
-    except orjson.JSONDecodeError as e:
-        raise ValueError(f"Failed to decode JSON: {e}") from e