airbyte-cdk 6.27.2__py3-none-any.whl → 6.28.0__py3-none-any.whl

airbyte_cdk/cli/source_declarative_manifest/_run.py

@@ -21,7 +21,6 @@ import pkgutil
 import sys
 import traceback
 from collections.abc import Mapping
-from datetime import datetime
 from pathlib import Path
 from typing import Any, cast
 
@@ -44,6 +43,7 @@ from airbyte_cdk.sources.declarative.concurrent_declarative_source import (
 )
 from airbyte_cdk.sources.declarative.yaml_declarative_source import YamlDeclarativeSource
 from airbyte_cdk.sources.source import TState
+from airbyte_cdk.utils.datetime_helpers import ab_datetime_now
 
 
 class SourceLocalYaml(YamlDeclarativeSource):
@@ -101,7 +101,7 @@ def _get_local_yaml_source(args: list[str]) -> SourceLocalYaml:
                         type=Type.TRACE,
                         trace=AirbyteTraceMessage(
                             type=TraceType.ERROR,
-                            emitted_at=int(datetime.now().timestamp() * 1000),
+                            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(),
@@ -191,7 +191,7 @@ def create_declarative_source(
                         type=Type.TRACE,
                         trace=AirbyteTraceMessage(
                             type=TraceType.ERROR,
-                            emitted_at=int(datetime.now().timestamp() * 1000),
+                            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(),

airbyte_cdk/connector_builder/connector_builder_handler.py

@@ -3,7 +3,6 @@
 #
 
 import dataclasses
-from datetime import datetime
 from typing import Any, List, Mapping
 
 from airbyte_cdk.connector_builder.message_grouper import MessageGrouper
@@ -21,6 +20,7 @@ from airbyte_cdk.sources.declarative.parsers.model_to_component_factory import (
     ModelToComponentFactory,
 )
 from airbyte_cdk.utils.airbyte_secrets_utils import filter_secrets
+from airbyte_cdk.utils.datetime_helpers import ab_datetime_now
 from airbyte_cdk.utils.traced_exception import AirbyteTracedException
 
 DEFAULT_MAXIMUM_NUMBER_OF_PAGES_PER_SLICE = 5
@@ -114,4 +114,4 @@ def resolve_manifest(source: ManifestDeclarativeSource) -> AirbyteMessage:
 
 
 def _emitted_at() -> int:
-    return int(datetime.now().timestamp()) * 1000
+    return ab_datetime_now().to_epoch_millis()

airbyte_cdk/sources/declarative/auth/oauth.py

@@ -3,10 +3,9 @@
 #
 
 from dataclasses import InitVar, dataclass, field
+from datetime import timedelta
 from typing import Any, List, Mapping, MutableMapping, Optional, Union
 
-import pendulum
-
 from airbyte_cdk.sources.declarative.auth.declarative_authenticator import DeclarativeAuthenticator
 from airbyte_cdk.sources.declarative.interpolation.interpolated_boolean import InterpolatedBoolean
 from airbyte_cdk.sources.declarative.interpolation.interpolated_mapping import InterpolatedMapping
@@ -18,6 +17,7 @@ from airbyte_cdk.sources.streams.http.requests_native_auth.abstract_oauth import
 from airbyte_cdk.sources.streams.http.requests_native_auth.oauth import (
     SingleUseRefreshTokenOauth2Authenticator,
 )
+from airbyte_cdk.utils.datetime_helpers import AirbyteDateTime, ab_datetime_now, ab_datetime_parse
 
 
 @dataclass
@@ -53,7 +53,7 @@ class DeclarativeOauth2Authenticator(AbstractOauth2Authenticator, DeclarativeAut
     refresh_token: Optional[Union[InterpolatedString, str]] = None
     scopes: Optional[List[str]] = None
     token_expiry_date: Optional[Union[InterpolatedString, str]] = None
-    _token_expiry_date: Optional[pendulum.DateTime] = field(init=False, repr=False, default=None)
+    _token_expiry_date: Optional[AirbyteDateTime] = field(init=False, repr=False, default=None)
     token_expiry_date_format: Optional[str] = None
     token_expiry_is_time_of_expiration: bool = False
     access_token_name: Union[InterpolatedString, str] = "access_token"
@@ -122,15 +122,24 @@ class DeclarativeOauth2Authenticator(AbstractOauth2Authenticator, DeclarativeAut
         self._refresh_request_headers = InterpolatedMapping(
             self.refresh_request_headers or {}, parameters=parameters
         )
-        self._token_expiry_date: pendulum.DateTime = (
-            pendulum.parse(
-                InterpolatedString.create(self.token_expiry_date, parameters=parameters).eval(
-                    self.config
+        try:
+            if (
+                isinstance(self.token_expiry_date, (int, str))
+                and str(self.token_expiry_date).isdigit()
+            ):
+                self._token_expiry_date = ab_datetime_parse(self.token_expiry_date)
+            else:
+                self._token_expiry_date = (
+                    ab_datetime_parse(
+                        InterpolatedString.create(
+                            self.token_expiry_date, parameters=parameters
+                        ).eval(self.config)
+                    )
+                    if self.token_expiry_date
+                    else ab_datetime_now() - timedelta(days=1)
                 )
-            )  # type: ignore # pendulum.parse returns a datetime in this context
-            if self.token_expiry_date
-            else pendulum.now().subtract(days=1)  # type: ignore # substract does not have type hints
-        )
+        except ValueError as e:
+            raise ValueError(f"Invalid token expiry date format: {e}")
         self.use_profile_assertion = (
             InterpolatedBoolean(self.use_profile_assertion, parameters=parameters)
             if isinstance(self.use_profile_assertion, str)
@@ -222,8 +231,8 @@ class DeclarativeOauth2Authenticator(AbstractOauth2Authenticator, DeclarativeAut
     def get_refresh_request_headers(self) -> Mapping[str, Any]:
         return self._refresh_request_headers.eval(self.config)
 
-    def get_token_expiry_date(self) -> pendulum.DateTime:
-        return self._token_expiry_date  # type: ignore # _token_expiry_date is a pendulum.DateTime. It is never None despite what mypy thinks
+    def get_token_expiry_date(self) -> AirbyteDateTime:
+        return self._token_expiry_date  # type: ignore # _token_expiry_date is an AirbyteDateTime. It is never None despite what mypy thinks
 
     def set_token_expiry_date(self, value: Union[str, int]) -> None:
         self._token_expiry_date = self._parse_token_expiration_date(value)

airbyte_cdk/sources/declarative/auth/token_provider.py

@@ -9,9 +9,7 @@ from dataclasses import InitVar, dataclass, field
 from typing import Any, List, Mapping, Optional, Union
 
 import dpath
-import pendulum
 from isodate import Duration
-from pendulum import DateTime
 
 from airbyte_cdk.sources.declarative.decoders.decoder import Decoder
 from airbyte_cdk.sources.declarative.decoders.json_decoder import JsonDecoder
@@ -21,6 +19,7 @@ from airbyte_cdk.sources.declarative.requesters.requester import Requester
 from airbyte_cdk.sources.http_logger import format_http_message
 from airbyte_cdk.sources.message import MessageRepository, NoopMessageRepository
 from airbyte_cdk.sources.types import Config
+from airbyte_cdk.utils.datetime_helpers import AirbyteDateTime, ab_datetime_now
 
 
 class TokenProvider:
@@ -38,7 +37,7 @@ class SessionTokenProvider(TokenProvider):
     message_repository: MessageRepository = NoopMessageRepository()
     decoder: Decoder = field(default_factory=lambda: JsonDecoder(parameters={}))
 
-    _next_expiration_time: Optional[DateTime] = None
+    _next_expiration_time: Optional[AirbyteDateTime] = None
     _token: Optional[str] = None
 
     def get_token(self) -> str:
@@ -48,7 +47,7 @@ class SessionTokenProvider(TokenProvider):
         return self._token
 
     def _refresh_if_necessary(self) -> None:
-        if self._next_expiration_time is None or self._next_expiration_time < pendulum.now():
+        if self._next_expiration_time is None or self._next_expiration_time < ab_datetime_now():
             self._refresh()
 
     def _refresh(self) -> None:
@@ -65,7 +64,7 @@ class SessionTokenProvider(TokenProvider):
             raise ReadException("Failed to get session token, response got ignored by requester")
         session_token = dpath.get(next(self.decoder.decode(response)), self.session_token_path)
         if self.expiration_duration is not None:
-            self._next_expiration_time = pendulum.now() + self.expiration_duration
+            self._next_expiration_time = ab_datetime_now() + self.expiration_duration
         self._token = session_token  # type: ignore # Returned decoded response will be Mapping and therefore session_token will be str or None
 
 

airbyte_cdk/sources/streams/concurrent/state_converters/datetime_stream_state_converter.py

@@ -6,9 +6,6 @@ from abc import abstractmethod
 from datetime import datetime, timedelta, timezone
 from typing import Any, Callable, List, MutableMapping, Optional, Tuple
 
-import pendulum
-from pendulum.datetime import DateTime
-
 # FIXME We would eventually like the Concurrent package do be agnostic of the declarative package. However, this is a breaking change and
 #  the goal in the short term is only to fix the issue we are seeing for source-declarative-manifest.
 from airbyte_cdk.sources.declarative.datetime.datetime_parser import DatetimeParser
@@ -17,6 +14,7 @@ from airbyte_cdk.sources.streams.concurrent.state_converters.abstract_stream_sta
     AbstractStreamStateConverter,
     ConcurrencyCompatibleStateType,
 )
+from airbyte_cdk.utils.datetime_helpers import AirbyteDateTime, ab_datetime_now, ab_datetime_parse
 
 
 class DateTimeStreamStateConverter(AbstractStreamStateConverter):
@@ -36,7 +34,7 @@ class DateTimeStreamStateConverter(AbstractStreamStateConverter):
 
     @classmethod
     def get_end_provider(cls) -> Callable[[], datetime]:
-        return lambda: datetime.now(timezone.utc)
+        return ab_datetime_now
 
     @abstractmethod
     def increment(self, timestamp: datetime) -> datetime: ...
@@ -136,10 +134,10 @@ class EpochValueConcurrentStreamStateConverter(DateTimeStreamStateConverter):
         return int(timestamp.timestamp())
 
     def parse_timestamp(self, timestamp: int) -> datetime:
-        dt_object = pendulum.from_timestamp(timestamp)
-        if not isinstance(dt_object, DateTime):
+        dt_object = AirbyteDateTime.fromtimestamp(timestamp, timezone.utc)
+        if not isinstance(dt_object, AirbyteDateTime):
             raise ValueError(
-                f"DateTime object was expected but got {type(dt_object)} from pendulum.parse({timestamp})"
+                f"AirbyteDateTime object was expected but got {type(dt_object)} from AirbyteDateTime.fromtimestamp({timestamp})"
             )
         return dt_object
 
@@ -169,14 +167,25 @@ class IsoMillisConcurrentStreamStateConverter(DateTimeStreamStateConverter):
     def increment(self, timestamp: datetime) -> datetime:
         return timestamp + self._cursor_granularity
 
-    def output_format(self, timestamp: datetime) -> Any:
-        return timestamp.strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"
+    def output_format(self, timestamp: datetime) -> str:
+        """Format datetime with milliseconds always included.
+
+        Args:
+            timestamp: The datetime to format.
+
+        Returns:
+            str: ISO8601/RFC3339 formatted string with milliseconds.
+        """
+        dt = AirbyteDateTime.from_datetime(timestamp)
+        # Always include milliseconds, even if zero
+        millis = dt.microsecond // 1000 if dt.microsecond else 0
+        return f"{dt.year:04d}-{dt.month:02d}-{dt.day:02d}T{dt.hour:02d}:{dt.minute:02d}:{dt.second:02d}.{millis:03d}Z"
 
     def parse_timestamp(self, timestamp: str) -> datetime:
-        dt_object = pendulum.parse(timestamp)
-        if not isinstance(dt_object, DateTime):
+        dt_object = ab_datetime_parse(timestamp)
+        if not isinstance(dt_object, AirbyteDateTime):
             raise ValueError(
-                f"DateTime object was expected but got {type(dt_object)} from pendulum.parse({timestamp})"
+                f"AirbyteDateTime object was expected but got {type(dt_object)} from parse({timestamp})"
             )
         return dt_object
 
@@ -184,7 +193,7 @@ class IsoMillisConcurrentStreamStateConverter(DateTimeStreamStateConverter):
 class CustomFormatConcurrentStreamStateConverter(IsoMillisConcurrentStreamStateConverter):
     """
     Datetime State converter that emits state according to the supplied datetime format. The converter supports reading
-    incoming state in any valid datetime format via Pendulum.
+    incoming state in any valid datetime format using AirbyteDateTime parsing utilities.
     """
 
     def __init__(

airbyte_cdk/sources/streams/http/requests_native_auth/abstract_oauth.py

@@ -4,11 +4,11 @@
 
 import logging
 from abc import abstractmethod
+from datetime import timedelta
 from json import JSONDecodeError
 from typing import Any, List, Mapping, MutableMapping, Optional, Tuple, Union
 
 import backoff
-import pendulum
 import requests
 from requests.auth import AuthBase
 
@@ -17,6 +17,7 @@ from airbyte_cdk.sources.http_logger import format_http_message
 from airbyte_cdk.sources.message import MessageRepository, NoopMessageRepository
 from airbyte_cdk.utils import AirbyteTracedException
 from airbyte_cdk.utils.airbyte_secrets_utils import add_to_secrets
+from airbyte_cdk.utils.datetime_helpers import AirbyteDateTime, ab_datetime_now, ab_datetime_parse
 
 from ..exceptions import DefaultBackoffException
 
@@ -72,7 +73,7 @@ class AbstractOauth2Authenticator(AuthBase):
 
     def token_has_expired(self) -> bool:
         """Returns True if the token is expired"""
-        return pendulum.now() > self.get_token_expiry_date()  # type: ignore # this is always a bool despite what mypy thinks
+        return ab_datetime_now() > self.get_token_expiry_date()
 
     def build_refresh_request_body(self) -> Mapping[str, Any]:
         """
@@ -179,7 +180,7 @@ class AbstractOauth2Authenticator(AuthBase):
             self.get_expires_in_name()
         ]
 
-    def _parse_token_expiration_date(self, value: Union[str, int]) -> pendulum.DateTime:
+    def _parse_token_expiration_date(self, value: Union[str, int]) -> AirbyteDateTime:
         """
         Return the expiration datetime of the refresh token
 
@@ -191,9 +192,19 @@ class AbstractOauth2Authenticator(AuthBase):
                 raise ValueError(
                     f"Invalid token expiry date format {self.token_expiry_date_format}; a string representing the format is required."
                 )
-            return pendulum.from_format(str(value), self.token_expiry_date_format)
+            try:
+                return ab_datetime_parse(str(value))
+            except ValueError as e:
+                raise ValueError(f"Invalid token expiry date format: {e}")
         else:
-            return pendulum.now().add(seconds=int(float(value)))
+            try:
+                # Only accept numeric values (as int/float/string) when no format specified
+                seconds = int(float(str(value)))
+                return ab_datetime_now() + timedelta(seconds=seconds)
+            except (ValueError, TypeError):
+                raise ValueError(
+                    f"Invalid expires_in value: {value}. Expected number of seconds when no format specified."
+                )
 
     @property
     def token_expiry_is_time_of_expiration(self) -> bool:
@@ -244,7 +255,7 @@ class AbstractOauth2Authenticator(AuthBase):
         """List of requested scopes"""
 
     @abstractmethod
-    def get_token_expiry_date(self) -> pendulum.DateTime:
+    def get_token_expiry_date(self) -> AirbyteDateTime:
         """Expiration date of the access token"""
 
     @abstractmethod

airbyte_cdk/sources/streams/http/requests_native_auth/oauth.py

@@ -2,10 +2,10 @@
 # Copyright (c) 2023 Airbyte, Inc., all rights reserved.
 #
 
+from datetime import timedelta
 from typing import Any, List, Mapping, Optional, Sequence, Tuple, Union
 
 import dpath
-import pendulum
 
 from airbyte_cdk.config_observation import (
     create_connector_config_control_message,
@@ -15,6 +15,11 @@ from airbyte_cdk.sources.message import MessageRepository, NoopMessageRepository
 from airbyte_cdk.sources.streams.http.requests_native_auth.abstract_oauth import (
     AbstractOauth2Authenticator,
 )
+from airbyte_cdk.utils.datetime_helpers import (
+    AirbyteDateTime,
+    ab_datetime_now,
+    ab_datetime_parse,
+)
 
 
 class Oauth2Authenticator(AbstractOauth2Authenticator):
@@ -34,7 +39,7 @@ class Oauth2Authenticator(AbstractOauth2Authenticator):
         client_secret_name: str = "client_secret",
         refresh_token_name: str = "refresh_token",
         scopes: List[str] | None = None,
-        token_expiry_date: pendulum.DateTime | None = None,
+        token_expiry_date: AirbyteDateTime | None = None,
         token_expiry_date_format: str | None = None,
         access_token_name: str = "access_token",
         expires_in_name: str = "expires_in",
@@ -62,7 +67,7 @@ class Oauth2Authenticator(AbstractOauth2Authenticator):
         self._grant_type_name = grant_type_name
         self._grant_type = grant_type
 
-        self._token_expiry_date = token_expiry_date or pendulum.now().subtract(days=1)  # type: ignore [no-untyped-call]
+        self._token_expiry_date = token_expiry_date or (ab_datetime_now() - timedelta(days=1))
         self._token_expiry_date_format = token_expiry_date_format
         self._token_expiry_is_time_of_expiration = token_expiry_is_time_of_expiration
         self._access_token = None
@@ -112,7 +117,7 @@ class Oauth2Authenticator(AbstractOauth2Authenticator):
     def get_grant_type(self) -> str:
         return self._grant_type
 
-    def get_token_expiry_date(self) -> pendulum.DateTime:
+    def get_token_expiry_date(self) -> AirbyteDateTime:
         return self._token_expiry_date
 
     def set_token_expiry_date(self, value: Union[str, int]) -> None:
@@ -276,17 +281,24 @@ class SingleUseRefreshTokenOauth2Authenticator(Oauth2Authenticator):
             new_refresh_token,
         )
 
-    def get_token_expiry_date(self) -> pendulum.DateTime:
+    def get_token_expiry_date(self) -> AirbyteDateTime:
         expiry_date = dpath.get(
             self._connector_config,  # type: ignore[arg-type]
             self._token_expiry_date_config_path,
             default="",
         )
-        return pendulum.now().subtract(days=1) if expiry_date == "" else pendulum.parse(expiry_date)  # type: ignore[arg-type, return-value, no-untyped-call]
+        result = (
+            ab_datetime_now() - timedelta(days=1)
+            if expiry_date == ""
+            else ab_datetime_parse(str(expiry_date))
+        )
+        if isinstance(result, AirbyteDateTime):
+            return result
+        raise TypeError("Invalid datetime conversion")
 
     def set_token_expiry_date(  # type: ignore[override]
         self,
-        new_token_expiry_date: pendulum.DateTime,
+        new_token_expiry_date: AirbyteDateTime,
     ) -> None:
         dpath.new(
             self._connector_config,  # type: ignore[arg-type]
@@ -296,17 +308,17 @@ class SingleUseRefreshTokenOauth2Authenticator(Oauth2Authenticator):
 
     def token_has_expired(self) -> bool:
         """Returns True if the token is expired"""
-        return pendulum.now("UTC") > self.get_token_expiry_date()
+        return ab_datetime_now() > self.get_token_expiry_date()
 
     @staticmethod
     def get_new_token_expiry_date(
         access_token_expires_in: str,
         token_expiry_date_format: str | None = None,
-    ) -> pendulum.DateTime:
+    ) -> AirbyteDateTime:
         if token_expiry_date_format:
-            return pendulum.from_format(access_token_expires_in, token_expiry_date_format)
+            return ab_datetime_parse(access_token_expires_in)
         else:
-            return pendulum.now("UTC").add(seconds=int(access_token_expires_in))
+            return ab_datetime_now() + timedelta(seconds=int(access_token_expires_in))
 
     def get_access_token(self) -> str:
         """Retrieve new access and refresh token if the access token has expired.
@@ -318,7 +330,7 @@ class SingleUseRefreshTokenOauth2Authenticator(Oauth2Authenticator):
             new_access_token, access_token_expires_in, new_refresh_token = (
                 self.refresh_access_token()
             )
-            new_token_expiry_date: pendulum.DateTime = self.get_new_token_expiry_date(
+            new_token_expiry_date: AirbyteDateTime = self.get_new_token_expiry_date(
                 access_token_expires_in, self._token_expiry_date_format
             )
             self.access_token = new_access_token

airbyte_cdk/sources/utils/transform.py

@@ -3,7 +3,6 @@
 #
 
 import logging
-from distutils.util import strtobool
 from enum import Flag, auto
 from typing import Any, Callable, Dict, Generator, Mapping, Optional, cast
 
@@ -22,6 +21,28 @@ python_to_json = {v: k for k, v in json_to_python.items()}
 
 logger = logging.getLogger("airbyte")
 
+_TRUTHY_STRINGS = ("y", "yes", "t", "true", "on", "1")
+_FALSEY_STRINGS = ("n", "no", "f", "false", "off", "0")
+
+
+def _strtobool(value: str, /) -> int:
+    """Mimic the behavior of distutils.util.strtobool.
+
+    From: https://docs.python.org/2/distutils/apiref.html#distutils.util.strtobool
+
+    > Convert a string representation of truth to true (1) or false (0).
+    > True values are y, yes, t, true, on and 1; false values are n, no, f, false, off and 0. Raises
+    > `ValueError` if val is anything else.
+    """
+    normalized_str = value.lower().strip()
+    if normalized_str in _TRUTHY_STRINGS:
+        return 1
+
+    if normalized_str in _FALSEY_STRINGS:
+        return 0
+
+    raise ValueError(f"Invalid boolean value: {normalized_str}")
+
 
 class TransformConfig(Flag):
     """
@@ -129,7 +150,7 @@ class TypeTransformer:
                 return int(original_item)
             elif target_type == "boolean":
                 if isinstance(original_item, str):
-                    return strtobool(original_item) == 1
+                    return _strtobool(original_item) == 1
                 return bool(original_item)
             elif target_type == "array":
                 item_types = set(subschema.get("items", {}).get("type", set()))

airbyte_cdk/utils/datetime_helpers.py

@@ -0,0 +1,517 @@
+"""Provides consistent datetime handling across Airbyte with ISO8601/RFC3339 compliance.
+
+Copyright (c) 2023 Airbyte, Inc., all rights reserved.
+
+This module provides a custom datetime class (AirbyteDateTime) and helper functions that ensure
+consistent datetime handling across Airbyte. All datetime strings are formatted according to
+ISO8601/RFC3339 standards with 'T' delimiter and '+00:00' for UTC timezone.
+
+Key Features:
+    - Timezone-aware datetime objects (defaults to UTC)
+    - ISO8601/RFC3339 compliant string formatting
+    - Consistent parsing of various datetime formats
+    - Support for Unix timestamps and milliseconds
+    - Type-safe datetime arithmetic with timedelta
+
+## Basic Usage
+
+```python
+from airbyte_cdk.utils.datetime_helpers import AirbyteDateTime, ab_datetime_now, ab_datetime_parse
+from datetime import timedelta, timezone
+
+## Current time in UTC
+now = ab_datetime_now()
+print(now)  # 2023-03-14T15:09:26.535897Z
+
+# Parse various datetime formats
+dt = ab_datetime_parse("2023-03-14T15:09:26Z")  # ISO8601/RFC3339
+dt = ab_datetime_parse("2023-03-14")  # Date only (assumes midnight UTC)
+dt = ab_datetime_parse(1678806566)  # Unix timestamp
+
+## Create with explicit timezone
+dt = AirbyteDateTime(2023, 3, 14, 15, 9, 26, tzinfo=timezone.utc)
+print(dt)  # 2023-03-14T15:09:26+00:00
+
+# Datetime arithmetic with timedelta
+tomorrow = dt + timedelta(days=1)
+yesterday = dt - timedelta(days=1)
+time_diff = tomorrow - yesterday  # timedelta object
+```
+
+## Millisecond Timestamp Handling
+
+```python
+# Convert to millisecond timestamp
+dt = ab_datetime_parse("2023-03-14T15:09:26Z")
+ms = dt.to_epoch_millis()  # 1678806566000
+
+# Create from millisecond timestamp
+dt = AirbyteDateTime.from_epoch_millis(1678806566000)
+print(dt)  # 2023-03-14T15:09:26Z
+```
+
+## Timezone Handling
+
+```python
+# Create with non-UTC timezone
+tz = timezone(timedelta(hours=-4))  # EDT
+dt = AirbyteDateTime(2023, 3, 14, 15, 9, 26, tzinfo=tz)
+print(dt)  # 2023-03-14T15:09:26-04:00
+
+## Parse with timezone
+dt = ab_datetime_parse("2023-03-14T15:09:26-04:00")
+print(dt)  # 2023-03-14T15:09:26-04:00
+
+## Naive datetimes are automatically converted to UTC
+dt = ab_datetime_parse("2023-03-14T15:09:26")
+print(dt)  # 2023-03-14T15:09:26Z
+```
+
+# Format Validation
+
+```python
+from airbyte_cdk.utils.datetime_helpers import ab_datetime_try_parse
+
+# Validate ISO8601/RFC3339 format
+assert ab_datetime_try_parse("2023-03-14T15:09:26Z")       # Basic UTC format
+assert ab_datetime_try_parse("2023-03-14T15:09:26-04:00")  # With timezone offset
+assert ab_datetime_try_parse("2023-03-14T15:09:26+00:00")  # With explicit UTC offset
+assert not ab_datetime_try_parse("2023-03-14 15:09:26Z")   # Invalid: missing T delimiter
+assert not ab_datetime_try_parse("foo")                     # Invalid: not a datetime
+```
+"""
+
+from datetime import datetime, timedelta, timezone
+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):
+    """A timezone-aware datetime class with ISO8601/RFC3339 string representation and operator overloading.
+
+    This class extends the standard datetime class to provide consistent timezone handling
+    (defaulting to UTC) and ISO8601/RFC3339 compliant string formatting. It also supports
+    operator overloading for datetime arithmetic with timedelta objects.
+
+    Example:
+        >>> dt = AirbyteDateTime(2023, 3, 14, 15, 9, 26, tzinfo=timezone.utc)
+        >>> str(dt)
+        '2023-03-14T15:09:26+00:00'
+        >>> dt + timedelta(hours=1)
+        '2023-03-14T16:09:26+00:00'
+    """
+
+    def __new__(cls, *args: Any, **kwargs: Any) -> "AirbyteDateTime":
+        """Creates a new timezone-aware AirbyteDateTime instance.
+
+        Ensures all instances are timezone-aware by defaulting to UTC if no timezone is provided.
+
+        Returns:
+            AirbyteDateTime: A new timezone-aware datetime instance.
+        """
+        self = super().__new__(cls, *args, **kwargs)
+        if self.tzinfo is None:
+            return self.replace(tzinfo=timezone.utc)
+        return self
+
+    @classmethod
+    def from_datetime(cls, dt: datetime) -> "AirbyteDateTime":
+        """Converts a standard datetime to AirbyteDateTime.
+
+        Args:
+            dt: A standard datetime object to convert.
+
+        Returns:
+            AirbyteDateTime: A new timezone-aware AirbyteDateTime instance.
+        """
+        return cls(
+            dt.year,
+            dt.month,
+            dt.day,
+            dt.hour,
+            dt.minute,
+            dt.second,
+            dt.microsecond,
+            dt.tzinfo or timezone.utc,
+        )
+
+    def __str__(self) -> str:
+        """Returns the datetime in ISO8601/RFC3339 format with 'T' delimiter.
+
+        Ensures consistent string representation with timezone, using '+00:00' for UTC.
+        Preserves full microsecond precision when present, omits when zero.
+
+        Returns:
+            str: ISO8601/RFC3339 formatted string.
+        """
+        aware_self = self if self.tzinfo else self.replace(tzinfo=timezone.utc)
+        base = self.strftime("%Y-%m-%dT%H:%M:%S")
+        if self.microsecond:
+            base = f"{base}.{self.microsecond:06d}"
+        # Format timezone as ±HH:MM
+        offset = aware_self.strftime("%z")
+        return f"{base}{offset[:3]}:{offset[3:]}"
+
+    def __repr__(self) -> str:
+        """Returns the same string representation as __str__ for consistency.
+
+        Returns:
+            str: ISO8601/RFC3339 formatted string.
+        """
+        return self.__str__()
+
+    def add(self, delta: timedelta) -> "AirbyteDateTime":
+        """Add a timedelta interval to this datetime.
+
+        This method provides a more explicit alternative to the + operator
+        for adding time intervals to datetimes.
+
+        Args:
+            delta: The timedelta interval to add.
+
+        Returns:
+            AirbyteDateTime: A new datetime with the interval added.
+
+        Example:
+            >>> dt = AirbyteDateTime(2023, 3, 14, tzinfo=timezone.utc)
+            >>> dt.add(timedelta(hours=1))
+            '2023-03-14T01:00:00Z'
+        """
+        return self + delta
+
+    def subtract(self, delta: timedelta) -> "AirbyteDateTime":
+        """Subtract a timedelta interval from this datetime.
+
+        This method provides a more explicit alternative to the - operator
+        for subtracting time intervals from datetimes.
+
+        Args:
+            delta: The timedelta interval to subtract.
+
+        Returns:
+            AirbyteDateTime: A new datetime with the interval subtracted.
+
+        Example:
+            >>> dt = AirbyteDateTime(2023, 3, 14, tzinfo=timezone.utc)
+            >>> dt.subtract(timedelta(hours=1))
+            '2023-03-13T23:00:00Z'
+        """
+        result = super().__sub__(delta)
+        if isinstance(result, datetime):
+            return AirbyteDateTime.from_datetime(result)
+        raise TypeError("Invalid operation")
+
+    def __add__(self, other: timedelta) -> "AirbyteDateTime":
+        """Adds a timedelta to this datetime.
+
+        Args:
+            other: A timedelta object to add.
+
+        Returns:
+            AirbyteDateTime: A new datetime with the timedelta added.
+
+        Raises:
+            TypeError: If other is not a timedelta.
+        """
+        result = super().__add__(other)
+        if isinstance(result, datetime):
+            return AirbyteDateTime.from_datetime(result)
+        raise TypeError("Invalid operation")
+
+    def __radd__(self, other: timedelta) -> "AirbyteDateTime":
+        """Supports timedelta + AirbyteDateTime operation.
+
+        Args:
+            other: A timedelta object to add.
+
+        Returns:
+            AirbyteDateTime: A new datetime with the timedelta added.
+
+        Raises:
+            TypeError: If other is not a timedelta.
+        """
+        return self.__add__(other)
+
+    @overload  # type: ignore[override]
+    def __sub__(self, other: timedelta) -> "AirbyteDateTime": ...
+
+    @overload  # type: ignore[override]
+    def __sub__(self, other: Union[datetime, "AirbyteDateTime"]) -> timedelta: ...
+
+    def __sub__(
+        self, other: Union[datetime, "AirbyteDateTime", timedelta]
+    ) -> Union[timedelta, "AirbyteDateTime"]:  # type: ignore[override]
+        """Subtracts a datetime, AirbyteDateTime, or timedelta from this datetime.
+
+        Args:
+            other: A datetime, AirbyteDateTime, or timedelta object to subtract.
+
+        Returns:
+            Union[timedelta, AirbyteDateTime]: A timedelta if subtracting datetime/AirbyteDateTime,
+                or a new datetime if subtracting timedelta.
+
+        Raises:
+            TypeError: If other is not a datetime, AirbyteDateTime, or timedelta.
+        """
+        if isinstance(other, timedelta):
+            result = super().__sub__(other)  # type: ignore[call-overload]
+            if isinstance(result, datetime):
+                return AirbyteDateTime.from_datetime(result)
+        elif isinstance(other, (datetime, AirbyteDateTime)):
+            result = super().__sub__(other)  # type: ignore[call-overload]
+            if isinstance(result, timedelta):
+                return result
+        raise TypeError(
+            f"unsupported operand type(s) for -: '{type(self).__name__}' and '{type(other).__name__}'"
+        )
+
+    def __rsub__(self, other: datetime) -> timedelta:
+        """Supports datetime - AirbyteDateTime operation.
+
+        Args:
+            other: A datetime object.
+
+        Returns:
+            timedelta: The time difference between the datetimes.
+
+        Raises:
+            TypeError: If other is not a datetime.
+        """
+        if not isinstance(other, datetime):
+            return NotImplemented
+        result = other - datetime(
+            self.year,
+            self.month,
+            self.day,
+            self.hour,
+            self.minute,
+            self.second,
+            self.microsecond,
+            self.tzinfo,
+        )
+        if isinstance(result, timedelta):
+            return result
+        raise TypeError("Invalid operation")
+
+    def to_epoch_millis(self) -> int:
+        """Return the Unix timestamp in milliseconds for this datetime.
+
+        Returns:
+            int: Number of milliseconds since Unix epoch (January 1, 1970).
+
+        Example:
+            >>> dt = AirbyteDateTime(2023, 3, 14, 15, 9, 26, tzinfo=timezone.utc)
+            >>> dt.to_epoch_millis()
+            1678806566000
+        """
+        return int(self.timestamp() * 1000)
+
+    @classmethod
+    def from_epoch_millis(cls, milliseconds: int) -> "AirbyteDateTime":
+        """Create an AirbyteDateTime from Unix timestamp in milliseconds.
+
+        Args:
+            milliseconds: Number of milliseconds since Unix epoch (January 1, 1970).
+
+        Returns:
+            AirbyteDateTime: A new timezone-aware datetime instance (UTC).
+
+        Example:
+            >>> dt = AirbyteDateTime.from_epoch_millis(1678806566000)
+            >>> str(dt)
+            '2023-03-14T15:09:26+00:00'
+        """
+        return cls.fromtimestamp(milliseconds / 1000.0, timezone.utc)
+
+    @classmethod
+    def from_str(cls, dt_str: str) -> "AirbyteDateTime":
+        """Thin convenience wrapper around `ab_datetime_parse()`.
+
+        This method attempts to create a new `AirbyteDateTime` using all available parsing
+        strategies.
+
+        Raises:
+            ValueError: If the value cannot be parsed into a valid datetime object.
+        """
+        return ab_datetime_parse(dt_str)
+
+
+def ab_datetime_now() -> AirbyteDateTime:
+    """Returns the current time as an AirbyteDateTime in UTC timezone.
+
+    Previously named: now()
+
+    Returns:
+        AirbyteDateTime: Current UTC time.
+
+    Example:
+        >>> dt = ab_datetime_now()
+        >>> str(dt)  # Returns current time in ISO8601/RFC3339
+        '2023-03-14T15:09:26.535897Z'
+    """
+    return AirbyteDateTime.from_datetime(datetime.now(timezone.utc))
+
+
+def ab_datetime_parse(dt_str: str | int) -> AirbyteDateTime:
+    """Parses a datetime string or timestamp into an AirbyteDateTime with timezone awareness.
+
+    Previously named: parse()
+
+    Handles:
+        - ISO8601/RFC3339 format strings (with 'T' delimiter)
+        - Unix timestamps (as integers or strings)
+        - Date-only strings (YYYY-MM-DD)
+        - Timezone-aware formats (+00:00 for UTC, or ±HH:MM offset)
+
+    Always returns a timezone-aware datetime (defaults to UTC if no timezone specified).
+
+    Args:
+        dt_str: A datetime string in ISO8601/RFC3339 format, Unix timestamp (int/str),
+            or other recognizable datetime format.
+
+    Returns:
+        AirbyteDateTime: A timezone-aware datetime object.
+
+    Raises:
+        ValueError: If the input cannot be parsed as a valid datetime.
+
+    Example:
+        >>> ab_datetime_parse("2023-03-14T15:09:26+00:00")
+        '2023-03-14T15:09:26+00:00'
+        >>> ab_datetime_parse(1678806000)  # Unix timestamp
+        '2023-03-14T15:00:00+00:00'
+        >>> ab_datetime_parse("2023-03-14")  # Date-only
+        '2023-03-14T00:00:00+00:00'
+    """
+    try:
+        # Handle numeric values as Unix timestamps (UTC)
+        if isinstance(dt_str, int) or (
+            isinstance(dt_str, str)
+            and (dt_str.isdigit() or (dt_str.startswith("-") and dt_str[1:].isdigit()))
+        ):
+            timestamp = int(dt_str)
+            if timestamp < 0:
+                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())
+
+        if not isinstance(dt_str, str):
+            raise ValueError(
+                f"Could not parse datetime string: expected string or integer, got {type(dt_str)}"
+            )
+
+        # Handle date-only format first
+        if ":" not in dt_str and dt_str.count("-") == 2 and "/" not in dt_str:
+            try:
+                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())
+            except (ValueError, TypeError):
+                raise ValueError(f"Invalid date format: {dt_str}")
+
+        # Validate datetime format
+        if "/" in dt_str or " " in dt_str or "GMT" in dt_str:
+            raise ValueError(f"Could not parse datetime string: {dt_str}")
+
+        # Try parsing with dateutil for timezone handling
+        try:
+            parsed = parser.parse(dt_str)
+            if parsed.tzinfo is None:
+                parsed = parsed.replace(tzinfo=timezone.utc)
+            return AirbyteDateTime.from_datetime(parsed)
+        except (ValueError, TypeError):
+            raise ValueError(f"Could not parse datetime string: {dt_str}")
+    except ValueError as e:
+        if "Invalid date format:" in str(e):
+            raise
+        if "Timestamp cannot be negative" in str(e):
+            raise
+        if "Timestamp value too large" in str(e):
+            raise
+        raise ValueError(f"Could not parse datetime string: {dt_str}")
+
+
+def ab_datetime_format(dt: Union[datetime, AirbyteDateTime]) -> str:
+    """Formats a datetime object as an ISO8601/RFC3339 string with 'T' delimiter and timezone.
+
+    Previously named: format()
+
+    Converts any datetime object to a string with 'T' delimiter and proper timezone.
+    If the datetime is naive (no timezone), UTC is assumed.
+    Uses '+00:00' for UTC timezone, otherwise keeps the original timezone offset.
+
+    Args:
+        dt: Any datetime object to format.
+
+    Returns:
+        str: ISO8601/RFC3339 formatted datetime string.
+
+    Example:
+        >>> dt = datetime(2023, 3, 14, 15, 9, 26, tzinfo=timezone.utc)
+        >>> ab_datetime_format(dt)
+        '2023-03-14T15:09:26+00:00'
+    """
+    if isinstance(dt, AirbyteDateTime):
+        return str(dt)
+
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
+
+    # Format with consistent timezone representation
+    base = dt.strftime("%Y-%m-%dT%H:%M:%S")
+    if dt.microsecond:
+        base = f"{base}.{dt.microsecond:06d}"
+    offset = dt.strftime("%z")
+    return f"{base}{offset[:3]}:{offset[3:]}"
+
+
+def ab_datetime_try_parse(dt_str: str) -> AirbyteDateTime | None:
+    """Try to parse the input string as an ISO8601/RFC3339 datetime, failing gracefully instead of raising an exception.
+
+    Requires strict ISO8601/RFC3339 format with:
+    - 'T' delimiter between date and time components
+    - Valid timezone (Z for UTC or ±HH:MM offset)
+    - Complete datetime representation (date and time)
+
+    Returns None for any non-compliant formats including:
+    - Space-delimited datetimes
+    - Date-only strings
+    - Missing timezone
+    - Invalid timezone format
+    - Wrong date/time separators
+
+    Example:
+        >>> ab_datetime_try_parse("2023-03-14T15:09:26Z")  # Returns AirbyteDateTime
+        >>> ab_datetime_try_parse("2023-03-14 15:09:26Z")  # Returns None (invalid format)
+        >>> ab_datetime_try_parse("2023-03-14")  # Returns None (missing time and timezone)
+    """
+    if not isinstance(dt_str, str):
+        return None
+    try:
+        # Validate format before parsing
+        if "T" not in dt_str:
+            return None
+        if not any(x in dt_str for x in ["Z", "+", "-"]):
+            return None
+        if "/" in dt_str or " " in dt_str or "GMT" in dt_str:
+            return None
+
+        # Try parsing with dateutil
+        parsed = parser.parse(dt_str)
+        if parsed.tzinfo is None:
+            return None
+
+        # Validate time components
+        if not (0 <= parsed.hour <= 23 and 0 <= parsed.minute <= 59 and 0 <= parsed.second <= 59):
+            return None
+
+        return AirbyteDateTime.from_datetime(parsed)
+    except (ValueError, TypeError):
+        return None

airbyte_cdk-6.28.0.dist-info/LICENSE_SHORT

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

{airbyte_cdk-6.27.2.dist-info → airbyte_cdk-6.28.0.dist-info}/METADATA

@@ -1,19 +1,20 @@
 Metadata-Version: 2.1
 Name: airbyte-cdk
-Version: 6.27.2
+Version: 6.28.0
 Summary: A framework for writing Airbyte Connectors.
 Home-page: https://airbyte.com
 License: MIT
 Keywords: airbyte,connector-development-kit,cdk
 Author: Airbyte
 Author-email: contact@airbyte.io
-Requires-Python: >=3.10,<3.12
+Requires-Python: >=3.10,<3.13
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Provides-Extra: file-based
@@ -45,7 +46,6 @@ Requires-Dist: orjson (>=3.10.7,<4.0.0)
 Requires-Dist: pandas (==2.2.2)
 Requires-Dist: pdf2image (==1.16.3) ; extra == "file-based"
 Requires-Dist: pdfminer.six (==20221105) ; extra == "file-based"
-Requires-Dist: pendulum (<3.0.0)
 Requires-Dist: psutil (==6.1.0)
 Requires-Dist: pyarrow (>=15.0.0,<15.1.0) ; extra == "file-based"
 Requires-Dist: pydantic (>=2.7,<3.0)
@@ -53,7 +53,7 @@ Requires-Dist: pyjwt (>=2.8.0,<3.0.0)
 Requires-Dist: pyrate-limiter (>=3.1.0,<3.2.0)
 Requires-Dist: pytesseract (==0.3.10) ; extra == "file-based"
 Requires-Dist: python-calamine (==0.2.3) ; extra == "file-based"
-Requires-Dist: python-dateutil
+Requires-Dist: python-dateutil (>=2.9.0,<3.0.0)
 Requires-Dist: python-snappy (==0.7.3) ; extra == "file-based"
 Requires-Dist: python-ulid (>=3.0.0,<4.0.0)
 Requires-Dist: pytz (==2024.2)
@@ -66,6 +66,7 @@ Requires-Dist: tiktoken (==0.8.0) ; extra == "vector-db-based"
 Requires-Dist: unstructured.pytesseract (>=0.3.12) ; extra == "file-based"
 Requires-Dist: unstructured[docx,pptx] (==0.10.27) ; extra == "file-based"
 Requires-Dist: wcmatch (==10.0)
+Requires-Dist: whenever (>=0.6.16,<0.7.0)
 Requires-Dist: xmltodict (>=0.13,<0.15)
 Project-URL: Documentation, https://docs.airbyte.io/
 Project-URL: Repository, https://github.com/airbytehq/airbyte-python-cdk

{airbyte_cdk-6.27.2.dist-info → airbyte_cdk-6.28.0.dist-info}/RECORD

@@ -1,13 +1,13 @@
 airbyte_cdk/__init__.py,sha256=52uncJvDQNHvwKxaqzXgnMYTptIl65LDJr2fvlk8-DU,11707
 airbyte_cdk/cli/__init__.py,sha256=Hu-1XT2KDoYjDF7-_ziDwv5bY3PueGjANOCbzeOegDg,57
 airbyte_cdk/cli/source_declarative_manifest/__init__.py,sha256=-0ST722Nj65bgRokzpzPkD1NBBW5CytEHFUe38cB86Q,91
-airbyte_cdk/cli/source_declarative_manifest/_run.py,sha256=dMNFuS_z3irzN8IoHj0o155Oeud1E0rMuNAD3jyY1Q8,8303
+airbyte_cdk/cli/source_declarative_manifest/_run.py,sha256=9qtbjt-I_stGWzWX6yVUKO_eE-Ga7g-uTuibML9qLBs,8330
 airbyte_cdk/cli/source_declarative_manifest/spec.json,sha256=Earc1L6ngcdIr514oFQlUoOxdF4RHqtUyStSIAquXdY,554
 airbyte_cdk/config_observation.py,sha256=7SSPxtN0nXPkm4euGNcTTr1iLbwUL01jy-24V1Hzde0,3986
 airbyte_cdk/connector.py,sha256=bO23kdGRkl8XKFytOgrrWFc_VagteTHVEF6IsbizVkM,4224
 airbyte_cdk/connector_builder/README.md,sha256=Hw3wvVewuHG9-QgsAq1jDiKuLlStDxKBz52ftyNRnBw,1665
 airbyte_cdk/connector_builder/__init__.py,sha256=4Hw-PX1-VgESLF16cDdvuYCzGJtHntThLF4qIiULWeo,61
-airbyte_cdk/connector_builder/connector_builder_handler.py,sha256=umB60OXyrCxzbO3qWMy870YRlnubmIiPG76ZoP8Hq_s,4255
+airbyte_cdk/connector_builder/connector_builder_handler.py,sha256=CZX1tdWYLdPE_2XtH2KnFNsHrqvWNxsotzTsKii0vrQ,4285
 airbyte_cdk/connector_builder/main.py,sha256=ubAPE0Oo5gjZOa-KMtLLJQkc8_inUpFR3sIb2DEh2No,3722
 airbyte_cdk/connector_builder/message_grouper.py,sha256=Xckskpqe9kbUByaKVmPsfTKxuyI2FHt8k4NZ4p8xo_I,19813
 airbyte_cdk/connector_builder/models.py,sha256=uCHpOdJx2PyZtIqk-mt9eSVuFMQoEqrW-9sjCz0Z-AQ,1500
@@ -53,10 +53,10 @@ airbyte_cdk/sources/declarative/async_job/timer.py,sha256=Fb8P72CQ7jIzJyzMSSNuBf
 airbyte_cdk/sources/declarative/auth/__init__.py,sha256=e2CRrcBWGhz3sQu3Oh34d1riEIwXipGS8hrSB1pu0Oo,284
 airbyte_cdk/sources/declarative/auth/declarative_authenticator.py,sha256=nf-OmRUHYG4ORBwyb5CANzuHEssE-oNmL-Lccn41Td8,1099
 airbyte_cdk/sources/declarative/auth/jwt.py,sha256=7r5q1zOekjw8kEmEk1oUyovzVt3cbD6BuFnRILeLZi8,8250
-airbyte_cdk/sources/declarative/auth/oauth.py,sha256=EoSPxwe40A6VT5K4N7n7TnrGr7wQD4eMltfOBVeuMMQ,13506
+airbyte_cdk/sources/declarative/auth/oauth.py,sha256=fibXa-dqtM54jIUscWbz7DEA5uY6F2o1LfARjEeGRy0,13926
 airbyte_cdk/sources/declarative/auth/selective_authenticator.py,sha256=qGwC6YsCldr1bIeKG6Qo-A9a5cTdHw-vcOn3OtQrS4c,1540
 airbyte_cdk/sources/declarative/auth/token.py,sha256=r4u3WXyVa7WmiSZ9-eZXlrUI-pS0D4YWJnwjLzwV-Fk,11210
-airbyte_cdk/sources/declarative/auth/token_provider.py,sha256=9oq3dcBPAPwXSfkISjhA05dMhIzxaDQTmwOydBrnsMk,3028
+airbyte_cdk/sources/declarative/auth/token_provider.py,sha256=9CuSsmOoHkvlc4k-oZ3Jx5luAgfTMm1I_5HOZxw7wMU,3075
 airbyte_cdk/sources/declarative/checks/__init__.py,sha256=nsVV5Bo0E_tBNd8A4Xdsdb-75PpcLo5RQu2RQ_Gv-ME,806
 airbyte_cdk/sources/declarative/checks/check_dynamic_stream.py,sha256=aXKL1YSAB-0T_eZiavb7e5rprf-DdXG77Fy81FtlcWk,1843
 airbyte_cdk/sources/declarative/checks/check_stream.py,sha256=dAA-UhmMj0WLXCkRQrilWCfJmncBzXCZ18ptRNip3XA,2139
@@ -277,7 +277,7 @@ airbyte_cdk/sources/streams/concurrent/partitions/stream_slicer.py,sha256=nbdkkH
 airbyte_cdk/sources/streams/concurrent/partitions/types.py,sha256=frPVvHtY7vLxpGEbMQzNvF1Y52ZVyct9f1DDhGoRjwY,1166
 airbyte_cdk/sources/streams/concurrent/state_converters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 airbyte_cdk/sources/streams/concurrent/state_converters/abstract_stream_state_converter.py,sha256=CXHUMOhndu-LOKgsnNTItv5s5qrKpmJDeHOzlH1nBy8,6819
-airbyte_cdk/sources/streams/concurrent/state_converters/datetime_stream_state_converter.py,sha256=syjdxEoElIOzqVS5Jrm5FOR70jsbBdttEO_3Iz12Jyo,7523
+airbyte_cdk/sources/streams/concurrent/state_converters/datetime_stream_state_converter.py,sha256=x8MLm1pTMfLNHvMF3P1ixYkYt_xjpbaIwnvhY_ofdBo,8076
 airbyte_cdk/sources/streams/core.py,sha256=jiYW6w8cjNjzXMd8U8Gt-02fYYU7b0ciXSSSnGvFRak,32219
 airbyte_cdk/sources/streams/http/__init__.py,sha256=AGiEZ5B1Joi9ZnFpkJLT7F3QLpCAaBgAeVWy-1znmZw,311
 airbyte_cdk/sources/streams/http/availability_strategy.py,sha256=sovoGFThZr-doMN9vJvTuJBrvkwQVIO0qTQO64pGZPY,2428
@@ -295,9 +295,9 @@ airbyte_cdk/sources/streams/http/http.py,sha256=JAMpiTdS9HFNOlwayWNvQdxoqs2rpW9w
 airbyte_cdk/sources/streams/http/http_client.py,sha256=tDE0ROtxjGMVphvsw8INvGMtZ97hIF-v47pZ3jIyiwc,23011
 airbyte_cdk/sources/streams/http/rate_limiting.py,sha256=IwdjrHKUnU97XO4qONgYRv4YYW51xQ8SJm4WLafXDB8,6351
 airbyte_cdk/sources/streams/http/requests_native_auth/__init__.py,sha256=RN0D3nOX1xLgwEwKWu6pkGy3XqBFzKSNZ8Lf6umU2eY,413
-airbyte_cdk/sources/streams/http/requests_native_auth/abstract_oauth.py,sha256=-GDNyqccdutOftFpqCvvk81NwkskHhDZ8QcsUKzNjRQ,11660
+airbyte_cdk/sources/streams/http/requests_native_auth/abstract_oauth.py,sha256=DKv9oAHaEp80qHpy3JBaMhn8QLfXavoUpY4fIY77Fkk,12176
 airbyte_cdk/sources/streams/http/requests_native_auth/abstract_token.py,sha256=Y3n7J-sk5yGjv_OxtY6Z6k0PEsFZmtIRi-x0KCbaHdA,1010
-airbyte_cdk/sources/streams/http/requests_native_auth/oauth.py,sha256=Zse4ve1MvPJBx-7CDtTBTmPuT6b9koGLMGpmd5188Y8,16698
+airbyte_cdk/sources/streams/http/requests_native_auth/oauth.py,sha256=jYlqj7wUs7z7son6mmKjbNzyizN7iWv9MeuRiYRpPHo,16902
 airbyte_cdk/sources/streams/http/requests_native_auth/token.py,sha256=h5PTzcdH-RQLeCg7xZ45w_484OPUDSwNWl_iMJQmZoI,2526
 airbyte_cdk/sources/streams/utils/__init__.py,sha256=4Hw-PX1-VgESLF16cDdvuYCzGJtHntThLF4qIiULWeo,61
 airbyte_cdk/sources/types.py,sha256=aFPGI4t2K1vHz2oFSUIYUyDN7kw-vcYq4D7aD2zgfAU,5128
@@ -306,7 +306,7 @@ airbyte_cdk/sources/utils/casing.py,sha256=QC-gV1O4e8DR4-bhdXieUPKm_JamzslVyfABL
 airbyte_cdk/sources/utils/record_helper.py,sha256=jeB0mucudzna7Zvj-pCBbwFrbLJ36SlAWZTh5O4Fb9Y,2168
 airbyte_cdk/sources/utils/schema_helpers.py,sha256=bR3I70-e11S6B8r6VK-pthQXtcYrXojgXFvuK7lRrpg,8545
 airbyte_cdk/sources/utils/slice_logger.py,sha256=qWWeFLAvigFz0b4O1_O3QDM1cy8PqZAMMgVPR2hEeb8,1778
-airbyte_cdk/sources/utils/transform.py,sha256=Sks6kiRbef1W-5I6PRqnFxksJe2NOPKCRXQLudaltf8,11015
+airbyte_cdk/sources/utils/transform.py,sha256=0LOvIJg1vmg_70AiAVe-YHMr-LHrqEuxg9cm1BnYPDM,11725
 airbyte_cdk/sources/utils/types.py,sha256=41ZQR681t5TUnOScij58d088sb99klH_ZENFcaYro_g,175
 airbyte_cdk/sql/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 airbyte_cdk/sql/_util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -339,6 +339,7 @@ airbyte_cdk/utils/airbyte_secrets_utils.py,sha256=wEtRnl5KRhN6eLJwrDrC4FJjyqt_4v
 airbyte_cdk/utils/analytics_message.py,sha256=bi3uugQ2NjecnwTnz63iD5D1M8ZR8mXPbdtt6w5cC4s,653
 airbyte_cdk/utils/constants.py,sha256=QzCi7j5SqpI5I06uRvQ8FC73JVJi7rXaRnR3E_gro5c,108
 airbyte_cdk/utils/datetime_format_inferrer.py,sha256=Ne2cpk7Tx3eZDEW2Q3O7jnNOY9g-w-AUMt3Ltvwg1tY,3989
+airbyte_cdk/utils/datetime_helpers.py,sha256=PD47CAFDt0ZeCSH8HiVDyPKym0qAuGmaZrClPyVwO0U,18012
 airbyte_cdk/utils/event_timing.py,sha256=aiuFmPU80buLlNdKq4fDTEqqhEIelHPF6AalFGwY8as,2557
 airbyte_cdk/utils/is_cloud_environment.py,sha256=DayV32Irh-SdnJ0MnjvstwCJ66_l5oEsd8l85rZtHoc,574
 airbyte_cdk/utils/mapping_helpers.py,sha256=H7BH-Yr8hSRG4W0zZcQ0ZzKOY5QFn8fNkGcEsE3xZN8,1736
@@ -350,8 +351,9 @@ airbyte_cdk/utils/slice_hasher.py,sha256=EDxgROHDbfG-QKQb59m7h_7crN1tRiawdf5uU7G
 airbyte_cdk/utils/spec_schema_transformations.py,sha256=-5HTuNsnDBAhj-oLeQXwpTGA0HdcjFOf2zTEMUTTg_Y,816
 airbyte_cdk/utils/stream_status_utils.py,sha256=ZmBoiy5HVbUEHAMrUONxZvxnvfV9CesmQJLDTAIWnWw,1171
 airbyte_cdk/utils/traced_exception.py,sha256=C8uIBuCL_E4WnBAOPSxBicD06JAldoN9fGsQDp463OY,6292
-airbyte_cdk-6.27.2.dist-info/LICENSE.txt,sha256=Wfe61S4BaGPj404v8lrAbvhjYR68SHlkzeYrg3_bbuM,1051
-airbyte_cdk-6.27.2.dist-info/METADATA,sha256=efz3OhjjZMxAI6kDoM6y09zWy_KbGBpm1rYCdZVg8lU,5933
-airbyte_cdk-6.27.2.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-airbyte_cdk-6.27.2.dist-info/entry_points.txt,sha256=fj-e3PAQvsxsQzyyq8UkG1k8spunWnD4BAH2AwlR6NM,95
-airbyte_cdk-6.27.2.dist-info/RECORD,,
+airbyte_cdk-6.28.0.dist-info/LICENSE.txt,sha256=Wfe61S4BaGPj404v8lrAbvhjYR68SHlkzeYrg3_bbuM,1051
+airbyte_cdk-6.28.0.dist-info/LICENSE_SHORT,sha256=aqF6D1NcESmpn-cqsxBtszTEnHKnlsp8L4x9wAh3Nxg,55
+airbyte_cdk-6.28.0.dist-info/METADATA,sha256=EYHArwfUWLBPhnr-8IYPz0Vhh8cA3Nx5BKznR26QB2g,6010
+airbyte_cdk-6.28.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+airbyte_cdk-6.28.0.dist-info/entry_points.txt,sha256=fj-e3PAQvsxsQzyyq8UkG1k8spunWnD4BAH2AwlR6NM,95
+airbyte_cdk-6.28.0.dist-info/RECORD,,