airbyte-cdk 7.3.2__py3-none-any.whl → 7.3.3__py3-none-any.whl

airbyte_cdk/sources/declarative/declarative_component_schema.yaml

@@ -2279,12 +2279,14 @@ definitions:
           - FAIL
           - RETRY
           - IGNORE
+          - RESET_PAGINATION
           - RATE_LIMITED
         examples:
           - SUCCESS
           - FAIL
           - RETRY
           - IGNORE
+          - RESET_PAGINATION
           - RATE_LIMITED
       failure_type:
         title: Failure Type
@@ -3707,6 +3709,9 @@ definitions:
         anyOf:
           - "$ref": "#/definitions/DefaultPaginator"
           - "$ref": "#/definitions/NoPagination"
+      pagination_reset:
+        description: Describes what triggers pagination reset and how to handle it.
+        "$ref": "#/definitions/PaginationReset"
       ignore_stream_slicer_parameters_on_paginated_requests:
         description: If true, the partition router and incremental request options will be ignored when paginating requests. Request options set directly on the requester will not be ignored.
         type: boolean
@@ -3730,6 +3735,36 @@ definitions:
       $parameters:
         type: object
         additionalProperties: true
+  PaginationReset:
+    title: Pagination Reset
+    description: Describes what triggers pagination reset and how to handle it. If SPLIT_USING_CURSOR, the connector developer is accountable for ensuring that the records are returned in ascending order.
+    type: object
+    required:
+      - type
+      - action
+    properties:
+      type:
+        type: string
+        enum: [ PaginationReset ]
+      action:
+        type: string
+        enum:
+          - SPLIT_USING_CURSOR
+          - RESET
+      limits:
+        "$ref": "#/definitions/PaginationResetLimits"
+  PaginationResetLimits:
+    title: Pagination Reset Limits
+    description: Describes the limits that trigger pagination reset
+    type: object
+    required:
+      - type
+    properties:
+      type:
+        type: string
+        enum: [ PaginationResetLimits ]
+      number_of_records:
+        type: integer
   GzipDecoder:
     title: gzip
     description: Select 'gzip' for response data that is compressed with gzip. Requires specifying an inner data type/decoder to parse the decompressed data.

airbyte_cdk/sources/declarative/incremental/concurrent_partition_cursor.py

@@ -151,7 +151,7 @@ class ConcurrentPerPartitionCursor(Cursor):
         self._connector_state_converter = connector_state_converter
         self._cursor_field = cursor_field
 
-        self._cursor_factory = cursor_factory
+        self._cursor_factory = cursor_factory  # self._cursor_factory is flagged as private but is used in model_to_component_factory to ease pagination reset instantiation
         self._partition_router = partition_router
 
         # The dict is ordered to ensure that once the maximum number of partitions is reached,

airbyte_cdk/sources/declarative/models/declarative_component_schema.py

@@ -539,6 +539,7 @@ class Action(Enum):
     FAIL = "FAIL"
     RETRY = "RETRY"
     IGNORE = "IGNORE"
+    RESET_PAGINATION = "RESET_PAGINATION"
     RATE_LIMITED = "RATE_LIMITED"
 
 
@@ -553,7 +554,14 @@ class HttpResponseFilter(BaseModel):
     action: Optional[Action] = Field(
         None,
         description="Action to execute if a response matches the filter.",
-        examples=["SUCCESS", "FAIL", "RETRY", "IGNORE", "RATE_LIMITED"],
+        examples=[
+            "SUCCESS",
+            "FAIL",
+            "RETRY",
+            "IGNORE",
+            "RESET_PAGINATION",
+            "RATE_LIMITED",
+        ],
         title="Action",
     )
     failure_type: Optional[FailureType] = Field(
@@ -1173,6 +1181,16 @@ class LegacySessionTokenAuthenticator(BaseModel):
     parameters: Optional[Dict[str, Any]] = Field(None, alias="$parameters")
 
 
+class Action1(Enum):
+    SPLIT_USING_CURSOR = "SPLIT_USING_CURSOR"
+    RESET = "RESET"
+
+
+class PaginationResetLimits(BaseModel):
+    type: Literal["PaginationResetLimits"]
+    number_of_records: Optional[int] = None
+
+
 class CsvDecoder(BaseModel):
     type: Literal["CsvDecoder"]
     encoding: Optional[str] = "utf-8"
@@ -2054,6 +2072,12 @@ class RecordSelector(BaseModel):
     parameters: Optional[Dict[str, Any]] = Field(None, alias="$parameters")
 
 
+class PaginationReset(BaseModel):
+    type: Literal["PaginationReset"]
+    action: Action1
+    limits: Optional[PaginationResetLimits] = None
+
+
 class GzipDecoder(BaseModel):
     type: Literal["GzipDecoder"]
     decoder: Union[CsvDecoder, GzipDecoder, JsonDecoder, JsonlDecoder]
@@ -2822,6 +2846,10 @@ class SimpleRetriever(BaseModel):
         None,
         description="Paginator component that describes how to navigate through the API's pages.",
     )
+    pagination_reset: Optional[PaginationReset] = Field(
+        None,
+        description="Describes what triggers pagination reset and how to handle it.",
+    )
     ignore_stream_slicer_parameters_on_paginated_requests: Optional[bool] = Field(
         False,
         description="If true, the partition router and incremental request options will be ignored when paginating requests. Request options set directly on the requester will not be ignored.",

airbyte_cdk/sources/declarative/parsers/model_to_component_factory.py

@@ -116,11 +116,15 @@ from airbyte_cdk.sources.declarative.migrations.legacy_to_per_partition_state_mi
 )
 from airbyte_cdk.sources.declarative.models import (
     CustomStateMigration,
+    PaginationResetLimits,
 )
 from airbyte_cdk.sources.declarative.models.base_model_with_deprecations import (
     DEPRECATION_LOGS_TAG,
     BaseModelWithDeprecations,
 )
+from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
+    Action1 as PaginationResetActionModel,
+)
 from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
     AddedFieldDefinition as AddedFieldDefinitionModel,
 )
@@ -358,6 +362,9 @@ from airbyte_cdk.sources.declarative.models.declarative_component_schema import
 from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
     PageIncrement as PageIncrementModel,
 )
+from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
+    PaginationReset as PaginationResetModel,
+)
 from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
     ParametrizedComponentsResolver as ParametrizedComponentsResolverModel,
 )
@@ -529,6 +536,7 @@ from airbyte_cdk.sources.declarative.retrievers.file_uploader import (
     LocalFileSystemFileWriter,
     NoopFileWriter,
 )
