airbyte-cdk 6.31.1.dev0__py3-none-any.whl → 6.31.2.dev0__py3-none-any.whl

airbyte_cdk/sources/streams/concurrent/cursor.py

@@ -13,6 +13,7 @@ from typing import (
     Mapping,
     MutableMapping,
     Optional,
+    Protocol,
     Tuple,
     Union,
 )
@@ -20,8 +21,6 @@ from typing import (
 from airbyte_cdk.sources.connector_state_manager import ConnectorStateManager
 from airbyte_cdk.sources.message import MessageRepository
 from airbyte_cdk.sources.streams import NO_CURSOR_STATE_KEY
-from airbyte_cdk.sources.streams.concurrent.clamping import ClampingStrategy, NoClamping
-from airbyte_cdk.sources.streams.concurrent.cursor_types import CursorValueType, GapType
 from airbyte_cdk.sources.streams.concurrent.partitions.partition import Partition
 from airbyte_cdk.sources.streams.concurrent.partitions.stream_slicer import StreamSlicer
 from airbyte_cdk.sources.streams.concurrent.state_converters.abstract_stream_state_converter import (
@@ -36,6 +35,36 @@ def _extract_value(mapping: Mapping[str, Any], path: List[str]) -> Any:
     return functools.reduce(lambda a, b: a[b], path, mapping)
 
 
+class GapType(Protocol):
+    """
+    This is the representation of gaps between two cursor values. Examples:
+    * if cursor values are datetimes, GapType is timedelta
+    * if cursor values are integer, GapType will also be integer
+    """
+
+    pass
+
+
+class CursorValueType(Protocol):
+    """Protocol for annotating comparable types."""
+
+    @abstractmethod
+    def __lt__(self: "CursorValueType", other: "CursorValueType") -> bool:
+        pass
+
+    @abstractmethod
+    def __ge__(self: "CursorValueType", other: "CursorValueType") -> bool:
+        pass
+
+    @abstractmethod
+    def __add__(self: "CursorValueType", other: GapType) -> "CursorValueType":
+        pass
+
+    @abstractmethod
+    def __sub__(self: "CursorValueType", other: GapType) -> "CursorValueType":
+        pass
+
+
 class CursorField:
     def __init__(self, cursor_field_key: str) -> None:
         self.cursor_field_key = cursor_field_key
@@ -143,7 +172,6 @@ class ConcurrentCursor(Cursor):
         lookback_window: Optional[GapType] = None,
         slice_range: Optional[GapType] = None,
         cursor_granularity: Optional[GapType] = None,
-        clamping_strategy: ClampingStrategy = NoClamping(),
     ) -> None:
         self._stream_name = stream_name
         self._stream_namespace = stream_namespace
@@ -165,13 +193,10 @@ class ConcurrentCursor(Cursor):
         self._cursor_granularity = cursor_granularity
         # Flag to track if the logger has been triggered (per stream)
         self._should_be_synced_logger_triggered = False
-        self._clamping_strategy = clamping_strategy
 
     @property
     def state(self) -> MutableMapping[str, Any]:
-        return self._connector_state_converter.convert_to_state_message(
-            self.cursor_field, self._concurrent_state
-        )
+        return self._concurrent_state
 
     @property
     def cursor_field(self) -> CursorField:
@@ -216,10 +241,10 @@ class ConcurrentCursor(Cursor):
         return self._connector_state_converter.parse_value(self._cursor_field.extract_value(record))
 
     def close_partition(self, partition: Partition) -> None:
-        slice_count_before = len(self._concurrent_state.get("slices", []))
+        slice_count_before = len(self.state.get("slices", []))
         self._add_slice_to_state(partition)
         if slice_count_before < len(
-            self._concurrent_state["slices"]
+            self.state["slices"]
         ):  # only emit if at least one slice has been processed
             self._merge_partitions()
             self._emit_state_message()
@@ -231,11 +256,11 @@ class ConcurrentCursor(Cursor):
         )
 
         if self._slice_boundary_fields:
-            if "slices" not in self._concurrent_state:
+            if "slices" not in self.state:
                 raise RuntimeError(
                     f"The state for stream {self._stream_name} should have at least one slice to delineate the sync start time, but no slices are present. This is unexpected. Please contact Support."
                 )
