airbyte-cdk 6.60.0.post14.dev16483785754__tar.gz → 6.60.0.post16.dev16484674380__tar.gz

{airbyte_cdk-6.60.0.post14.dev16483785754 → airbyte_cdk-6.60.0.post16.dev16484674380}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: airbyte-cdk
-Version: 6.60.0.post14.dev16483785754
+Version: 6.60.0.post16.dev16484674380
 Summary: A framework for writing Airbyte Connectors.
 Home-page: https://airbyte.com
 License: MIT

airbyte_cdk-6.60.0.post16.dev16484674380/airbyte_cdk/models/airbyte_protocol.py

@@ -0,0 +1,9 @@
+#
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
+#
+
+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 '*'

airbyte_cdk-6.60.0.post16.dev16484674380/airbyte_cdk/models/airbyte_protocol_serializers.py

@@ -0,0 +1,117 @@
+# Copyright (c) 2024 Airbyte, Inc., all rights reserved.
+import sys
+from typing import Any, Dict, Type, TypeVar
+
+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."""
+
+
+T = TypeVar("T")
+
+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 self.model_class(**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
+AirbyteCatalogSerializer = SERIALIZER(AirbyteCatalog, omit_none=True)
+AirbyteStreamSerializer = SERIALIZER(AirbyteStream, omit_none=True)
+AirbyteStreamStateSerializer = SERIALIZER(
+    AirbyteStreamState, omit_none=True, custom_type_resolver=custom_type_resolver
+)
+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)
+ConfiguredAirbyteStreamSerializer = SERIALIZER(ConfiguredAirbyteStream, omit_none=True)
+ConnectorSpecificationSerializer = SERIALIZER(ConnectorSpecification, omit_none=True)

{airbyte_cdk-6.60.0.post14.dev16483785754 → airbyte_cdk-6.60.0.post16.dev16484674380}/airbyte_cdk/test/entrypoint_wrapper.py

@@ -30,11 +30,6 @@ from typing import Any, List, Literal, Optional, Union, final, overload
 import orjson
 from pydantic import ValidationError as V2ValidationError
 
-if sys.platform == 'emscripten':
-    from serpyco import SchemaValidationError
-else:
-    from serpyco_rs import SchemaValidationError
-
 from airbyte_cdk.entrypoint import AirbyteEntrypoint
 from airbyte_cdk.exception_handler import assemble_uncaught_exception
 from airbyte_cdk.logger import AirbyteLogFormatter
@@ -55,6 +50,13 @@ from airbyte_cdk.models import (
 from airbyte_cdk.sources import Source
 from airbyte_cdk.test.models.scenario import ExpectedOutcome
 
+JsonValidationErrors: tuple[type[Exception], ...] = (orjson.JSONDecodeError,)
+# Conditionally import and create a union type for exception handling
+if sys.platform != "emscripten":
+    from serpyco_rs import SchemaValidationError
+
+    JsonValidationErrors = (orjson.JSONDecodeError, SchemaValidationError)
+
 
 class AirbyteEntrypointException(Exception):
     """Exception raised for errors in the AirbyteEntrypoint execution.
@@ -123,7 +125,7 @@ class EntrypointOutput:
     def _parse_message(message: str) -> AirbyteMessage:
         try:
             return AirbyteMessageSerializer.load(orjson.loads(message))