+from airbyte_cdk.sources.declarative.retrievers.pagination_tracker import PaginationTracker
 from airbyte_cdk.sources.declarative.schema import (
     ComplexFieldType,
     DefaultSchemaLoader,
@@ -644,6 +652,8 @@ _NO_STREAM_SLICING = SinglePartitionRouter(parameters={})
 # this would be a circular import
 MAX_SLICES = 5
 
+LOGGER = logging.getLogger(f"airbyte.model_to_component_factory")
+
 
 class ModelToComponentFactory:
     EPOCH_DATETIME_FORMAT = "%s"
@@ -2043,6 +2053,7 @@ class ModelToComponentFactory:
             if isinstance(concurrent_cursor, FinalStateCursor)
             else concurrent_cursor
         )
+
         retriever = self._create_component_from_model(
             model=model.retriever,
             config=config,
@@ -2051,12 +2062,9 @@ class ModelToComponentFactory:
             request_options_provider=request_options_provider,
             stream_slicer=stream_slicer,
             partition_router=partition_router,
-            stop_condition_cursor=concurrent_cursor
-            if self._is_stop_condition_on_cursor(model)
-            else None,
-            client_side_incremental_sync={"cursor": concurrent_cursor}
-            if self._is_client_side_filtering_enabled(model)
-            else None,
+            has_stop_condition_cursor=self._is_stop_condition_on_cursor(model),
+            is_client_side_incremental_sync=self._is_client_side_filtering_enabled(model),
+            cursor=concurrent_cursor,
             transformations=transformations,
             file_uploader=file_uploader,
             incremental_sync=model.incremental_sync,
@@ -3049,7 +3057,7 @@ class ModelToComponentFactory:
         name: str,
         transformations: List[RecordTransformation] | None = None,
         decoder: Decoder | None = None,
-        client_side_incremental_sync: Dict[str, Any] | None = None,
+        client_side_incremental_sync_cursor: Optional[Cursor] = None,
         file_uploader: Optional[DefaultFileUploader] = None,
         **kwargs: Any,
     ) -> RecordSelector:
@@ -3065,14 +3073,14 @@ class ModelToComponentFactory:
         transform_before_filtering = (
             False if model.transform_before_filtering is None else model.transform_before_filtering
         )
-        if client_side_incremental_sync:
+        if client_side_incremental_sync_cursor:
             record_filter = ClientSideIncrementalRecordFilterDecorator(
                 config=config,
                 parameters=model.parameters,
                 condition=model.record_filter.condition
                 if (model.record_filter and hasattr(model.record_filter, "condition"))
                 else None,
-                **client_side_incremental_sync,
+                cursor=client_side_incremental_sync_cursor,
             )
             transform_before_filtering = (
                 True
@@ -3150,8 +3158,9 @@ class ModelToComponentFactory:
         name: str,
         primary_key: Optional[Union[str, List[str], List[List[str]]]],
         request_options_provider: Optional[RequestOptionsProvider] = None,
-        stop_condition_cursor: Optional[Cursor] = None,
-        client_side_incremental_sync: Optional[Dict[str, Any]] = None,
+        cursor: Optional[Cursor] = None,
+        has_stop_condition_cursor: bool = False,
+        is_client_side_incremental_sync: bool = False,
         transformations: List[RecordTransformation],
         file_uploader: Optional[DefaultFileUploader] = None,
         incremental_sync: Optional[
@@ -3181,6 +3190,9 @@ class ModelToComponentFactory:
 
             return _url or _url_base
 
+        if cursor is None:
+            cursor = FinalStateCursor(name, None, self._message_repository)
+
         decoder = (
             self._create_component_from_model(model=model.decoder, config=config)
             if model.decoder
@@ -3192,7 +3204,7 @@ class ModelToComponentFactory:
             config=config,
             decoder=decoder,
             transformations=transformations,
-            client_side_incremental_sync=client_side_incremental_sync,
+            client_side_incremental_sync_cursor=cursor if is_client_side_incremental_sync else None,
             file_uploader=file_uploader,
         )
 
@@ -3280,7 +3292,7 @@ class ModelToComponentFactory:
                 url_base=_get_url(requester),
                 extractor_model=model.record_selector.extractor,
                 decoder=decoder,
-                cursor_used_for_stop_condition=stop_condition_cursor or None,
+                cursor_used_for_stop_condition=cursor if has_stop_condition_cursor else None,
             )
             if model.paginator
             else NoPagination(parameters={})
@@ -3329,6 +3341,13 @@ class ModelToComponentFactory:
                 parameters=model.parameters or {},
             )
 
+        if (
+            model.record_selector.record_filter
+            and model.pagination_reset
+            and model.pagination_reset.limits
+        ):
+            raise ValueError("PaginationResetLimits are not supported while having record filter.")
+
         return SimpleRetriever(
             name=name,
             paginator=paginator,
@@ -3342,9 +3361,40 @@ class ModelToComponentFactory:
             ignore_stream_slicer_parameters_on_paginated_requests=ignore_stream_slicer_parameters_on_paginated_requests,
             additional_query_properties=query_properties,
             log_formatter=self._get_log_formatter(log_formatter, name),
+            pagination_tracker_factory=self._create_pagination_tracker_factory(
+                model.pagination_reset, cursor
+            ),
             parameters=model.parameters or {},
         )
 
+    def _create_pagination_tracker_factory(
+        self, model: Optional[PaginationResetModel], cursor: Cursor
+    ) -> Callable[[], PaginationTracker]:
+        if model is None:
+            return lambda: PaginationTracker()
+
+        # Until we figure out a way to use any cursor for PaginationTracker, we will have to have this cursor selector logic
+        cursor_factory: Callable[[], Optional[ConcurrentCursor]] = lambda: None
+        if model.action == PaginationResetActionModel.RESET:
+            # in that case, we will let cursor_factory to return None even if the stream has a cursor
+            pass
+        elif model.action == PaginationResetActionModel.SPLIT_USING_CURSOR:
+            if isinstance(cursor, ConcurrentCursor):
+                cursor_factory = lambda: cursor.copy_without_state()  # type: ignore  # the if condition validates that it is a ConcurrentCursor
+            elif isinstance(cursor, ConcurrentPerPartitionCursor):
+                cursor_factory = lambda: cursor._cursor_factory.create(  # type: ignore  # if this becomes a problem, we would need to extract the cursor_factory instantiation logic and make it accessible here
+                    {}, datetime.timedelta(0)
+                )
+            elif not isinstance(cursor, FinalStateCursor):
+                LOGGER.warning(
+                    "Unknown cursor for PaginationTracker. Pagination resets might not work properly"
+                )
+        else:
+            raise ValueError(f"Unknown PaginationReset action: {model.action}")
+
+        limit = model.limits.number_of_records if model and model.limits else None
+        return lambda: PaginationTracker(cursor_factory(), limit)
+
     def _get_log_formatter(
         self, log_formatter: Callable[[Response], Any] | None, name: str
     ) -> Callable[[Response], Any] | None:

