airbyte-cdk 6.31.1__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