-        except (orjson.JSONDecodeError, SchemaValidationError):
+        except JsonValidationErrors:
             # The platform assumes that logs that are not of AirbyteMessage format are log messages
             return AirbyteMessage(
                 type=Type.LOG, log=AirbyteLogMessage(level=Level.INFO, message=message)

{airbyte_cdk-6.60.0.post14.dev16483785754 → airbyte_cdk-6.60.0.post16.dev16484674380}/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.60.0.post14.dev16483785754"  # Version will be calculated dynamically.
+version = "6.60.0.post16.dev16484674380"  # Version will be calculated dynamically.
 
 [tool.poetry-dynamic-versioning]
 enable = false

airbyte_cdk-6.60.0.post14.dev16483785754/airbyte_cdk/models/airbyte_protocol.py

@@ -1,93 +0,0 @@
-#
-# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
-#
-
-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 '*'
-
-if sys.platform == 'emscripten':
-    from serpyco.metadata import Alias
-else:
-    from serpyco_rs.metadata import Alias
-
-# ruff: noqa: F405  # ignore fuzzy import issues with 'import *'
-
-
-@dataclass
-class AirbyteStateBlob:
-    """
-    A dataclass that dynamically sets attributes based on provided keyword arguments and positional arguments.
-    Used to "mimic" pydantic Basemodel with ConfigDict(extra='allow') option.
-
-    The `AirbyteStateBlob` class allows for flexible instantiation by accepting any number of keyword arguments
-    and positional arguments. These are used to dynamically update the instance's attributes. This class is useful
-    in scenarios where the attributes of an object are not known until runtime and need to be set dynamically.
-
-    Attributes:
-        kwargs (InitVar[Mapping[str, Any]]): A dictionary of keyword arguments used to set attributes dynamically.
-
-    Methods:
-        __init__(*args: Any, **kwargs: Any) -> None:
-            Initializes the `AirbyteStateBlob` by setting attributes from the provided arguments.
-
-        __eq__(other: object) -> bool:
-            Checks equality between two `AirbyteStateBlob` instances based on their internal dictionaries.
-            Returns `False` if the other object is not an instance of `AirbyteStateBlob`.
-    """
-
-    kwargs: InitVar[Mapping[str, Any]]
-
-    def __init__(self, *args: Any, **kwargs: Any) -> None:
-        # Set any attribute passed in through kwargs
-        for arg in args:
-            self.__dict__.update(arg)
-        for key, value in kwargs.items():
-            setattr(self, key, value)
-
-    def __eq__(self, other: object) -> bool:
-        return (
-            False
-            if not isinstance(other, AirbyteStateBlob)
-            else bool(self.__dict__ == other.__dict__)
-        )
-
-
-# The following dataclasses have been redeclared to include the new version of AirbyteStateBlob
-@dataclass
-class AirbyteStreamState:
-    stream_descriptor: StreamDescriptor  # type: ignore [name-defined]
-    stream_state: Optional[AirbyteStateBlob] = None
-
-
-@dataclass
-class AirbyteGlobalState:
-    stream_states: List[AirbyteStreamState]
-    shared_state: Optional[AirbyteStateBlob] = None
-
-
-@dataclass
-class AirbyteStateMessage:
-    type: Optional[AirbyteStateType] = None  # type: ignore [name-defined]
-    stream: Optional[AirbyteStreamState] = None
-    global_: Annotated[AirbyteGlobalState | None, Alias("global")] = (
-        None  # "global" is a reserved keyword in python ⇒ Alias is used for (de-)serialization
-    )
-    data: Optional[Dict[str, Any]] = None
-    sourceStats: Optional[AirbyteStateStats] = None  # type: ignore [name-defined]
-    destinationStats: Optional[AirbyteStateStats] = None  # type: ignore [name-defined]
-
-
-@dataclass
-class AirbyteMessage:
-    type: Type  # type: ignore [name-defined]
-    log: Optional[AirbyteLogMessage] = None  # type: ignore [name-defined]
-    spec: Optional[ConnectorSpecification] = None  # type: ignore [name-defined]
-    connectionStatus: Optional[AirbyteConnectionStatus] = None  # type: ignore [name-defined]
-    catalog: Optional[AirbyteCatalog] = None  # type: ignore [name-defined]
-    record: Optional[AirbyteRecordMessage] = None  # type: ignore [name-defined]
-    state: Optional[AirbyteStateMessage] = None
-    trace: Optional[AirbyteTraceMessage] = None  # type: ignore [name-defined]
-    control: Optional[AirbyteControlMessage] = None  # type: ignore [name-defined]

airbyte_cdk-6.60.0.post14.dev16483785754/airbyte_cdk/models/airbyte_protocol_serializers.py

@@ -1,55 +0,0 @@
-# Copyright (c) 2024 Airbyte, Inc., all rights reserved.
-import sys
-from typing import Any, Dict
-
-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."""
-
-if USE_RUST_BACKEND:
-    from serpyco_rs import CustomType, Serializer
-else:
-    from serpyco import CustomType, Serializer
-
-
-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"}
-
-
-def custom_type_resolver(t: type) -> CustomType[AirbyteStateBlob, Dict[str, Any]] | None:
-    return AirbyteStateBlobType() if t is AirbyteStateBlob else None
-
-
-AirbyteCatalogSerializer = Serializer(AirbyteCatalog, omit_none=True)
-AirbyteStreamSerializer = Serializer(AirbyteStream, omit_none=True)
-AirbyteStreamStateSerializer = Serializer(
-    AirbyteStreamState, omit_none=True, custom_type_resolver=custom_type_resolver
-)
-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)
-ConfiguredAirbyteStreamSerializer = Serializer(ConfiguredAirbyteStream, omit_none=True)
-ConnectorSpecificationSerializer = Serializer(ConnectorSpecification, omit_none=True)