airbyte_cdk/sources/declarative/requesters/error_handlers/composite_error_handler.py

@@ -66,14 +66,14 @@ class CompositeErrorHandler(ErrorHandler):
             if not isinstance(matched_error_resolution, ErrorResolution):
                 continue
 
-            if matched_error_resolution.response_action == ResponseAction.SUCCESS:
+            if matched_error_resolution.response_action in [
+                ResponseAction.SUCCESS,
+                ResponseAction.RETRY,
+                ResponseAction.IGNORE,
+                ResponseAction.RESET_PAGINATION,
+            ]:
                 return matched_error_resolution
 
-            if (
-                matched_error_resolution.response_action == ResponseAction.RETRY
-                or matched_error_resolution.response_action == ResponseAction.IGNORE
-            ):
-                return matched_error_resolution
         if matched_error_resolution:
             return matched_error_resolution
 

airbyte_cdk/sources/declarative/retrievers/pagination_tracker.py

@@ -0,0 +1,64 @@
+from typing import Optional
+
+from airbyte_cdk.sources.declarative.models import FailureType
+from airbyte_cdk.sources.declarative.types import Record, StreamSlice
+from airbyte_cdk.sources.streams.concurrent.cursor import ConcurrentCursor
+from airbyte_cdk.utils.traced_exception import AirbyteTracedException
+
+
+class PaginationTracker:
+    _record_count: int
+    _number_of_attempt_with_same_slice: int
+
+    def __init__(
+        self, cursor: Optional[ConcurrentCursor] = None, max_number_of_records: Optional[int] = None
+    ) -> None:
+        """
+        Ideally, we would have passed the `Cursor` interface here instead of `ConcurrentCursor` but not all
+        implementations of `Cursor` can support this use case. For example, if the `ConcurrentPerPartitionCursor`
+        switch to global state, we stop keeping track of the state per partition and therefore can't get an accurate
+        view for a specific stream_slice. In order to solve that, we decided to scope this feature to use only
+        ConcurrentCursor which is the only "leaf" cursor that actually emits stream slices with `cursor_partition`.
+        """
+        self._cursor = cursor
+        self._limit = max_number_of_records
+        self._reset()
+
+        """
+        Given we have a cursor, we do not allow for the same slice to be processed twice because we assume we will
+        always process the same slice.
+
+        Given no cursor, we assume that the pagination reset is for retrying purposes and we allow to retry once.
+        """
+        self._allowed_number_of_attempt_with_same_slice = 1 if self._cursor else 2
+        self._number_of_attempt_with_same_slice = 0
+
+    def observe(self, record: Record) -> None:
+        self._record_count += 1
+        if self._cursor:
+            self._cursor.observe(record)
+
+    def has_reached_limit(self) -> bool:
+        return self._limit is not None and self._record_count >= self._limit
+
+    def _reset(self) -> None:
+        self._record_count = 0
+
+    def reduce_slice_range_if_possible(self, stream_slice: StreamSlice) -> StreamSlice:
+        new_slice = self._cursor.reduce_slice_range(stream_slice) if self._cursor else stream_slice
+
+        if new_slice == stream_slice:
+            self._number_of_attempt_with_same_slice += 1
+            if (
+                self._number_of_attempt_with_same_slice
+                >= self._allowed_number_of_attempt_with_same_slice
+            ):
+                raise AirbyteTracedException(
+                    internal_message=f"There were {self._number_of_attempt_with_same_slice} attempts with the same slice already while the max allowed is {self._allowed_number_of_attempt_with_same_slice}",
+                    failure_type=FailureType.system_error,
+                )
+        else:
+            self._number_of_attempt_with_same_slice = 0
+
+        self._reset()
+        return new_slice

airbyte_cdk/sources/declarative/retrievers/simple_retriever.py

@@ -3,10 +3,10 @@
 #
 
 import json
+import logging
 from collections import defaultdict
 from dataclasses import InitVar, dataclass, field
 from functools import partial