-            self._concurrent_state["slices"].append(
+            self.state["slices"].append(
                 {
                     self._connector_state_converter.START_KEY: self._extract_from_slice(
                         partition, self._slice_boundary_fields[self._START_BOUNDARY]
@@ -263,7 +288,7 @@ class ConcurrentCursor(Cursor):
                     "expected. Please contact the Airbyte team."
                 )
 
-            self._concurrent_state["slices"].append(
+            self.state["slices"].append(
                 {
                     self._connector_state_converter.START_KEY: self.start,
                     self._connector_state_converter.END_KEY: most_recent_cursor_value,
@@ -275,7 +300,9 @@ class ConcurrentCursor(Cursor):
         self._connector_state_manager.update_state_for_stream(
             self._stream_name,
             self._stream_namespace,
-            self.state,
+            self._connector_state_converter.convert_to_state_message(
+                self._cursor_field, self.state
+            ),
         )
         state_message = self._connector_state_manager.create_state_message(
             self._stream_name, self._stream_namespace
@@ -283,9 +310,7 @@ class ConcurrentCursor(Cursor):
         self._message_repository.emit_message(state_message)
 
     def _merge_partitions(self) -> None:
-        self._concurrent_state["slices"] = self._connector_state_converter.merge_intervals(
-            self._concurrent_state["slices"]
-        )
+        self.state["slices"] = self._connector_state_converter.merge_intervals(self.state["slices"])
 
     def _extract_from_slice(self, partition: Partition, key: str) -> CursorValueType:
         try:
@@ -322,42 +347,36 @@ class ConcurrentCursor(Cursor):
         if self._start is not None and self._is_start_before_first_slice():
             yield from self._split_per_slice_range(
                 self._start,
-                self._concurrent_state["slices"][0][self._connector_state_converter.START_KEY],
+                self.state["slices"][0][self._connector_state_converter.START_KEY],
                 False,
             )
 
-        if len(self._concurrent_state["slices"]) == 1:
+        if len(self.state["slices"]) == 1:
             yield from self._split_per_slice_range(
                 self._calculate_lower_boundary_of_last_slice(
-                    self._concurrent_state["slices"][0][self._connector_state_converter.END_KEY]
+                    self.state["slices"][0][self._connector_state_converter.END_KEY]
                 ),
                 self._end_provider(),
                 True,
             )
-        elif len(self._concurrent_state["slices"]) > 1:
-            for i in range(len(self._concurrent_state["slices"]) - 1):
+        elif len(self.state["slices"]) > 1:
+            for i in range(len(self.state["slices"]) - 1):
                 if self._cursor_granularity:
                     yield from self._split_per_slice_range(
-                        self._concurrent_state["slices"][i][self._connector_state_converter.END_KEY]
+                        self.state["slices"][i][self._connector_state_converter.END_KEY]
                         + self._cursor_granularity,
-                        self._concurrent_state["slices"][i + 1][
-                            self._connector_state_converter.START_KEY
-                        ],
+                        self.state["slices"][i + 1][self._connector_state_converter.START_KEY],
                         False,
                     )
                 else:
                     yield from self._split_per_slice_range(
-                        self._concurrent_state["slices"][i][
-                            self._connector_state_converter.END_KEY
-                        ],
-                        self._concurrent_state["slices"][i + 1][
-                            self._connector_state_converter.START_KEY
-                        ],
+                        self.state["slices"][i][self._connector_state_converter.END_KEY],
+                        self.state["slices"][i + 1][self._connector_state_converter.START_KEY],
                         False,
                     )
             yield from self._split_per_slice_range(
                 self._calculate_lower_boundary_of_last_slice(
-                    self._concurrent_state["slices"][-1][self._connector_state_converter.END_KEY]
+                    self.state["slices"][-1][self._connector_state_converter.END_KEY]
                 ),
                 self._end_provider(),
                 True,
@@ -368,8 +387,7 @@ class ConcurrentCursor(Cursor):
     def _is_start_before_first_slice(self) -> bool:
         return (
             self._start is not None
-            and self._start
-            < self._concurrent_state["slices"][0][self._connector_state_converter.START_KEY]
+            and self._start < self.state["slices"][0][self._connector_state_converter.START_KEY]
         )
 
     def _calculate_lower_boundary_of_last_slice(
@@ -390,12 +408,10 @@ class ConcurrentCursor(Cursor):
 
         lower = max(lower, self._start) if self._start else lower
         if not self._slice_range or self._evaluate_upper_safely(lower, self._slice_range) >= upper:
-            clamped_lower = self._clamping_strategy.clamp(lower)
-            clamped_upper = self._clamping_strategy.clamp(upper)
             start_value, end_value = (
-                (clamped_lower, clamped_upper - self._cursor_granularity)
+                (lower, upper - self._cursor_granularity)
                 if self._cursor_granularity and not upper_is_end
-                else (clamped_lower, clamped_upper)
+                else (lower, upper)
             )
             yield StreamSlice(
                 partition={},
@@ -417,21 +433,11 @@ class ConcurrentCursor(Cursor):
                 )
                 has_reached_upper_boundary = current_upper_boundary >= upper
 
-                clamped_upper = (
-                    self._clamping_strategy.clamp(current_upper_boundary)
-                    if current_upper_boundary != upper
-                    else current_upper_boundary
-                )
-                clamped_lower = self._clamping_strategy.clamp(current_lower_boundary)
-                if clamped_lower >= clamped_upper:
-                    # clamping collapsed both values which means that it is time to stop processing
-                    # FIXME should this be replace by proper end_provider
-                    break
                 start_value, end_value = (
-                    (clamped_lower, clamped_upper - self._cursor_granularity)
+                    (current_lower_boundary, current_upper_boundary - self._cursor_granularity)
                     if self._cursor_granularity
                     and (not upper_is_end or not has_reached_upper_boundary)
-                    else (clamped_lower, clamped_upper)
+                    else (current_lower_boundary, current_upper_boundary)
                 )
                 yield StreamSlice(
                     partition={},
@@ -444,7 +450,7 @@ class ConcurrentCursor(Cursor):
                         ]: self._connector_state_converter.output_format(end_value),
                     },
                 )
-                current_lower_boundary = clamped_upper
+                current_lower_boundary = current_upper_boundary
                 if current_upper_boundary >= upper:
                     stop_processing = True
 

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

@@ -6,6 +6,9 @@ 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
@@ -14,7 +17,6 @@ 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):
@@ -34,7 +36,7 @@ class DateTimeStreamStateConverter(AbstractStreamStateConverter):
 
     @classmethod
     def get_end_provider(cls) -> Callable[[], datetime]:
-        return ab_datetime_now
+        return lambda: datetime.now(timezone.utc)
 
     @abstractmethod
     def increment(self, timestamp: datetime) -> datetime: ...
@@ -134,10 +136,10 @@ class EpochValueConcurrentStreamStateConverter(DateTimeStreamStateConverter):
         return int(timestamp.timestamp())
 
     def parse_timestamp(self, timestamp: int) -> datetime:
-        dt_object = AirbyteDateTime.fromtimestamp(timestamp, timezone.utc)
-        if not isinstance(dt_object, AirbyteDateTime):
+        dt_object = pendulum.from_timestamp(timestamp)
+        if not isinstance(dt_object, DateTime):
             raise ValueError(
-                f"AirbyteDateTime object was expected but got {type(dt_object)} from AirbyteDateTime.fromtimestamp({timestamp})"
+                f"DateTime object was expected but got {type(dt_object)} from pendulum.parse({timestamp})"
             )
         return dt_object
 
@@ -167,25 +169,14 @@ class IsoMillisConcurrentStreamStateConverter(DateTimeStreamStateConverter):
     def increment(self, timestamp: datetime) -> datetime:
         return timestamp + self._cursor_granularity
 
-    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 output_format(self, timestamp: datetime) -> Any:
+        return timestamp.strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"
 
     def parse_timestamp(self, timestamp: str) -> datetime:
-        dt_object = ab_datetime_parse(timestamp)
-        if not isinstance(dt_object, AirbyteDateTime):
+        dt_object = pendulum.parse(timestamp)
+        if not isinstance(dt_object, DateTime):
             raise ValueError(
-                f"AirbyteDateTime object was expected but got {type(dt_object)} from parse({timestamp})"
+                f"DateTime object was expected but got {type(dt_object)} from pendulum.parse({timestamp})"
             )
         return dt_object
 
@@ -193,7 +184,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 using AirbyteDateTime parsing utilities.
+    incoming state in any valid datetime format via Pendulum.
     """
 
     def __init__(

airbyte_cdk/sources/streams/core.py

@@ -223,17 +223,17 @@ class Stream(ABC):
                     record_counter += 1
 
                     checkpoint_interval = self.state_checkpoint_interval
+                    checkpoint = checkpoint_reader.get_checkpoint()
                     if (
                         should_checkpoint
                         and checkpoint_interval
                         and record_counter % checkpoint_interval == 0
+                        and checkpoint is not None
                     ):
-                        checkpoint = checkpoint_reader.get_checkpoint()
-                        if checkpoint:
-                            airbyte_state_message = self._checkpoint_state(
-                                checkpoint, state_manager=state_manager
-                            )
-                            yield airbyte_state_message
+                        airbyte_state_message = self._checkpoint_state(
+                            checkpoint, state_manager=state_manager
+                        )
+                        yield airbyte_state_message
 
                     if internal_config.is_limit_reached(record_counter):
                         break

airbyte_cdk/sources/streams/http/http.py

@@ -423,6 +423,8 @@ class HttpStream(Stream, CheckpointMixin, ABC):
         stream_slice: Optional[Mapping[str, Any]] = None,
         stream_state: Optional[Mapping[str, Any]] = None,
     ) -> Iterable[StreamData]:
+        partition, _, _ = self._extract_slice_fields(stream_slice=stream_slice)
+
         stream_state = stream_state or {}
         pagination_complete = False
         next_page_token = None
@@ -436,7 +438,6 @@ class HttpStream(Stream, CheckpointMixin, ABC):
 
         cursor = self.get_cursor()
         if cursor and isinstance(cursor, SubstreamResumableFullRefreshCursor):
-            partition, _, _ = self._extract_slice_fields(stream_slice=stream_slice)
             # Substreams checkpoint state by marking an entire parent partition as completed so that on the subsequent attempt
             # after a failure, completed parents are skipped and the sync can make progress
             cursor.close_slice(StreamSlice(cursor_slice={}, partition=partition))

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,7 +17,6 @@ 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
 
@@ -73,7 +72,7 @@ class AbstractOauth2Authenticator(AuthBase):
 
     def token_has_expired(self) -> bool:
         """Returns True if the token is expired"""
-        return ab_datetime_now() > self.get_token_expiry_date()
+        return pendulum.now() > self.get_token_expiry_date()  # type: ignore # this is always a bool despite what mypy thinks
 
     def build_refresh_request_body(self) -> Mapping[str, Any]:
         """
@@ -180,7 +179,7 @@ class AbstractOauth2Authenticator(AuthBase):
             self.get_expires_in_name()
         ]
 
-    def _parse_token_expiration_date(self, value: Union[str, int]) -> AirbyteDateTime:
+    def _parse_token_expiration_date(self, value: Union[str, int]) -> pendulum.DateTime:
         """
         Return the expiration datetime of the refresh token
 
@@ -192,19 +191,9 @@ class AbstractOauth2Authenticator(AuthBase):
                 raise ValueError(
                     f"Invalid token expiry date format {self.token_expiry_date_format}; a string representing the format is required."
                 )
-            try:
-                return ab_datetime_parse(str(value))
-            except ValueError as e:
-                raise ValueError(f"Invalid token expiry date format: {e}")
+            return pendulum.from_format(str(value), self.token_expiry_date_format)
         else:
-            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."
-                )
+            return pendulum.now().add(seconds=int(float(value)))
 
     @property
     def token_expiry_is_time_of_expiration(self) -> bool:
@@ -255,7 +244,7 @@ class AbstractOauth2Authenticator(AuthBase):
         """List of requested scopes"""
 
     @abstractmethod
-    def get_token_expiry_date(self) -> AirbyteDateTime:
+    def get_token_expiry_date(self) -> pendulum.DateTime:
         """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,11 +15,6 @@ 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):
@@ -39,7 +34,7 @@ class Oauth2Authenticator(AbstractOauth2Authenticator):
         client_secret_name: str = "client_secret",
         refresh_token_name: str = "refresh_token",
         scopes: List[str] | None = None,
-        token_expiry_date: AirbyteDateTime | None = None,
+        token_expiry_date: pendulum.DateTime | None = None,
         token_expiry_date_format: str | None = None,
         access_token_name: str = "access_token",
         expires_in_name: str = "expires_in",
@@ -67,7 +62,7 @@ class Oauth2Authenticator(AbstractOauth2Authenticator):
         self._grant_type_name = grant_type_name
         self._grant_type = grant_type
 
-        self._token_expiry_date = token_expiry_date or (ab_datetime_now() - timedelta(days=1))
+        self._token_expiry_date = token_expiry_date or pendulum.now().subtract(days=1)  # type: ignore [no-untyped-call]
         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
@@ -100,16 +95,16 @@ class Oauth2Authenticator(AbstractOauth2Authenticator):
         return self._access_token_name
 
     def get_scopes(self) -> list[str]:
-        return self._scopes  # type: ignore[return-value]
+        return self._scopes  # type: ignore [return-value]
 
     def get_expires_in_name(self) -> str:
         return self._expires_in_name
 
     def get_refresh_request_body(self) -> Mapping[str, Any]:
-        return self._refresh_request_body  # type: ignore[return-value]
+        return self._refresh_request_body  # type: ignore [return-value]
 
     def get_refresh_request_headers(self) -> Mapping[str, Any]:
-        return self._refresh_request_headers  # type: ignore[return-value]
+        return self._refresh_request_headers  # type: ignore [return-value]
 
     def get_grant_type_name(self) -> str:
         return self._grant_type_name
@@ -117,7 +112,7 @@ class Oauth2Authenticator(AbstractOauth2Authenticator):
     def get_grant_type(self) -> str:
         return self._grant_type
 
-    def get_token_expiry_date(self) -> AirbyteDateTime:
+    def get_token_expiry_date(self) -> pendulum.DateTime:
         return self._token_expiry_date
 
     def set_token_expiry_date(self, value: Union[str, int]) -> None:
@@ -133,11 +128,11 @@ class Oauth2Authenticator(AbstractOauth2Authenticator):
 
     @property
     def access_token(self) -> str:
-        return self._access_token  # type: ignore[return-value]
+        return self._access_token  # type: ignore [return-value]
 
     @access_token.setter
     def access_token(self, value: str) -> None:
-        self._access_token = value  # type: ignore[assignment]  # Incorrect type for assignment
+        self._access_token = value  # type: ignore [assignment]  # Incorrect type for assignment
 
 
 class SingleUseRefreshTokenOauth2Authenticator(Oauth2Authenticator):
@@ -197,15 +192,15 @@ class SingleUseRefreshTokenOauth2Authenticator(Oauth2Authenticator):
             message_repository (MessageRepository): the message repository used to emit logs on HTTP requests and control message on config update
         """
         self._client_id = (
-            client_id  # type: ignore[assignment]  # Incorrect type for assignment
+            client_id  # type: ignore [assignment]  # Incorrect type for assignment
             if client_id is not None
-            else dpath.get(connector_config, ("credentials", "client_id"))  # type: ignore[arg-type]
+            else dpath.get(connector_config, ("credentials", "client_id"))  # type: ignore [arg-type]
         )
         self._client_secret = (
-            client_secret  # type: ignore[assignment]  # Incorrect type for assignment
+            client_secret  # type: ignore [assignment]  # Incorrect type for assignment
             if client_secret is not None
             else dpath.get(
-                connector_config,  # type: ignore[arg-type]
+                connector_config,  # type: ignore [arg-type]
                 ("credentials", "client_secret"),
             )
         )
@@ -253,8 +248,8 @@ class SingleUseRefreshTokenOauth2Authenticator(Oauth2Authenticator):
 
     @property
     def access_token(self) -> str:
-        return dpath.get(  # type: ignore[return-value]
-            self._connector_config,  # type: ignore[arg-type]
+        return dpath.get(  # type: ignore [return-value]
+            self._connector_config,  # type: ignore [arg-type]
             self._access_token_config_path,
             default="",
         )
@@ -262,63 +257,56 @@ class SingleUseRefreshTokenOauth2Authenticator(Oauth2Authenticator):
     @access_token.setter
     def access_token(self, new_access_token: str) -> None:
         dpath.new(
-            self._connector_config,  # type: ignore[arg-type]
+            self._connector_config,  # type: ignore [arg-type]
             self._access_token_config_path,
             new_access_token,
         )
 
     def get_refresh_token(self) -> str:
-        return dpath.get(  # type: ignore[return-value]
-            self._connector_config,  # type: ignore[arg-type]
+        return dpath.get(  # type: ignore [return-value]
+            self._connector_config,  # type: ignore [arg-type]
             self._refresh_token_config_path,
             default="",
         )
 
     def set_refresh_token(self, new_refresh_token: str) -> None:
         dpath.new(
-            self._connector_config,  # type: ignore[arg-type]
+            self._connector_config,  # type: ignore [arg-type]
             self._refresh_token_config_path,
             new_refresh_token,
         )
 
-    def get_token_expiry_date(self) -> AirbyteDateTime:
+    def get_token_expiry_date(self) -> pendulum.DateTime:
         expiry_date = dpath.get(
-            self._connector_config,  # type: ignore[arg-type]
+            self._connector_config,  # type: ignore [arg-type]
             self._token_expiry_date_config_path,
             default="",
         )
-        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")
+        return pendulum.now().subtract(days=1) if expiry_date == "" else pendulum.parse(expiry_date)  # type: ignore [arg-type, return-value, no-untyped-call]
 
     def set_token_expiry_date(  # type: ignore[override]
         self,
-        new_token_expiry_date: AirbyteDateTime,
+        new_token_expiry_date: pendulum.DateTime,
     ) -> None:
         dpath.new(
-            self._connector_config,  # type: ignore[arg-type]
+            self._connector_config,  # type: ignore [arg-type]
             self._token_expiry_date_config_path,
             str(new_token_expiry_date),
         )
 
     def token_has_expired(self) -> bool:
         """Returns True if the token is expired"""
-        return ab_datetime_now() > self.get_token_expiry_date()
+        return pendulum.now("UTC") > self.get_token_expiry_date()
 
     @staticmethod
     def get_new_token_expiry_date(
         access_token_expires_in: str,
         token_expiry_date_format: str | None = None,
-    ) -> AirbyteDateTime:
+    ) -> pendulum.DateTime:
         if token_expiry_date_format:
-            return ab_datetime_parse(access_token_expires_in)
+            return pendulum.from_format(access_token_expires_in, token_expiry_date_format)
         else:
-            return ab_datetime_now() + timedelta(seconds=int(access_token_expires_in))
+            return pendulum.now("UTC").add(seconds=int(access_token_expires_in))
 
     def get_access_token(self) -> str:
         """Retrieve new access and refresh token if the access token has expired.
@@ -330,7 +318,7 @@ class SingleUseRefreshTokenOauth2Authenticator(Oauth2Authenticator):
             new_access_token, access_token_expires_in, new_refresh_token = (
                 self.refresh_access_token()
             )
-            new_token_expiry_date: AirbyteDateTime = self.get_new_token_expiry_date(
+            new_token_expiry_date: pendulum.DateTime = self.get_new_token_expiry_date(
                 access_token_expires_in, self._token_expiry_date_format
             )
             self.access_token = new_access_token
@@ -341,10 +329,10 @@ class SingleUseRefreshTokenOauth2Authenticator(Oauth2Authenticator):
             #  message directly in the console, this is needed
             if not isinstance(self._message_repository, NoopMessageRepository):
                 self._message_repository.emit_message(
-                    create_connector_config_control_message(self._connector_config)  # type: ignore[arg-type]
+                    create_connector_config_control_message(self._connector_config)  # type: ignore [arg-type]
                 )
             else:
-                emit_configuration_as_airbyte_control_message(self._connector_config)  # type: ignore[arg-type]
+                emit_configuration_as_airbyte_control_message(self._connector_config)  # type: ignore [arg-type]
         return self.access_token
 
     def refresh_access_token(  # type: ignore[override]  # Signature doesn't match base class

airbyte_cdk/sources/types.py

@@ -6,7 +6,7 @@ from __future__ import annotations
 
 from typing import Any, ItemsView, Iterator, KeysView, List, Mapping, Optional, ValuesView
 
-from airbyte_cdk.utils.slice_hasher import SliceHasher
+import orjson
 
 # A FieldPointer designates a path to a field inside a mapping. For example, retrieving ["k1", "k1.2"] in the object {"k1" :{"k1.2":
 # "hello"}] returns "hello"
@@ -151,9 +151,7 @@ class StreamSlice(Mapping[str, Any]):
         return self._stream_slice
 
     def __hash__(self) -> int:
-        return SliceHasher.hash(
-            stream_slice=self._stream_slice
-        )  # no need to provide stream_name here as this is used for slicing the cursor
+        return hash(orjson.dumps(self._stream_slice, option=orjson.OPT_SORT_KEYS))
 
     def __bool__(self) -> bool:
         return bool(self._stream_slice) or bool(self._extra_fields)