airbyte-cdk 6.60.0.post17.dev16484729071__tar.gz → 6.60.0.post20.dev16487461641__tar.gz

{airbyte_cdk-6.60.0.post17.dev16484729071 → airbyte_cdk-6.60.0.post20.dev16487461641}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: airbyte-cdk
-Version: 6.60.0.post17.dev16484729071
+Version: 6.60.0.post20.dev16487461641
 Summary: A framework for writing Airbyte Connectors.
 Home-page: https://airbyte.com
 License: MIT

{airbyte_cdk-6.60.0.post17.dev16484729071 → airbyte_cdk-6.60.0.post20.dev16487461641}/airbyte_cdk/cli/source_declarative_manifest/_run.py

@@ -32,13 +32,13 @@ from airbyte_cdk.entrypoint import AirbyteEntrypoint, launch
 from airbyte_cdk.models import (
     AirbyteErrorTraceMessage,
     AirbyteMessage,
-    AirbyteMessageSerializer,
     AirbyteStateMessage,
     AirbyteTraceMessage,
     ConfiguredAirbyteCatalog,
     ConnectorSpecificationSerializer,
     TraceType,
     Type,
+    ab_message_to_string,
 )
 from airbyte_cdk.sources.declarative.concurrent_declarative_source import (
     ConcurrentDeclarativeSource,
@@ -105,21 +105,19 @@ def _get_local_yaml_source(args: list[str]) -> SourceLocalYaml:
         )
     except Exception as error:
         print(
-            orjson.dumps(
-                AirbyteMessageSerializer.dump(
-                    AirbyteMessage(
-                        type=Type.TRACE,
-                        trace=AirbyteTraceMessage(
-                            type=TraceType.ERROR,
-                            emitted_at=ab_datetime_now().to_epoch_millis(),
-                            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(),
-                            ),
+            ab_message_to_string(
+                AirbyteMessage(
+                    type=Type.TRACE,
+                    trace=AirbyteTraceMessage(
+                        type=TraceType.ERROR,
+                        emitted_at=ab_datetime_now().to_epoch_millis(),
+                        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
 
@@ -153,7 +151,7 @@ def handle_remote_manifest_command(args: list[str]) -> None:
         spec = ConnectorSpecificationSerializer.load(spec_obj)
 
         message = AirbyteMessage(type=Type.SPEC, spec=spec)
-        print(AirbyteEntrypoint.airbyte_message_to_string(message))
+        print(ab_message_to_string(message))
     else:
         source = create_declarative_source(args)
         launch(
@@ -215,21 +213,19 @@ def create_declarative_source(
         )
     except Exception as error:
         print(
-            orjson.dumps(
-                AirbyteMessageSerializer.dump(
-                    AirbyteMessage(
-                        type=Type.TRACE,
-                        trace=AirbyteTraceMessage(
-                            type=TraceType.ERROR,
-                            emitted_at=ab_datetime_now().to_epoch_millis(),
-                            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(),
-                            ),
+            ab_message_to_string(
+                AirbyteMessage(
+                    type=Type.TRACE,
+                    trace=AirbyteTraceMessage(
+                        type=TraceType.ERROR,
+                        emitted_at=ab_datetime_now().to_epoch_millis(),
+                        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
 
@@ -298,10 +294,10 @@ def _register_components_from_file(filepath: str) -> None:
     spec.loader.exec_module(module)
 
 
-def run() -> None:
+def run(args: list[str] | None = None) -> None:
     """Run the `source-declarative-manifest` CLI.
 
     Args are detected from the command line, and the appropriate command is executed.
     """
-    args: list[str] = sys.argv[1:]
+    args = args or sys.argv[1:]
     handle_command(args)

{airbyte_cdk-6.60.0.post17.dev16484729071 → airbyte_cdk-6.60.0.post20.dev16487461641}/airbyte_cdk/config_observation.py

@@ -16,9 +16,9 @@ from airbyte_cdk.models import (
     AirbyteControlConnectorConfigMessage,
     AirbyteControlMessage,
     AirbyteMessage,
-    AirbyteMessageSerializer,
     OrchestratorType,
     Type,
+    ab_message_to_string,
 )
 
 
@@ -92,7 +92,7 @@ def emit_configuration_as_airbyte_control_message(config: MutableMapping[str, An
     See the airbyte_cdk.sources.message package
     """
     airbyte_message = create_connector_config_control_message(config)
-    print(orjson.dumps(AirbyteMessageSerializer.dump(airbyte_message)).decode())
+    print(ab_message_to_string(airbyte_message))
 
 
 def create_connector_config_control_message(config: MutableMapping[str, Any]) -> AirbyteMessage:

{airbyte_cdk-6.60.0.post17.dev16484729071 → airbyte_cdk-6.60.0.post20.dev16487461641}/airbyte_cdk/connector_builder/main.py

@@ -20,10 +20,10 @@ from airbyte_cdk.connector_builder.connector_builder_handler import (
 from airbyte_cdk.entrypoint import AirbyteEntrypoint
 from airbyte_cdk.models import (
     AirbyteMessage,
-    AirbyteMessageSerializer,
     AirbyteStateMessage,
     ConfiguredAirbyteCatalog,
     ConfiguredAirbyteCatalogSerializer,
+    ab_message_to_string,
 )
 from airbyte_cdk.sources.declarative.manifest_declarative_source import ManifestDeclarativeSource
 from airbyte_cdk.sources.source import Source
@@ -92,11 +92,9 @@ def handle_request(args: List[str]) -> str:
     command, config, catalog, state = get_config_and_catalog_from_args(args)
     limits = get_limits(config)
     source = create_source(config, limits)
-    return orjson.dumps(
-        AirbyteMessageSerializer.dump(
-            handle_connector_builder_request(source, command, config, catalog, state, limits)
-        )
-    ).decode()  # type: ignore[no-any-return] # Serializer.dump() always returns AirbyteMessage
+    return ab_message_to_string(
+        handle_connector_builder_request(source, command, config, catalog, state, limits)
+    )
 
 
 if __name__ == "__main__":
@@ -107,4 +105,4 @@ if __name__ == "__main__":
             exc, message=f"Error handling request: {str(exc)}"
         )
         m = error.as_airbyte_message()
-        print(orjson.dumps(AirbyteMessageSerializer.dump(m)).decode())
+        print(ab_message_to_string(m))

{airbyte_cdk-6.60.0.post17.dev16484729071 → airbyte_cdk-6.60.0.post20.dev16487461641}/airbyte_cdk/destinations/destination.py

@@ -15,10 +15,11 @@ from airbyte_cdk.connector import Connector
 from airbyte_cdk.exception_handler import init_uncaught_exception_handler
 from airbyte_cdk.models import (
     AirbyteMessage,
-    AirbyteMessageSerializer,
     ConfiguredAirbyteCatalog,
     ConfiguredAirbyteCatalogSerializer,
     Type,
+    ab_message_from_string,
+    ab_message_to_string,
 )
 from airbyte_cdk.sources.utils.schema_helpers import check_config_against_spec_or_exit
 from airbyte_cdk.utils.traced_exception import AirbyteTracedException
@@ -46,7 +47,7 @@ class Destination(Connector, ABC):
         """Reads from stdin, converting to Airbyte messages"""
         for line in input_stream:
             try:
-                yield AirbyteMessageSerializer.load(orjson.loads(line))
+                yield ab_message_from_string(line)
             except orjson.JSONDecodeError:
                 logger.info(
                     f"ignoring input which can't be deserialized as Airbyte Message: {line}"
@@ -151,4 +152,4 @@ class Destination(Connector, ABC):
         parsed_args = self.parse_args(args)
         output_messages = self.run_cmd(parsed_args)
         for message in output_messages:
-            print(orjson.dumps(AirbyteMessageSerializer.dump(message)).decode())
+            print(ab_message_to_string(message))

{airbyte_cdk-6.60.0.post17.dev16484729071 → airbyte_cdk-6.60.0.post20.dev16487461641}/airbyte_cdk/entrypoint.py

@@ -26,12 +26,12 @@ from airbyte_cdk.logger import PRINT_BUFFER, init_logger
 from airbyte_cdk.models import (
     AirbyteConnectionStatus,
     AirbyteMessage,
-    AirbyteMessageSerializer,
     AirbyteStateStats,
     ConnectorSpecification,
     FailureType,
     Status,
     Type,
+    ab_message_to_string,
 )
 from airbyte_cdk.sources import Source
 from airbyte_cdk.sources.connector_state_manager import HashableStreamDescriptor
@@ -47,7 +47,6 @@ logger = init_logger("airbyte")
 
 VALID_URL_SCHEMES = ["https"]
 CLOUD_DEPLOYMENT_MODE = "cloud"
-_HAS_LOGGED_FOR_SERIALIZATION_ERROR = False
 
 
 class AirbyteEntrypoint(object):
@@ -178,26 +177,26 @@ class AirbyteEntrypoint(object):
                 if cmd == "spec":
                     message = AirbyteMessage(type=Type.SPEC, spec=source_spec)
                     yield from [
-                        self.airbyte_message_to_string(queued_message)
+                        ab_message_to_string(queued_message)
                         for queued_message in self._emit_queued_messages(self.source)
                     ]
-                    yield self.airbyte_message_to_string(message)
+                    yield ab_message_to_string(message)
                 else:
                     raw_config = self.source.read_config(parsed_args.config)
                     config = self.source.configure(raw_config, temp_dir)
 
                     yield from [
-                        self.airbyte_message_to_string(queued_message)
+                        ab_message_to_string(queued_message)
                         for queued_message in self._emit_queued_messages(self.source)
                     ]
                     if cmd == "check":
                         yield from map(
-                            AirbyteEntrypoint.airbyte_message_to_string,
+                            ab_message_to_string,
                             self.check(source_spec, config),
                         )
                     elif cmd == "discover":
                         yield from map(
-                            AirbyteEntrypoint.airbyte_message_to_string,
+                            ab_message_to_string,
                             self.discover(source_spec, config),
                         )
                     elif cmd == "read":
@@ -205,14 +204,14 @@ class AirbyteEntrypoint(object):
                         state = self.source.read_state(parsed_args.state)
 
                         yield from map(
-                            AirbyteEntrypoint.airbyte_message_to_string,
+                            ab_message_to_string,
                             self.read(source_spec, config, config_catalog, state),
                         )
                     else:
                         raise Exception("Unexpected command " + cmd)
         finally:
             yield from [
-                self.airbyte_message_to_string(queued_message)
+                ab_message_to_string(queued_message)
                 for queued_message in self._emit_queued_messages(self.source)
             ]
 
@@ -327,20 +326,6 @@ class AirbyteEntrypoint(object):
         config_secrets = get_secrets(connection_specification, config)
         update_secrets(config_secrets)
 
-    @staticmethod
-    def airbyte_message_to_string(airbyte_message: AirbyteMessage) -> str:
-        global _HAS_LOGGED_FOR_SERIALIZATION_ERROR
-        serialized_message = AirbyteMessageSerializer.dump(airbyte_message)
-        try:
-            return orjson.dumps(serialized_message).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(serialized_message)
-
     @classmethod
     def extract_state(cls, args: List[str]) -> Optional[Any]:
         parsed_args = cls.parse_args(args)

{airbyte_cdk-6.60.0.post17.dev16484729071 → airbyte_cdk-6.60.0.post20.dev16487461641}/airbyte_cdk/logger.py

@@ -12,9 +12,9 @@ import orjson
 from airbyte_cdk.models import (
     AirbyteLogMessage,
     AirbyteMessage,
-    AirbyteMessageSerializer,
     Level,
     Type,
+    ab_message_to_string,
 )
 from airbyte_cdk.utils import PrintBuffer
 from airbyte_cdk.utils.airbyte_secrets_utils import filter_secrets
@@ -81,7 +81,7 @@ class AirbyteLogFormatter(logging.Formatter):
             log_message = AirbyteMessage(
                 type=Type.LOG, log=AirbyteLogMessage(level=airbyte_level, message=message)
             )
-            return orjson.dumps(AirbyteMessageSerializer.dump(log_message)).decode()
+            return ab_message_to_string(log_message)
 
     @staticmethod
     def extract_extra_args_from_record(record: logging.LogRecord) -> Mapping[str, Any]:

{airbyte_cdk-6.60.0.post17.dev16484729071 → airbyte_cdk-6.60.0.post20.dev16487461641}/airbyte_cdk/models/__init__.py

@@ -50,12 +50,11 @@ from .airbyte_protocol import (
     Type,
 )
 from .airbyte_protocol_serializers import (
-    AirbyteMessageSerializer,
     AirbyteStateMessageSerializer,
-    AirbyteStreamStateSerializer,
     ConfiguredAirbyteCatalogSerializer,
-    ConfiguredAirbyteStreamSerializer,
     ConnectorSpecificationSerializer,
+    ab_message_from_string,
+    ab_message_to_string,
 )
 from .well_known_types import (
     BinaryData,

{airbyte_cdk-6.60.0.post17.dev16484729071 → airbyte_cdk-6.60.0.post20.dev16487461641}/airbyte_cdk/models/airbyte_protocol_serializers.py

@@ -1,10 +1,14 @@
 # Copyright (c) 2024 Airbyte, Inc., all rights reserved.
+import json
 import sys
-from typing import Any, Callable, Dict, Type, TypeVar
+from enum import Enum
+from typing import Any, Callable, Dict, Type, TypeVar, cast
 
 import orjson
 from pydantic import ValidationError
 
+from airbyte_cdk.logger import init_logger
+
 from .airbyte_protocol import (  # type: ignore[attr-defined] # all classes are imported to airbyte_protocol via *
     AirbyteCatalog,
     AirbyteMessage,
@@ -20,9 +24,15 @@ from .airbyte_protocol import (  # type: ignore[attr-defined] # all classes are
 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 = init_logger("airbyte")
+
+
 class CustomSerializer:
     """Custom serializer that mimics serpyco-rs Serializer API"""
 
@@ -101,11 +111,6 @@ custom_type_resolver = None
 #         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
 )
@@ -113,5 +118,65 @@ 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)
+
+
+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

{airbyte_cdk-6.60.0.post17.dev16484729071 → airbyte_cdk-6.60.0.post20.dev16487461641}/airbyte_cdk/sources/declarative/manifest_declarative_source.py

@@ -31,7 +31,7 @@ from airbyte_cdk.models import (
     ConnectorSpecification,
     FailureType,
 )
-from airbyte_cdk.models.airbyte_protocol_serializers import AirbyteMessageSerializer
+from airbyte_cdk.models.airbyte_protocol_serializers import ab_message_to_string
 from airbyte_cdk.sources.declarative.checks import COMPONENTS_CHECKER_TYPE_MAPPING
 from airbyte_cdk.sources.declarative.checks.connection_checker import ConnectionChecker
 from airbyte_cdk.sources.declarative.declarative_source import DeclarativeSource
@@ -234,7 +234,7 @@ class ManifestDeclarativeSource(DeclarativeSource):
             )
             # We have no mechanism for consuming the queue, so we print the messages to stdout
             for message in self.message_repository.consume_queue():
-                print(orjson.dumps(AirbyteMessageSerializer.dump(message)).decode())
+                print(ab_message_to_string(message))
         self._spec_component.transform_config(mutable_config)
         return mutable_config
 

{airbyte_cdk-6.60.0.post17.dev16484729071 → airbyte_cdk-6.60.0.post20.dev16487461641}/airbyte_cdk/sources/streams/http/http_client.py

@@ -14,12 +14,12 @@ import requests_cache
 from requests.auth import AuthBase
 
 from airbyte_cdk.models import (
-    AirbyteMessageSerializer,
     AirbyteStreamStatus,
     AirbyteStreamStatusReason,
     AirbyteStreamStatusReasonType,
     Level,
     StreamDescriptor,
+    ab_message_to_string,
 )
 from airbyte_cdk.sources.http_config import MAX_CONNECTION_POOL_SIZE
 from airbyte_cdk.sources.message import MessageRepository
@@ -396,13 +396,11 @@ class HttpClient:
         if error_resolution.response_action == ResponseAction.RATE_LIMITED:
             # TODO: Update to handle with message repository when concurrent message repository is ready
             reasons = [AirbyteStreamStatusReason(type=AirbyteStreamStatusReasonType.RATE_LIMITED)]
-            message = orjson.dumps(
-                AirbyteMessageSerializer.dump(
-                    stream_status_as_airbyte_message(
-                        StreamDescriptor(name=self._name), AirbyteStreamStatus.RUNNING, reasons
-                    )
+            message = ab_message_to_string(
+                stream_status_as_airbyte_message(
+                    StreamDescriptor(name=self._name), AirbyteStreamStatus.RUNNING, reasons
                 )
-            ).decode()
+            )
 
             # Simply printing the stream status is a temporary solution and can cause future issues. Currently, the _send method is
             # wrapped with backoff decorators, and we can only emit messages by iterating record_iterator in the abstract source at the

{airbyte_cdk-6.60.0.post17.dev16484729071 → airbyte_cdk-6.60.0.post20.dev16487461641}/airbyte_cdk/test/catalog_builder.py

@@ -5,7 +5,6 @@ from typing import Any, Dict, List, Union, overload
 from airbyte_cdk.models import (
     ConfiguredAirbyteCatalog,
     ConfiguredAirbyteStream,
-    ConfiguredAirbyteStreamSerializer,
     SyncMode,
 )
 
@@ -42,7 +41,7 @@ class ConfiguredAirbyteStreamBuilder:
         return self
 
     def build(self) -> ConfiguredAirbyteStream:
-        return ConfiguredAirbyteStreamSerializer.load(self._stream)
+        return ConfiguredAirbyteStream(**self._stream)
 
 
 class CatalogBuilder:

{airbyte_cdk-6.60.0.post17.dev16484729071 → airbyte_cdk-6.60.0.post20.dev16487461641}/airbyte_cdk/test/entrypoint_wrapper.py

@@ -36,7 +36,6 @@ from airbyte_cdk.logger import AirbyteLogFormatter
 from airbyte_cdk.models import (
     AirbyteLogMessage,
     AirbyteMessage,
-    AirbyteMessageSerializer,
     AirbyteStateMessage,
     AirbyteStateMessageSerializer,
     AirbyteStreamState,
@@ -46,6 +45,8 @@ from airbyte_cdk.models import (
     Level,
     TraceType,
     Type,
+    ab_message_from_string,
+    ab_message_to_string,
 )
 from airbyte_cdk.sources import Source
 from airbyte_cdk.test.models.scenario import ExpectedOutcome
@@ -124,7 +125,7 @@ class EntrypointOutput:
     @staticmethod
     def _parse_message(message: str) -> AirbyteMessage:
         try:
-            return AirbyteMessageSerializer.load(orjson.loads(message))
+            return ab_message_from_string(message)
         except JsonValidationErrors:
             # The platform assumes that logs that are not of AirbyteMessage format are log messages
             return AirbyteMessage(

{airbyte_cdk-6.60.0.post17.dev16484729071 → airbyte_cdk-6.60.0.post20.dev16487461641}/airbyte_cdk/utils/datetime_helpers.py

@@ -86,7 +86,6 @@ from typing import Any, Optional, Union, overload
 
 from dateutil import parser
 from typing_extensions import Never
-from whenever import Instant, LocalDateTime, ZonedDateTime
 
 
 class AirbyteDateTime(datetime):
@@ -138,6 +137,18 @@ class AirbyteDateTime(datetime):
             dt.tzinfo or timezone.utc,
         )
 
+    @classmethod
+    def from_timestamp(cls, timestamp: float) -> "AirbyteDateTime":
+        """Creates an AirbyteDateTime from a Unix timestamp in seconds.
+
+        Args:
+            timestamp: A Unix timestamp in seconds (float).
+
+        Returns:
+            AirbyteDateTime: A new timezone-aware datetime instance (UTC).
+        """
+        return AirbyteDateTime.from_datetime(datetime.fromtimestamp(timestamp, tz=timezone.utc))
+
     def to_datetime(self) -> datetime:
         """Converts this AirbyteDateTime to a standard datetime object.
 
@@ -400,8 +411,7 @@ def ab_datetime_parse(dt_str: str | int) -> AirbyteDateTime:
                 raise ValueError("Timestamp cannot be negative")
             if len(str(abs(timestamp))) > 10:
                 raise ValueError("Timestamp value too large")
-            instant = Instant.from_timestamp(timestamp)
-            return AirbyteDateTime.from_datetime(instant.py_datetime())
+            return AirbyteDateTime.from_timestamp(timestamp)
 
         if not isinstance(dt_str, str):
             raise ValueError(
@@ -414,8 +424,7 @@ def ab_datetime_parse(dt_str: str | int) -> AirbyteDateTime:
                 year, month, day = map(int, dt_str.split("-"))
                 if not (1 <= month <= 12 and 1 <= day <= 31):
                     raise ValueError(f"Invalid date format: {dt_str}")
-                instant = Instant.from_utc(year, month, day, 0, 0, 0)
-                return AirbyteDateTime.from_datetime(instant.py_datetime())
+                return AirbyteDateTime(year, month, day, 0, 0, 0)
             except (ValueError, TypeError):
                 raise ValueError(f"Invalid date format: {dt_str}")
 

{airbyte_cdk-6.60.0.post17.dev16484729071 → airbyte_cdk-6.60.0.post20.dev16487461641}/airbyte_cdk/utils/traced_exception.py

@@ -11,12 +11,12 @@ from airbyte_cdk.models import (
     AirbyteConnectionStatus,
     AirbyteErrorTraceMessage,
     AirbyteMessage,
-    AirbyteMessageSerializer,
     AirbyteTraceMessage,
     FailureType,
     Status,
     StreamDescriptor,
     TraceType,
+    ab_message_to_string,
 )
 from airbyte_cdk.models import Type as MessageType
 from airbyte_cdk.utils.airbyte_secrets_utils import filter_secrets
@@ -95,7 +95,7 @@ class AirbyteTracedException(Exception):
         Prints the exception as an AirbyteTraceMessage.
         Note that this will be called automatically on uncaught exceptions when using the airbyte_cdk entrypoint.
         """
-        message = orjson.dumps(AirbyteMessageSerializer.dump(self.as_airbyte_message())).decode()
+        message = ab_message_to_string(self.as_airbyte_message())
         filtered_message = filter_secrets(message)
         print(filtered_message)
 

{airbyte_cdk-6.60.0.post17.dev16484729071 → airbyte_cdk-6.60.0.post20.dev16487461641}/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.post17.dev16484729071"  # Version will be calculated dynamically.
+version = "6.60.0.post20.dev16487461641"  # Version will be calculated dynamically.
 
 [tool.poetry-dynamic-versioning]
 enable = false