-from itertools import islice
 from typing import (
     Any,
     Callable,
@@ -39,14 +39,20 @@ from airbyte_cdk.sources.declarative.requesters.request_options import (
     RequestOptionsProvider,
 )
 from airbyte_cdk.sources.declarative.requesters.requester import Requester
+from airbyte_cdk.sources.declarative.retrievers.pagination_tracker import PaginationTracker
 from airbyte_cdk.sources.declarative.retrievers.retriever import Retriever
 from airbyte_cdk.sources.declarative.stream_slicers.stream_slicer import StreamSlicer
 from airbyte_cdk.sources.source import ExperimentalClassWarning
+from airbyte_cdk.sources.streams.concurrent.cursor import Cursor
 from airbyte_cdk.sources.streams.core import StreamData
+from airbyte_cdk.sources.streams.http.pagination_reset_exception import (
+    PaginationResetRequiredException,
+)
 from airbyte_cdk.sources.types import Config, Record, StreamSlice, StreamState
 from airbyte_cdk.utils.mapping_helpers import combine_mappings
 
 FULL_REFRESH_SYNC_COMPLETE_KEY = "__ab_full_refresh_sync_complete"
+LOGGER = logging.getLogger("airbyte")
 
 
 @dataclass
@@ -92,8 +98,14 @@ class SimpleRetriever(Retriever):
     ignore_stream_slicer_parameters_on_paginated_requests: bool = False
     additional_query_properties: Optional[QueryProperties] = None
     log_formatter: Optional[Callable[[requests.Response], Any]] = None
+    pagination_tracker_factory: Callable[[], PaginationTracker] = field(
+        default_factory=lambda: lambda: PaginationTracker()
+    )
 
     def __post_init__(self, parameters: Mapping[str, Any]) -> None:
+        # while changing `ModelToComponentFactory.create_simple_retriever` to accept a cursor, the sources implementing
+        # a CustomRetriever inheriting for SimpleRetriever needed to have the following validation added.
+        self.cursor = None if isinstance(self.cursor, Cursor) else self.cursor
         self._paginator = self.paginator or NoPagination(parameters=parameters)
         self._parameters = parameters
         self._name = (
@@ -362,90 +374,97 @@ class SimpleRetriever(Retriever):
         stream_state: Mapping[str, Any],
         stream_slice: StreamSlice,
     ) -> Iterable[Record]:
-        pagination_complete = False
-        initial_token = self._paginator.get_initial_token()
-        next_page_token: Optional[Mapping[str, Any]] = (
-            {"next_page_token": initial_token} if initial_token is not None else None
-        )
-        while not pagination_complete:
-            property_chunks: List[List[str]] = (
-                list(
-                    self.additional_query_properties.get_request_property_chunks(
-                        stream_slice=stream_slice
-                    )
-                )
-                if self.additional_query_properties
-                else [
-                    []
-                ]  # A single empty property chunk represents the case where property chunking is not configured
-            )
-
+        pagination_tracker = self.pagination_tracker_factory()
+        reset_pagination = False
+        next_page_token = self._get_initial_next_page_token()
+        while True:
             merged_records: MutableMapping[str, Any] = defaultdict(dict)
             last_page_size = 0
             last_record: Optional[Record] = None
-            response: Optional[requests.Response] = None
-            for properties in property_chunks:
-                if len(properties) > 0:
-                    stream_slice = StreamSlice(
-                        partition=stream_slice.partition or {},
-                        cursor_slice=stream_slice.cursor_slice or {},
-                        extra_fields={"query_properties": properties},
-                    )
-
-                response = self._fetch_next_page(stream_state, stream_slice, next_page_token)
-                for current_record in records_generator_fn(response):
-                    if (
-                        current_record
-                        and self.additional_query_properties
-                        and self.additional_query_properties.property_chunking
+
+            response = None
+            try:
+                if (
+                    self.additional_query_properties
+                    and self.additional_query_properties.property_chunking
+                ):
+                    for properties in self.additional_query_properties.get_request_property_chunks(
+                        stream_slice=stream_slice
                     ):
-                        merge_key = (
-                            self.additional_query_properties.property_chunking.get_merge_key(
-                                current_record
+                        stream_slice = StreamSlice(
+                            partition=stream_slice.partition or {},
+                            cursor_slice=stream_slice.cursor_slice or {},
+                            extra_fields={"query_properties": properties},
+                        )
+                        response = self._fetch_next_page(
+                            stream_state, stream_slice, next_page_token
+                        )
+
+                        for current_record in records_generator_fn(response):
+                            merge_key = (
+                                self.additional_query_properties.property_chunking.get_merge_key(
+                                    current_record
+                                )
                             )
+                            if merge_key:
+                                _deep_merge(merged_records[merge_key], current_record)
+                            else:
+                                # We should still emit records even if the record did not have a merge key
+                                pagination_tracker.observe(current_record)
+                                last_page_size += 1
+                                last_record = current_record
+                                yield current_record
+
+                    for merged_record in merged_records.values():
+                        record = Record(
+                            data=merged_record, stream_name=self.name, associated_slice=stream_slice
                         )
-                        if merge_key:
-                            _deep_merge(merged_records[merge_key], current_record)
-                        else:
-                            # We should still emit records even if the record did not have a merge key
-                            last_page_size += 1
-                            last_record = current_record
-                            yield current_record
-                    else:
+                        pagination_tracker.observe(record)
+                        last_page_size += 1
+                        last_record = record
+                        yield record
+                else:
+                    response = self._fetch_next_page(stream_state, stream_slice, next_page_token)
+                    for current_record in records_generator_fn(response):
+                        pagination_tracker.observe(current_record)
                         last_page_size += 1
                         last_record = current_record
                         yield current_record
-
-            if (
-                self.additional_query_properties
-                and self.additional_query_properties.property_chunking
-            ):
-                for merged_record in merged_records.values():
-                    record = Record(
-                        data=merged_record, stream_name=self.name, associated_slice=stream_slice
-                    )
-                    last_page_size += 1
-                    last_record = record
-                    yield record
-
-            if not response:
-                pagination_complete = True
+            except PaginationResetRequiredException:
+                reset_pagination = True
+            else:
+                if not response:
+                    break
+
+            if reset_pagination or pagination_tracker.has_reached_limit():
+                next_page_token = self._get_initial_next_page_token()
+                previous_slice = stream_slice
+                stream_slice = pagination_tracker.reduce_slice_range_if_possible(stream_slice)
+                LOGGER.info(
+                    f"Hitting PaginationReset event. StreamSlice used will go from {previous_slice} to {stream_slice}"
+                )
+                reset_pagination = False
             else:
                 last_page_token_value = (
                     next_page_token.get("next_page_token") if next_page_token else None
                 )
                 next_page_token = self._next_page_token(
-                    response=response,
+                    response=response,  # type:ignore # we are breaking from the loop on the try/else if there are no response so this should be fine
                     last_page_size=last_page_size,
                     last_record=last_record,
                     last_page_token_value=last_page_token_value,
                 )
                 if not next_page_token:
-                    pagination_complete = True
+                    break
 
         # Always return an empty generator just in case no records were ever yielded
         yield from []
 
+    def _get_initial_next_page_token(self) -> Optional[Mapping[str, Any]]:
+        initial_token = self._paginator.get_initial_token()
+        next_page_token = {"next_page_token": initial_token} if initial_token is not None else None
+        return next_page_token
+
     def _read_single_page(
         self,
         records_generator_fn: Callable[[Optional[requests.Response]], Iterable[Record]],

airbyte_cdk/sources/streams/concurrent/cursor.py

@@ -19,7 +19,7 @@ from typing import (
 )
 
 from airbyte_cdk.sources.connector_state_manager import ConnectorStateManager
-from airbyte_cdk.sources.message import MessageRepository
+from airbyte_cdk.sources.message import MessageRepository, NoopMessageRepository
 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
@@ -41,7 +41,7 @@ class CursorField:
     def __init__(self, cursor_field_key: str) -> None:
         self.cursor_field_key = cursor_field_key
 
-    def extract_value(self, record: Record) -> CursorValueType:
+    def extract_value(self, record: Record) -> Any:
         cursor_value = record.data.get(self.cursor_field_key)
         if cursor_value is None:
             raise ValueError(f"Could not find cursor field {self.cursor_field_key} in record")
@@ -136,6 +136,24 @@ class ConcurrentCursor(Cursor):
     _START_BOUNDARY = 0
     _END_BOUNDARY = 1
 
+    def copy_without_state(self) -> "ConcurrentCursor":
+        return self.__class__(
+            stream_name=self._stream_name,
+            stream_namespace=self._stream_namespace,
+            stream_state={},
+            message_repository=NoopMessageRepository(),
+            connector_state_manager=ConnectorStateManager(),
+            connector_state_converter=self._connector_state_converter,
+            cursor_field=self._cursor_field,
+            slice_boundary_fields=self._slice_boundary_fields,
+            start=self._start,
+            end_provider=self._end_provider,
+            lookback_window=self._lookback_window,
+            slice_range=self._slice_range,
+            cursor_granularity=self._cursor_granularity,
+            clamping_strategy=self._clamping_strategy,
+        )
+
     def __init__(
         self,
         stream_name: str,
@@ -174,6 +192,7 @@ class ConcurrentCursor(Cursor):
         # Flag to track if the logger has been triggered (per stream)
         self._should_be_synced_logger_triggered = False
         self._clamping_strategy = clamping_strategy
+        self._is_ascending_order = True
 
         # A lock is required when closing a partition because updating the cursor's concurrent_state is
         # not thread safe. When multiple partitions are being closed by the cursor at the same time, it is
@@ -245,6 +264,8 @@ class ConcurrentCursor(Cursor):
 
             if most_recent_cursor_value is None or most_recent_cursor_value < cursor_value:
                 self._most_recent_cursor_value_per_partition[record.associated_slice] = cursor_value
+            elif most_recent_cursor_value > cursor_value:
+                self._is_ascending_order = False
         except ValueError:
             self._log_for_record_without_cursor_value()
 
@@ -516,3 +537,31 @@ class ConcurrentCursor(Cursor):
                 f"Could not find cursor field `{self.cursor_field.cursor_field_key}` in record for stream {self._stream_name}. The incremental sync will assume it needs to be synced"
             )
             self._should_be_synced_logger_triggered = True
+
+    def reduce_slice_range(self, stream_slice: StreamSlice) -> StreamSlice:
+        # In theory, we might be more flexible here meaning that it doesn't need to be in ascending order but it just
+        # needs to be ordered. For now though, we will only support ascending order.
+        if not self._is_ascending_order:
+            LOGGER.warning(
+                "Attempting to reduce slice while records are not returned in incremental order might lead to missing records"
+            )
+
+        if stream_slice in self._most_recent_cursor_value_per_partition:
+            return StreamSlice(
+                partition=stream_slice.partition,
+                cursor_slice={
+                    self._slice_boundary_fields_wrapper[
+                        self._START_BOUNDARY
+                    ]: self._connector_state_converter.output_format(
+                        self._most_recent_cursor_value_per_partition[stream_slice]
+                    ),
+                    self._slice_boundary_fields_wrapper[
+                        self._END_BOUNDARY
+                    ]: stream_slice.cursor_slice[
+                        self._slice_boundary_fields_wrapper[self._END_BOUNDARY]
+                    ],
+                },
+                extra_fields=stream_slice.extra_fields,
+            )
+        else:
+            return stream_slice

airbyte_cdk/sources/streams/http/error_handlers/response_models.py

@@ -16,6 +16,7 @@ class ResponseAction(Enum):
     RETRY = "RETRY"
     FAIL = "FAIL"
     IGNORE = "IGNORE"
+    RESET_PAGINATION = "RESET_PAGINATION"
     RATE_LIMITED = "RATE_LIMITED"
 
 

airbyte_cdk/sources/streams/http/http_client.py

@@ -42,6 +42,9 @@ from airbyte_cdk.sources.streams.http.exceptions import (
     RequestBodyException,
     UserDefinedBackoffException,
 )
+from airbyte_cdk.sources.streams.http.pagination_reset_exception import (
+    PaginationResetRequiredException,
+)
 from airbyte_cdk.sources.streams.http.rate_limiting import (
     http_client_default_backoff_handler,
     rate_limit_default_backoff_handler,
@@ -428,6 +431,9 @@ class HttpClient:
         if error_resolution.response_action not in self._ACTIONS_TO_RETRY_ON:
             self._evict_key(request)
 
+        if error_resolution.response_action == ResponseAction.RESET_PAGINATION:
+            raise PaginationResetRequiredException()
+
         # Emit stream status RUNNING with the reason RATE_LIMITED to log that the rate limit has been reached
         if error_resolution.response_action == ResponseAction.RATE_LIMITED:
             # TODO: Update to handle with message repository when concurrent message repository is ready

airbyte_cdk/sources/streams/http/pagination_reset_exception.py

@@ -0,0 +1,2 @@
+class PaginationResetRequiredException(Exception):
+    pass

airbyte_cdk/test/mock_http/response_builder.py

@@ -75,6 +75,25 @@ class NestedPath(Path):
         return f"NestedPath(path={self._path})"
 
 
+class RootPath:
+    """
+    Path to use when the root of the response is an array.
+    """
+
+    def write(self, template: List[Dict[str, Any]], value: List[Dict[str, Any]]) -> None:
+        template.extend(value)
+
+    def update(self, template: List[Dict[str, Any]], value: List[Any]) -> None:
+        template.clear()
+        template.extend(value)
+
+    def extract(self, template: List[Dict[str, Any]]) -> Any:
+        return template
+
+    def __str__(self) -> str:
+        return f"RootPath"
+
+
 class PaginationStrategy(ABC):
     @abstractmethod
     def update(self, response: Dict[str, Any]) -> None:
@@ -149,12 +168,14 @@ class RecordBuilder:
 class HttpResponseBuilder:
     def __init__(
         self,
-        template: Dict[str, Any],
-        records_path: Union[FieldPath, NestedPath],
+        template: Union[Dict[str, Any], List[Dict[str, Any]]],
+        records_path: Union[FieldPath, NestedPath, RootPath],
         pagination_strategy: Optional[PaginationStrategy],
     ):
-        self._response = template
+        _validate_path_with_response(records_path, template)
+
         self._records: List[RecordBuilder] = []
+        self._response = template
         self._records_path = records_path
         self._pagination_strategy = pagination_strategy
         self._status_code = 200
@@ -169,6 +190,9 @@ class HttpResponseBuilder:
                 "`pagination_strategy` was not provided and hence, fields related to the pagination can't be modified. Please provide "
                 "`pagination_strategy` while instantiating ResponseBuilder to leverage this capability"
             )
+        elif isinstance(self._response, List):
+            raise ValueError("pagination_strategy requires the response to be a dict but was list")
+
         self._pagination_strategy.update(self._response)
         return self
 
@@ -177,7 +201,7 @@ class HttpResponseBuilder:
         return self
 
     def build(self) -> HttpResponse:
-        self._records_path.update(self._response, [record.build() for record in self._records])
+        self._records_path.update(self._response, [record.build() for record in self._records])  # type: ignore  # validated using _validate_path_with_response
         return HttpResponse(json.dumps(self._response), self._status_code)
 
 
@@ -208,15 +232,16 @@ def find_binary_response(resource: str, execution_folder: str) -> bytes:
 
 def create_record_builder(
     response_template: Dict[str, Any],
-    records_path: Union[FieldPath, NestedPath],
+    records_path: Union[FieldPath, NestedPath, RootPath],
     record_id_path: Optional[Path] = None,
     record_cursor_path: Optional[Union[FieldPath, NestedPath]] = None,
 ) -> RecordBuilder:
     """
     This will use the first record define at `records_path` as a template for the records. If more records are defined, they will be ignored
     """
+    _validate_path_with_response(records_path, response_template)
     try:
-        record_template = records_path.extract(response_template)[0]
+        record_template = records_path.extract(response_template)[0]  # type: ignore  # validated using _validate_path_with_response
         if not record_template:
             raise ValueError(
                 f"Could not extract any record from template at path `{records_path}`. "
@@ -230,8 +255,20 @@ def create_record_builder(
 
 
 def create_response_builder(
-    response_template: Dict[str, Any],
-    records_path: Union[FieldPath, NestedPath],
+    response_template: Union[Dict[str, Any], List[Dict[str, Any]]],
+    records_path: Union[FieldPath, NestedPath, RootPath],
     pagination_strategy: Optional[PaginationStrategy] = None,
 ) -> HttpResponseBuilder:
     return HttpResponseBuilder(response_template, records_path, pagination_strategy)
+
+
+def _validate_path_with_response(
+    records_path: Union[FieldPath, NestedPath, RootPath],
+    response_template: Union[Dict[str, Any], List[Dict[str, Any]]],
+) -> None:
+    if isinstance(response_template, List) and not isinstance(records_path, RootPath):
+        raise ValueError("templates of type lists require RootPath")
+    elif isinstance(response_template, Dict) and not isinstance(
+        records_path, (FieldPath, NestedPath)
+    ):
+        raise ValueError("templates of type dict either require FieldPath or NestedPath")

{airbyte_cdk-7.3.2.dist-info → airbyte_cdk-7.3.3.dist-info}/METADATA

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

{airbyte_cdk-7.3.2.dist-info → airbyte_cdk-7.3.3.dist-info}/RECORD

@@ -130,7 +130,7 @@ airbyte_cdk/sources/declarative/concurrent_declarative_source.py,sha256=z0AgJ6AZ
 airbyte_cdk/sources/declarative/datetime/__init__.py,sha256=4Hw-PX1-VgESLF16cDdvuYCzGJtHntThLF4qIiULWeo,61
 airbyte_cdk/sources/declarative/datetime/datetime_parser.py,sha256=_zGNGq31RNy_0QBLt_EcTvgPyhj7urPdx6oA3M5-r3o,3150
 airbyte_cdk/sources/declarative/datetime/min_max_datetime.py,sha256=0BHBtDNQZfvwM45-tY5pNlTcKAFSGGNxemoi0Jic-0E,5785
-airbyte_cdk/sources/declarative/declarative_component_schema.yaml,sha256=D5WeK1Iw_T0ZxLKCmKLowyO7GwxnwfhYom-sd1W14uQ,187793
+airbyte_cdk/sources/declarative/declarative_component_schema.yaml,sha256=0rHsucvsnGfcDVZ3hn9mBU9bhiHVC979LfXuZfoqaUk,188875
 airbyte_cdk/sources/declarative/decoders/__init__.py,sha256=JHb_0d3SE6kNY10mxA5YBEKPeSbsWYjByq1gUQxepoE,953
 airbyte_cdk/sources/declarative/decoders/composite_raw_decoder.py,sha256=qB4lRUrCXLTE-a3VlpOLaazHiC7RIF_FIVJesuz7ebw,8078
 airbyte_cdk/sources/declarative/decoders/decoder.py,sha256=1PeKwuMK8x9dsA2zqUjSVinEWVSEgYcUS6npiW3aC2c,855
@@ -150,7 +150,7 @@ airbyte_cdk/sources/declarative/extractors/record_selector.py,sha256=vCpwX1PVRFP
 airbyte_cdk/sources/declarative/extractors/response_to_file_extractor.py,sha256=WJyA2OYIEgFpVP5Y3o0tIj69AV6IKkn9B16MeXaEItI,6513
 airbyte_cdk/sources/declarative/extractors/type_transformer.py,sha256=d6Y2Rfg8pMVEEnHllfVksWZdNVOU55yk34O03dP9muY,1626
 airbyte_cdk/sources/declarative/incremental/__init__.py,sha256=_y8H65KgdmVNpwQAzXtXzi-t9mY6bmIIAWtRAbpHfEo,295
-airbyte_cdk/sources/declarative/incremental/concurrent_partition_cursor.py,sha256=vaynWCXmScAuVnrbJ2T7M1Y4RSZO7ctAej-kzZJYifk,27868
+airbyte_cdk/sources/declarative/incremental/concurrent_partition_cursor.py,sha256=ldroIGnz1rie9cNZF-Jsl3J6yAqNe7KYS7PNE342Eqs,27995
 airbyte_cdk/sources/declarative/interpolation/__init__.py,sha256=Kh7FxhfetyNVDnAQ9zSxNe4oUbb8CvoW7Mqz7cs2iPg,437
 airbyte_cdk/sources/declarative/interpolation/filters.py,sha256=cYap5zzOxIJWCLIfbkNlpyfUhjZ8FklLroIG4WGzYVs,5537
 airbyte_cdk/sources/declarative/interpolation/interpolated_boolean.py,sha256=8F3ntT_Mfo8cO9n6dCq8rTfJIpfKmzRCsVtVdhzaoGc,1964
@@ -165,14 +165,14 @@ airbyte_cdk/sources/declarative/migrations/legacy_to_per_partition_state_migrati
 airbyte_cdk/sources/declarative/migrations/state_migration.py,sha256=KWPjealMLKSMtajXgkdGgKg7EmTLR-CqqD7UIh0-eDU,794
 airbyte_cdk/sources/declarative/models/__init__.py,sha256=nUFxNCiKeYRVXuZEKA7GD-lTHxsiKcQ8FitZjKhPIvE,100
 airbyte_cdk/sources/declarative/models/base_model_with_deprecations.py,sha256=Imnj3yef0aqRdLfaUxkIYISUb8YkiPrRH_wBd-x8HjM,5999
-airbyte_cdk/sources/declarative/models/declarative_component_schema.py,sha256=t2td-7swgXY3RJc1VDBFUYI2Blc55j5TDFdg90aHwlU,132123
+airbyte_cdk/sources/declarative/models/declarative_component_schema.py,sha256=oLHcK2TVRgzahkDPuPvZ-6OqXS_DQU2gcBGq3SRpKsY,132793
 airbyte_cdk/sources/declarative/parsers/__init__.py,sha256=ZnqYNxHsKCgO38IwB34RQyRMXTs4GTvlRi3ImKnIioo,61
 airbyte_cdk/sources/declarative/parsers/custom_code_compiler.py,sha256=nlVvHC511NUyDEEIRBkoeDTAvLqKNp-hRy8D19z8tdk,5941
 airbyte_cdk/sources/declarative/parsers/custom_exceptions.py,sha256=wnRUP0Xeru9Rbu5OexXSDN9QWDo8YU4tT9M2LDVOgGA,802
 airbyte_cdk/sources/declarative/parsers/manifest_component_transformer.py,sha256=la9Ulpc0lQewiBLKJ0FpsWxyU5XISv-ulmFRHJLJ1Pc,11292
 airbyte_cdk/sources/declarative/parsers/manifest_normalizer.py,sha256=EtKjS9c94yNp3AwQC8KUCQaAYW5T3zvFYxoWYjc_buI,19729
 airbyte_cdk/sources/declarative/parsers/manifest_reference_resolver.py,sha256=pJmg78vqE5VfUrF_KJnWjucQ4k9IWFULeAxHCowrHXE,6806
-airbyte_cdk/sources/declarative/parsers/model_to_component_factory.py,sha256=QUDfBVn3KQZQKQJUyr4Dfzez4742JEtat3VuwStsTHM,185692
+airbyte_cdk/sources/declarative/parsers/model_to_component_factory.py,sha256=AgZ7mRbXVZHWTftPuDdH6wTanZPGi_dxtiu2dSxyWjs,188331
 airbyte_cdk/sources/declarative/partition_routers/__init__.py,sha256=TBC9AkGaUqHm2IKHMPN6punBIcY5tWGULowcLoAVkfw,1109
 airbyte_cdk/sources/declarative/partition_routers/async_job_partition_router.py,sha256=VelO7zKqKtzMJ35jyFeg0ypJLQC0plqqIBNXoBW1G2E,3001
 airbyte_cdk/sources/declarative/partition_routers/cartesian_product_stream_slicer.py,sha256=ocm4hZ4k-tEGs5HLrtI8ecWSK0hGqNH0Rvz2byx_HZk,6927
@@ -191,7 +191,7 @@ airbyte_cdk/sources/declarative/requesters/error_handlers/backoff_strategies/hea
 airbyte_cdk/sources/declarative/requesters/error_handlers/backoff_strategies/wait_time_from_header_backoff_strategy.py,sha256=I3KYCJHhPiRfxYUzOa293YH4U3wGFISDsdY1OMHWRtw,2942
 airbyte_cdk/sources/declarative/requesters/error_handlers/backoff_strategies/wait_until_time_from_header_backoff_strategy.py,sha256=T2JTIdHdPzPiW0MpkCNYPsuaHUtF9V-ijNqUqdTDl6U,3069
 airbyte_cdk/sources/declarative/requesters/error_handlers/backoff_strategy.py,sha256=ZN5kcaVAQDinX0Ld5NXA8M_7Sax5BoPsknVwH7v06as,634
-airbyte_cdk/sources/declarative/requesters/error_handlers/composite_error_handler.py,sha256=4_PegbHBUiNbqa5ndZ2n9rm69O2iEfWU-NcIhSXZDIs,4137
+airbyte_cdk/sources/declarative/requesters/error_handlers/composite_error_handler.py,sha256=yVMyKI4C-9vbIrTtQPdAndZQzdzpgRzqxtXDed2xwcE,4050
 airbyte_cdk/sources/declarative/requesters/error_handlers/default_error_handler.py,sha256=BGED9TcbA3mlvd9D7sog_u5AiyjWGVOUq_00aK3PNzg,5111
 airbyte_cdk/sources/declarative/requesters/error_handlers/default_http_response_filter.py,sha256=q0YkeYUUWO6iErUy0vjqiOkhg8_9d5YcCmtlpXAJJ9E,1314
 airbyte_cdk/sources/declarative/requesters/error_handlers/error_handler.py,sha256=Tan66odx8VHzfdyyXMQkXz2pJYksllGqvxmpoajgcK4,669
@@ -240,8 +240,9 @@ airbyte_cdk/sources/declarative/retrievers/file_uploader/file_uploader.py,sha256
 airbyte_cdk/sources/declarative/retrievers/file_uploader/file_writer.py,sha256=V8gAFjQXkhX5mwj1NafdcUrMfMBNF1hi0mrdXIl5qEc,359
 airbyte_cdk/sources/declarative/retrievers/file_uploader/local_file_system_file_writer.py,sha256=jLpdonre1UHfbjGSD5AK_T0codLABJByTvbqepDZtEQ,422
 airbyte_cdk/sources/declarative/retrievers/file_uploader/noop_file_writer.py,sha256=1yfimzxm09d2j605cu_HhiYVDNVL1rUMi3vs_jYlIyY,330
+airbyte_cdk/sources/declarative/retrievers/pagination_tracker.py,sha256=h-3GfksrWaQUa1xIefq9eG-6_DuW77Vq8XDenv-hCps,2865
 airbyte_cdk/sources/declarative/retrievers/retriever.py,sha256=os5psYh8z7ZdCAvbfZeTpmjvPa7Qpx0mblpKf47ZaZM,1876
-airbyte_cdk/sources/declarative/retrievers/simple_retriever.py,sha256=sa8xS8FTStqgp1kkc_ObJjO_b1Q4Nek3XdJ7KODLqQw,28136
+airbyte_cdk/sources/declarative/retrievers/simple_retriever.py,sha256=8nb87fsBno1SOxHxYA-sGxAy48sapcF3aZszBu4Ew_s,29643
 airbyte_cdk/sources/declarative/schema/__init__.py,sha256=xU45UvM5O4c1PSM13UHpCdh5hpW3HXy9vRRGEiAC1rg,795
 airbyte_cdk/sources/declarative/schema/composite_schema_loader.py,sha256=ymGbvxS_QyGc4nnjEyRo5ch8bVedELO41PAUxKXZyMw,1113
 airbyte_cdk/sources/declarative/schema/default_schema_loader.py,sha256=UnbzlExmwoQiVV8zDg4lhAEaqA_0pRfwbMRe8yqOuWk,1834
@@ -352,7 +353,7 @@ airbyte_cdk/sources/streams/concurrent/abstract_stream_facade.py,sha256=QTry1QCB
 airbyte_cdk/sources/streams/concurrent/adapters.py,sha256=h4ZewhWn2PzPTt0lZZjcUL4rrpW9E_of7prnI3bm-c4,14004
 airbyte_cdk/sources/streams/concurrent/availability_strategy.py,sha256=M0XmvF3vjlr4GbCM0XH1hAj7udiAONM9SnmXjqufzLM,1035
 airbyte_cdk/sources/streams/concurrent/clamping.py,sha256=i26GVyui2ScEXSP-IP_61K2HaTp1-6lTlYHsZVYpuZA,3240
-airbyte_cdk/sources/streams/concurrent/cursor.py,sha256=Dxjx4IAHZ6HHyfJ-B5SUTTYgdb1ZiiBKsZm3pYUquzk,23411
+airbyte_cdk/sources/streams/concurrent/cursor.py,sha256=oEcqUyswPyOg6SnjrFr8c8YYxVvaaInWNCHRLQcKjmk,25713
 airbyte_cdk/sources/streams/concurrent/cursor_types.py,sha256=ZyWLPpeLX1qXcP5MwS-wxK11IBMsnVPCw9zx8gA2_Ro,843
 airbyte_cdk/sources/streams/concurrent/default_stream.py,sha256=SSufbo5f7OOYS8DZaABXeJVvodcfp9wb8J9lT5Xik3s,4744
 airbyte_cdk/sources/streams/concurrent/exceptions.py,sha256=JOZ446MCLpmF26r9KfS6OO_6rGjcjgJNZdcw6jccjEI,468
@@ -379,10 +380,11 @@ airbyte_cdk/sources/streams/http/error_handlers/error_handler.py,sha256=GuqP7U1e
 airbyte_cdk/sources/streams/http/error_handlers/error_message_parser.py,sha256=xC93uB5BJd3iOnAXCrYLJTitWeGZlqzwe55VtsZqNnE,456
 airbyte_cdk/sources/streams/http/error_handlers/http_status_error_handler.py,sha256=2gqececTxxUqO6aIkVNNXADg48Px5EHUwnXHL9KiPT8,4188
 airbyte_cdk/sources/streams/http/error_handlers/json_error_message_parser.py,sha256=GW5rkBQLLTj7MEaDdbpG7DHxTQVRrDOg1ehLLxjqiM4,1828
-airbyte_cdk/sources/streams/http/error_handlers/response_models.py,sha256=xGIVELBFY0TmH9aUq1ikoqJz8oHLr6di2JLvKWVEO-s,2236
+airbyte_cdk/sources/streams/http/error_handlers/response_models.py,sha256=4uE83yZfBe8s_81U3yZRcY1eRhvJnz9NanCp7G2PY-k,2278
 airbyte_cdk/sources/streams/http/exceptions.py,sha256=TTUpWq_qLPtdvXqYPpMhtYbFVQ7dGtajDVfjb6KQ8z8,2099
 airbyte_cdk/sources/streams/http/http.py,sha256=0uariNq8OFnlX7iqOHwBhecxA-Hfd5hSY8_XCEgn3jI,28499
-airbyte_cdk/sources/streams/http/http_client.py,sha256=7VzR4Cm5Sqm79SdFg26WXPzQC_-RclPHAFKiyCjoFs8,25442
+airbyte_cdk/sources/streams/http/http_client.py,sha256=Afa4bPJrazMmSG15y-Hum194LnlpkaNrfgjLQk1SzqM,25690
+airbyte_cdk/sources/streams/http/pagination_reset_exception.py,sha256=M5zUi9OREH5DnHHoZUDbKf9uTdIBta8je5p52U9gu94,60
 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=aWrBmJ8AhUtvtHhHq5JGVZFXjDa7jG8DZePG4gEs9VY,19800
@@ -419,7 +421,7 @@ airbyte_cdk/test/mock_http/matcher.py,sha256=4Qj8UnJKZIs-eodshryce3SN1Ayc8GZpBET
 airbyte_cdk/test/mock_http/mocker.py,sha256=XgsjMtVoeMpRELPyALgrkHFauH9H5irxrz1Kcxh2yFY,8013
 airbyte_cdk/test/mock_http/request.py,sha256=tdB8cqk2vLgCDTOKffBKsM06llYs4ZecgtH6DKyx6yY,4112
 airbyte_cdk/test/mock_http/response.py,sha256=s4-cQQqTtmeej0pQDWqmG0vUWpHS-93lIWMpW3zSVyU,662
-airbyte_cdk/test/mock_http/response_builder.py,sha256=F-v7ebftqGj7YVIMLKdodmU9U8Dq8aIyllWGo2NGwHc,8331
+airbyte_cdk/test/mock_http/response_builder.py,sha256=N9DovhVtLqIGyubWcPGomr9CNy8KLg-EJoDk6x_t4js,9857
 airbyte_cdk/test/models/__init__.py,sha256=5f5oFcuUA3dyNTfvvTWav2pTD8WX4nznObKgMTmvdus,290
 airbyte_cdk/test/models/outcome.py,sha256=niSX6gkP4P-_kQUF1jkbBXq72FC3Rtkvtdl0gJsUyho,2263
 airbyte_cdk/test/models/scenario.py,sha256=M6vq4btxUI6ZiSQNNoNFOgUsZNDFdoieGOTe-AVHstc,6435
@@ -457,9 +459,9 @@ airbyte_cdk/utils/slice_hasher.py,sha256=EDxgROHDbfG-QKQb59m7h_7crN1tRiawdf5uU7G
 airbyte_cdk/utils/spec_schema_transformations.py,sha256=9YDJmnIGFsT51CVQf2tSSvTapGimITjEFGbUTSZAGTI,963
 airbyte_cdk/utils/stream_status_utils.py,sha256=ZmBoiy5HVbUEHAMrUONxZvxnvfV9CesmQJLDTAIWnWw,1171
 airbyte_cdk/utils/traced_exception.py,sha256=C8uIBuCL_E4WnBAOPSxBicD06JAldoN9fGsQDp463OY,6292
-airbyte_cdk-7.3.2.dist-info/LICENSE.txt,sha256=Wfe61S4BaGPj404v8lrAbvhjYR68SHlkzeYrg3_bbuM,1051
-airbyte_cdk-7.3.2.dist-info/LICENSE_SHORT,sha256=aqF6D1NcESmpn-cqsxBtszTEnHKnlsp8L4x9wAh3Nxg,55
-airbyte_cdk-7.3.2.dist-info/METADATA,sha256=rx2PHndj9YB3wb4wbgEplFCj7zyt3Lge0QkB5ztsRHQ,6798
-airbyte_cdk-7.3.2.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-airbyte_cdk-7.3.2.dist-info/entry_points.txt,sha256=eLZ2UYvJZGm1s07Pplcs--1Gim60YhZWTb53j_dghwU,195
-airbyte_cdk-7.3.2.dist-info/RECORD,,
+airbyte_cdk-7.3.3.dist-info/LICENSE.txt,sha256=Wfe61S4BaGPj404v8lrAbvhjYR68SHlkzeYrg3_bbuM,1051
+airbyte_cdk-7.3.3.dist-info/LICENSE_SHORT,sha256=aqF6D1NcESmpn-cqsxBtszTEnHKnlsp8L4x9wAh3Nxg,55
+airbyte_cdk-7.3.3.dist-info/METADATA,sha256=oy27N1IyxbkA8M82Maa4L-hRO-Njevgu_4AqS89jyFU,6798
+airbyte_cdk-7.3.3.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+airbyte_cdk-7.3.3.dist-info/entry_points.txt,sha256=eLZ2UYvJZGm1s07Pplcs--1Gim60YhZWTb53j_dghwU,195
+airbyte_cdk-7.3.3.dist-info/RECORD,,