airbyte-cdk 6.41.2.dev0__tar.gz → 6.41.4__tar.gz

{airbyte_cdk-6.41.2.dev0 → airbyte_cdk-6.41.4}/PKG-INFO

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

{airbyte_cdk-6.41.2.dev0 → airbyte_cdk-6.41.4}/airbyte_cdk/sources/declarative/async_job/job_orchestrator.py

@@ -179,7 +179,7 @@ class AsyncJobOrchestrator:
         self._non_breaking_exceptions: List[Exception] = []
 
     def _replace_failed_jobs(self, partition: AsyncPartition) -> None:
-        failed_status_jobs = (AsyncJobStatus.FAILED, AsyncJobStatus.TIMED_OUT)
+        failed_status_jobs = (AsyncJobStatus.FAILED,)
         jobs_to_replace = [job for job in partition.jobs if job.status() in failed_status_jobs]
         for job in jobs_to_replace:
             new_job = self._start_job(job.job_parameters(), job.api_job_id())
@@ -359,14 +359,11 @@ class AsyncJobOrchestrator:
                     self._process_partitions_with_errors(partition)
                 case _:
                     self._stop_timed_out_jobs(partition)
+                    # re-allocate FAILED jobs, but TIMEOUT jobs are not re-allocated
+                    self._reallocate_partition(current_running_partitions, partition)
 
-                    # job will be restarted in `_start_job`
-                    current_running_partitions.insert(0, partition)
-
-            for job in partition.jobs:
-                # We only remove completed jobs as we want failed/timed out jobs to be re-allocated in priority
-                if job.status() == AsyncJobStatus.COMPLETED:
-                    self._job_tracker.remove_job(job.api_job_id())
+            # We only remove completed / timeout jobs jobs as we want failed jobs to be re-allocated in priority
+            self._remove_completed_or_timed_out_jobs(partition)
 
         # update the referenced list with running partitions
         self._running_partitions = current_running_partitions
@@ -381,8 +378,11 @@ class AsyncJobOrchestrator:
     def _stop_timed_out_jobs(self, partition: AsyncPartition) -> None:
         for job in partition.jobs:
             if job.status() == AsyncJobStatus.TIMED_OUT:
-                # we don't free allocation here because it is expected to retry the job
-                self._abort_job(job, free_job_allocation=False)
+                self._abort_job(job, free_job_allocation=True)
+                raise AirbyteTracedException(
+                    internal_message=f"Job {job.api_job_id()} has timed out. Try increasing the `polling job timeout`.",
+                    failure_type=FailureType.config_error,
+                )
 
     def _abort_job(self, job: AsyncJob, free_job_allocation: bool = True) -> None:
         try:
@@ -392,6 +392,34 @@ class AsyncJobOrchestrator:
         except Exception as exception:
             LOGGER.warning(f"Could not free budget for job {job.api_job_id()}: {exception}")
 
+    def _remove_completed_or_timed_out_jobs(self, partition: AsyncPartition) -> None:
+        """
+        Remove completed or timed out jobs from the partition.
+
+        Args:
+            partition (AsyncPartition): The partition to process.
+        """
+        for job in partition.jobs:
+            if job.status() in [AsyncJobStatus.COMPLETED, AsyncJobStatus.TIMED_OUT]:
+                self._job_tracker.remove_job(job.api_job_id())
+
+    def _reallocate_partition(
+        self,
+        current_running_partitions: List[AsyncPartition],
+        partition: AsyncPartition,
+    ) -> None:
+        """
+        Reallocate the partition by starting a new job for each job in the
+        partition.
+        Args:
+            current_running_partitions (list): The list of currently running partitions.
+            partition (AsyncPartition): The partition to reallocate.
+        """
+        for job in partition.jobs:
+            if job.status() != AsyncJobStatus.TIMED_OUT:
+                # allow the FAILED jobs to be re-allocated for partition
+                current_running_partitions.insert(0, partition)
+
     def _process_partitions_with_errors(self, partition: AsyncPartition) -> None:
         """
         Process a partition with status errors (FAILED and TIMEOUT).

{airbyte_cdk-6.41.2.dev0 → airbyte_cdk-6.41.4}/airbyte_cdk/sources/declarative/declarative_component_schema.yaml

@@ -2894,7 +2894,7 @@ definitions:
         title: Lazy Read Pointer
         description: If set, this will enable lazy reading, using the initial read of parent records to extract child records.
         type: array
-        default: []
+        default: [ ]
         items:
           - type: string
         interpolation_context:
@@ -3199,7 +3199,7 @@ definitions:
     properties:
       type:
         type: string
-        enum: [StateDelegatingStream]
+        enum: [ StateDelegatingStream ]
       name:
         title: Name
         description: The stream name.
@@ -3254,14 +3254,12 @@ definitions:
           - "$ref": "#/definitions/CustomPartitionRouter"
           - "$ref": "#/definitions/ListPartitionRouter"
           - "$ref": "#/definitions/SubstreamPartitionRouter"
-          - "$ref": "#/definitions/GroupingPartitionRouter"
           - type: array
             items:
               anyOf:
                 - "$ref": "#/definitions/CustomPartitionRouter"
                 - "$ref": "#/definitions/ListPartitionRouter"
                 - "$ref": "#/definitions/SubstreamPartitionRouter"
-                - "$ref": "#/definitions/GroupingPartitionRouter"
       decoder:
         title: Decoder
         description: Component decoding the response so records can be extracted.
@@ -3335,7 +3333,7 @@ definitions:
         items:
           type: string
   AsyncRetriever:
-    description: "[Experimental - We expect the interface to change shortly and we reserve the right to not consider this a breaking change] Retrieves records by Asynchronously sending requests to fetch records. The retriever acts as an orchestrator between the requester, the record selector, the paginator, and the partition router."
+    description: "Retrieves records by Asynchronously sending requests to fetch records. The retriever acts as an orchestrator between the requester, the record selector, the paginator, and the partition router."
     type: object
     required:
       - type
@@ -3383,6 +3381,13 @@ definitions:
         anyOf:
           - "$ref": "#/definitions/CustomRequester"
           - "$ref": "#/definitions/HttpRequester"
+      polling_job_timeout:
+        description: The time in minutes after which the single Async Job should be considered as Timed Out.
+        anyOf:
+          - type: integer
+          - type: string
+        interpolation_context:
+          - config
       download_target_requester:
         description: Requester component that describes how to prepare HTTP requests to send to the source API to extract the url from polling response by the completed async job.
         anyOf:
@@ -3416,14 +3421,12 @@ definitions:
           - "$ref": "#/definitions/CustomPartitionRouter"
           - "$ref": "#/definitions/ListPartitionRouter"
           - "$ref": "#/definitions/SubstreamPartitionRouter"
-          - "$ref": "#/definitions/GroupingPartitionRouter"
           - type: array
             items:
               anyOf:
                 - "$ref": "#/definitions/CustomPartitionRouter"
                 - "$ref": "#/definitions/ListPartitionRouter"
                 - "$ref": "#/definitions/SubstreamPartitionRouter"
-                - "$ref": "#/definitions/GroupingPartitionRouter"
       decoder:
         title: Decoder
         description: Component decoding the response so records can be extracted.
@@ -3540,44 +3543,6 @@ definitions:
       $parameters:
         type: object
         additionalProperties: true
-  GroupingPartitionRouter:
-    title: Grouping Partition Router
-    description: >
-      A decorator on top of a partition router that groups partitions into batches of a specified size.
-      This is useful for APIs that support filtering by multiple partition keys in a single request.
-      Note that per-partition incremental syncs may not work as expected because the grouping
-      of partitions might change between syncs, potentially leading to inconsistent state tracking.
-    type: object
-    required:
-      - type
-      - group_size
-      - underlying_partition_router
-    properties:
-      type:
-        type: string
-        enum: [GroupingPartitionRouter]
-      group_size:
-        title: Group Size
-        description: The number of partitions to include in each group. This determines how many partition values are batched together in a single slice.
-        type: integer
-        examples:
-          - 10
-          - 50
-      underlying_partition_router:
-        title: Underlying Partition Router
-        description: The partition router whose output will be grouped. This can be any valid partition router component.
-        anyOf:
-          - "$ref": "#/definitions/CustomPartitionRouter"
-          - "$ref": "#/definitions/ListPartitionRouter"
-          - "$ref": "#/definitions/SubstreamPartitionRouter"
-      deduplicate:
-        title: Deduplicate Partitions
-        description: If true, ensures that partitions are unique within each group by removing duplicates based on the partition key.
-        type: boolean
-        default: true
-      $parameters:
-        type: object
-        additionalProperties: true
   WaitUntilTimeFromHeader:
     title: Wait Until Time Defined In Response Header
     description: Extract time at which we can retry the request from response header and wait for the difference between now and that time.

{airbyte_cdk-6.41.2.dev0 → airbyte_cdk-6.41.4}/airbyte_cdk/sources/declarative/incremental/concurrent_partition_cursor.py

@@ -79,7 +79,6 @@ class ConcurrentPerPartitionCursor(Cursor):
         connector_state_manager: ConnectorStateManager,
         connector_state_converter: AbstractStreamStateConverter,
         cursor_field: CursorField,
-        use_global_cursor: bool = False,
     ) -> None:
         self._global_cursor: Optional[StreamState] = {}
         self._stream_name = stream_name
@@ -107,7 +106,7 @@ class ConcurrentPerPartitionCursor(Cursor):
         self._lookback_window: int = 0
         self._parent_state: Optional[StreamState] = None
         self._number_of_partitions: int = 0
-        self._use_global_cursor: bool = use_global_cursor
+        self._use_global_cursor: bool = False
         self._partition_serializer = PerPartitionKeySerializer()
         # Track the last time a state message was emitted
         self._last_emission_time: float = 0.0

{airbyte_cdk-6.41.2.dev0 → airbyte_cdk-6.41.4}/airbyte_cdk/sources/declarative/models/declarative_component_schema.py

@@ -1467,7 +1467,7 @@ class AddFields(BaseModel):
     )
     condition: Optional[str] = Field(
         "",
-        description="Fields will be added if expression is evaluated to True.,",
+        description="Fields will be added if expression is evaluated to True.",
         examples=[
             "{{ property|string == '' }}",
             "{{ property is integer }}",
@@ -2301,15 +2301,7 @@ class SimpleRetriever(BaseModel):
             CustomPartitionRouter,
             ListPartitionRouter,
             SubstreamPartitionRouter,
-            GroupingPartitionRouter,
-            List[
-                Union[
-                    CustomPartitionRouter,
-                    ListPartitionRouter,
-                    SubstreamPartitionRouter,
-                    GroupingPartitionRouter,
-                ]
-            ],
+            List[Union[CustomPartitionRouter, ListPartitionRouter, SubstreamPartitionRouter]],
         ]
     ] = Field(
         [],
@@ -2362,6 +2354,10 @@ class AsyncRetriever(BaseModel):
         ...,
         description="Requester component that describes how to prepare HTTP requests to send to the source API to fetch the status of the running async job.",
     )
+    polling_job_timeout: Optional[Union[int, str]] = Field(
+        None,
+        description="The time in minutes after which the single Async Job should be considered as Timed Out.",
+    )
     download_target_requester: Optional[Union[CustomRequester, HttpRequester]] = Field(
         None,
         description="Requester component that describes how to prepare HTTP requests to send to the source API to extract the url from polling response by the completed async job.",
@@ -2387,15 +2383,7 @@ class AsyncRetriever(BaseModel):
             CustomPartitionRouter,
             ListPartitionRouter,
             SubstreamPartitionRouter,
-            GroupingPartitionRouter,
-            List[
-                Union[
-                    CustomPartitionRouter,
-                    ListPartitionRouter,
-                    SubstreamPartitionRouter,
-                    GroupingPartitionRouter,
-                ]
-            ],
+            List[Union[CustomPartitionRouter, ListPartitionRouter, SubstreamPartitionRouter]],
         ]
     ] = Field(
         [],
@@ -2447,29 +2435,6 @@ class SubstreamPartitionRouter(BaseModel):
     parameters: Optional[Dict[str, Any]] = Field(None, alias="$parameters")
 
 
-class GroupingPartitionRouter(BaseModel):
-    type: Literal["GroupingPartitionRouter"]
-    group_size: int = Field(
-        ...,
-        description="The number of partitions to include in each group. This determines how many partition values are batched together in a single slice.",
-        examples=[10, 50],
-        title="Group Size",
-    )
-    underlying_partition_router: Union[
-        CustomPartitionRouter, ListPartitionRouter, SubstreamPartitionRouter
-    ] = Field(
-        ...,
-        description="The partition router whose output will be grouped. This can be any valid partition router component.",
-        title="Underlying Partition Router",
-    )
-    deduplicate: Optional[bool] = Field(
-        True,
-        description="If true, ensures that partitions are unique within each group by removing duplicates based on the partition key.",
-        title="Deduplicate Partitions",
-    )
-    parameters: Optional[Dict[str, Any]] = Field(None, alias="$parameters")
-
-
 class HttpComponentsResolver(BaseModel):
     type: Literal["HttpComponentsResolver"]
     retriever: Union[AsyncRetriever, CustomRetriever, SimpleRetriever] = Field(

{airbyte_cdk-6.41.2.dev0 → airbyte_cdk-6.41.4}/airbyte_cdk/sources/declarative/parsers/model_to_component_factory.py

@@ -227,9 +227,6 @@ from airbyte_cdk.sources.declarative.models.declarative_component_schema import
 from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
     FlattenFields as FlattenFieldsModel,
 )
-from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
-    GroupingPartitionRouter as GroupingPartitionRouterModel,
-)
 from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
     GzipDecoder as GzipDecoderModel,
 )
@@ -388,7 +385,6 @@ from airbyte_cdk.sources.declarative.parsers.custom_code_compiler import (
 )
 from airbyte_cdk.sources.declarative.partition_routers import (
     CartesianProductStreamSlicer,
-    GroupingPartitionRouter,
     ListPartitionRouter,
     PartitionRouter,
     SinglePartitionRouter,
@@ -511,7 +507,7 @@ from airbyte_cdk.sources.streams.concurrent.state_converters.incrementing_count_
     IncrementingCountStreamStateConverter,
 )
 from airbyte_cdk.sources.streams.http.error_handlers.response_models import ResponseAction
-from airbyte_cdk.sources.types import Config, ConnectionDefinition
+from airbyte_cdk.sources.types import Config
 from airbyte_cdk.sources.utils.transform import TransformConfig, TypeTransformer
 
 ComponentDefinition = Mapping[str, Any]
@@ -642,7 +638,6 @@ class ModelToComponentFactory:
             UnlimitedCallRatePolicyModel: self.create_unlimited_call_rate_policy,
             RateModel: self.create_rate,
             HttpRequestRegexMatcherModel: self.create_http_request_matcher,
-            GroupingPartitionRouterModel: self.create_grouping_partition_router,
         }
 
         # Needed for the case where we need to perform a second parse on the fields of a custom component
@@ -1360,9 +1355,6 @@ class ModelToComponentFactory:
         )
         stream_state = self.apply_stream_state_migrations(stream_state_migrations, stream_state)
 
-        # Per-partition state doesn't make sense for GroupingPartitionRouter, so force the global state
-        use_global_cursor = isinstance(partition_router, GroupingPartitionRouter)
-
         # Return the concurrent cursor and state converter
         return ConcurrentPerPartitionCursor(
             cursor_factory=cursor_factory,
@@ -1374,7 +1366,6 @@ class ModelToComponentFactory:
             connector_state_manager=state_manager,
             connector_state_converter=connector_state_converter,
             cursor_field=cursor_field,
-            use_global_cursor=use_global_cursor,
         )
 
     @staticmethod
@@ -2948,6 +2939,27 @@ class ModelToComponentFactory:
                 parameters={},
             )
 
+        def _get_job_timeout() -> datetime.timedelta:
+            user_defined_timeout: Optional[int] = (
+                int(
+                    InterpolatedString.create(
+                        str(model.polling_job_timeout),
+                        parameters={},
+                    ).eval(config)
+                )
+                if model.polling_job_timeout
+                else None
+            )
+
+            # check for user defined timeout during the test read or 15 minutes
+            test_read_timeout = datetime.timedelta(minutes=user_defined_timeout or 15)
+            # default value for non-connector builder is 60 minutes.
+            default_sync_timeout = datetime.timedelta(minutes=user_defined_timeout or 60)
+
+            return (
+                test_read_timeout if self._emit_connector_builder_messages else default_sync_timeout
+            )
+
         decoder = (
             self._create_component_from_model(model=model.decoder, config=config)
             if model.decoder
@@ -3041,6 +3053,7 @@ class ModelToComponentFactory:
             config=config,
             name=name,
         )
+
         job_repository: AsyncJobRepository = AsyncHttpJobRepository(
             creation_requester=creation_requester,
             polling_requester=polling_requester,
@@ -3051,6 +3064,7 @@ class ModelToComponentFactory:
             status_extractor=status_extractor,
             status_mapping=self._create_async_job_status_mapping(model.status_mapping, config),
             download_target_extractor=download_target_extractor,
+            job_timeout=_get_job_timeout(),
         )
 
         async_job_partition_router = AsyncJobPartitionRouter(
@@ -3353,34 +3367,3 @@ class ModelToComponentFactory:
         self._api_budget = self.create_component(
             model_type=HTTPAPIBudgetModel, component_definition=component_definition, config=config
         )
-
-    def create_grouping_partition_router(
-        self, model: GroupingPartitionRouterModel, config: Config, **kwargs: Any
-    ) -> GroupingPartitionRouter:
-        underlying_router = self._create_component_from_model(
-            model=model.underlying_partition_router, config=config
-        )
-        if model.group_size < 1:
-            raise ValueError(f"Group size must be greater than 0, got {model.group_size}")
-
-        # Request options in underlying partition routers are not supported for GroupingPartitionRouter
-        # because they are specific to individual partitions and cannot be aggregated or handled
-        # when grouping, potentially leading to incorrect API calls. Any request customization
-        # should be managed at the stream level through the requester's configuration.
-        if isinstance(underlying_router, SubstreamPartitionRouter):
-            if any(
-                parent_config.request_option
-                for parent_config in underlying_router.parent_stream_configs
-            ):
-                raise ValueError("Request options are not supported for GroupingPartitionRouter.")
-
-        if isinstance(underlying_router, ListPartitionRouter):
-            if underlying_router.request_option:
-                raise ValueError("Request options are not supported for GroupingPartitionRouter.")
-
-        return GroupingPartitionRouter(
-            group_size=model.group_size,
-            underlying_partition_router=underlying_router,
-            deduplicate=model.deduplicate if model.deduplicate is not None else True,
-            config=config,
-        )

{airbyte_cdk-6.41.2.dev0 → airbyte_cdk-6.41.4}/airbyte_cdk/sources/declarative/partition_routers/__init__.py

@@ -8,9 +8,6 @@ from airbyte_cdk.sources.declarative.partition_routers.async_job_partition_route
 from airbyte_cdk.sources.declarative.partition_routers.cartesian_product_stream_slicer import (
     CartesianProductStreamSlicer,
 )
-from airbyte_cdk.sources.declarative.partition_routers.grouping_partition_router import (
-    GroupingPartitionRouter,
-)
 from airbyte_cdk.sources.declarative.partition_routers.list_partition_router import (
     ListPartitionRouter,
 )
@@ -25,7 +22,6 @@ from airbyte_cdk.sources.declarative.partition_routers.substream_partition_route
 __all__ = [
     "AsyncJobPartitionRouter",
     "CartesianProductStreamSlicer",
-    "GroupingPartitionRouter",
     "ListPartitionRouter",
     "SinglePartitionRouter",
     "SubstreamPartitionRouter",

{airbyte_cdk-6.41.2.dev0 → airbyte_cdk-6.41.4}/airbyte_cdk/sources/declarative/requesters/http_job_repository.py

@@ -45,7 +45,9 @@ class AsyncHttpJobRepository(AsyncJobRepository):
     status_mapping: Mapping[str, AsyncJobStatus]
     download_target_extractor: DpathExtractor
 
+    # timeout for the job to be completed, passed from `polling_job_timeout`
     job_timeout: Optional[timedelta] = None
+
     record_extractor: RecordExtractor = field(
         init=False, repr=False, default_factory=lambda: ResponseToFileExtractor({})
     )
@@ -131,7 +133,7 @@ class AsyncHttpJobRepository(AsyncJobRepository):
             log_formatter=lambda response: format_http_message(
                 response=response,
                 title="Async Job -- Create",
-                description="Create the server-side async job.",
+                description=f"Create the server-side async job. Timeout after: {self.job_timeout}",
                 stream_name=None,
                 is_auxiliary=True,
                 type="ASYNC_CREATE",
@@ -271,12 +273,59 @@ class AsyncHttpJobRepository(AsyncJobRepository):
         del self._create_job_response_by_id[job_id]
         del self._polling_job_response_by_id[job_id]
 
+    def _get_creation_response_interpolation_context(self, job: AsyncJob) -> Dict[str, Any]:
+        """
+        Returns the interpolation context for the creation response.
+
+        Args:
+            job (AsyncJob): The job for which to get the creation response interpolation context.
+
+        Returns:
+            Dict[str, Any]: The interpolation context as a dictionary.
+        """
+        # TODO: currently we support only JsonDecoder to decode the response to track the ids or the status
+        # of the Jobs. We should consider to add the support of other decoders like XMLDecoder, in the future
+        creation_response_context = dict(self._create_job_response_by_id[job.api_job_id()].json())
+        if not "headers" in creation_response_context:
+            creation_response_context["headers"] = self._create_job_response_by_id[
+                job.api_job_id()
+            ].headers
+        if not "request" in creation_response_context:
+            creation_response_context["request"] = self._create_job_response_by_id[
+                job.api_job_id()
+            ].request
+        return creation_response_context
+
+    def _get_polling_response_interpolation_context(self, job: AsyncJob) -> Dict[str, Any]:
+        """
+        Returns the interpolation context for the polling response.
+
+        Args:
+            job (AsyncJob): The job for which to get the polling response interpolation context.
+
+        Returns:
+            Dict[str, Any]: The interpolation context as a dictionary.
+        """
+        # TODO: currently we support only JsonDecoder to decode the response to track the ids or the status
+        # of the Jobs. We should consider to add the support of other decoders like XMLDecoder, in the future
+        polling_response_context = dict(self._polling_job_response_by_id[job.api_job_id()].json())
+        if not "headers" in polling_response_context:
+            polling_response_context["headers"] = self._polling_job_response_by_id[
+                job.api_job_id()
+            ].headers
+        if not "request" in polling_response_context:
+            polling_response_context["request"] = self._polling_job_response_by_id[
+                job.api_job_id()
+            ].request
+        return polling_response_context
+
     def _get_create_job_stream_slice(self, job: AsyncJob) -> StreamSlice:
-        creation_response = self._create_job_response_by_id[job.api_job_id()].json()
         stream_slice = StreamSlice(
             partition={},
             cursor_slice={},
-            extra_fields={"creation_response": creation_response},
+            extra_fields={
+                "creation_response": self._get_creation_response_interpolation_context(job),
+            },
         )
         return stream_slice
 
@@ -284,11 +333,12 @@ class AsyncHttpJobRepository(AsyncJobRepository):
         if not self.download_target_requester:
             url_response = self._polling_job_response_by_id[job.api_job_id()]
         else:
-            polling_response = self._polling_job_response_by_id[job.api_job_id()].json()
             stream_slice: StreamSlice = StreamSlice(
                 partition={},
                 cursor_slice={},
-                extra_fields={"polling_response": polling_response},
+                extra_fields={
+                    "polling_response": self._get_polling_response_interpolation_context(job),
+                },
             )
             url_response = self.download_target_requester.send_request(stream_slice=stream_slice)  # type: ignore # we expect download_target_requester to always be presented, otherwise raise an exception as we cannot proceed with the report
             if not url_response:

{airbyte_cdk-6.41.2.dev0 → airbyte_cdk-6.41.4}/airbyte_cdk/sources/declarative/retrievers/async_retriever.py

@@ -4,24 +4,17 @@
 from dataclasses import InitVar, dataclass, field
 from typing import Any, Iterable, Mapping, Optional
 
-from typing_extensions import deprecated
-
 from airbyte_cdk.sources.declarative.async_job.job import AsyncJob
 from airbyte_cdk.sources.declarative.extractors.record_selector import RecordSelector
 from airbyte_cdk.sources.declarative.partition_routers.async_job_partition_router import (
     AsyncJobPartitionRouter,
 )
 from airbyte_cdk.sources.declarative.retrievers.retriever import Retriever
-from airbyte_cdk.sources.source import ExperimentalClassWarning
 from airbyte_cdk.sources.streams.core import StreamData
 from airbyte_cdk.sources.types import Config, StreamSlice, StreamState
 from airbyte_cdk.sources.utils.slice_logger import AlwaysLogSliceLogger
 
 
-@deprecated(
-    "This class is experimental. Use at your own risk.",
-    category=ExperimentalClassWarning,
-)
 @dataclass
 class AsyncRetriever(Retriever):
     config: Config

{airbyte_cdk-6.41.2.dev0 → airbyte_cdk-6.41.4}/airbyte_cdk/test/mock_http/mocker.py

@@ -2,9 +2,10 @@
 
 import contextlib
 import functools
+from collections import defaultdict
 from enum import Enum
 from types import TracebackType
-from typing import Callable, List, Optional, Union
+from typing import Callable, Dict, Iterable, List, Optional, Union
 
 import requests_mock
 
@@ -40,7 +41,7 @@ class HttpMocker(contextlib.ContextDecorator):
 
     def __init__(self) -> None:
         self._mocker = requests_mock.Mocker()
-        self._matchers: List[HttpRequestMatcher] = []
+        self._matchers: Dict[SupportedHttpMethods, List[HttpRequestMatcher]] = defaultdict(list)
 
     def __enter__(self) -> "HttpMocker":
         self._mocker.__enter__()
@@ -55,7 +56,7 @@ class HttpMocker(contextlib.ContextDecorator):
         self._mocker.__exit__(exc_type, exc_val, exc_tb)
 
     def _validate_all_matchers_called(self) -> None:
-        for matcher in self._matchers:
+        for matcher in self._get_matchers():
             if not matcher.has_expected_match_count():
                 raise ValueError(f"Invalid number of matches for `{matcher}`")
 
@@ -69,9 +70,9 @@ class HttpMocker(contextlib.ContextDecorator):
             responses = [responses]
 
         matcher = HttpRequestMatcher(request, len(responses))
-        if matcher in self._matchers:
+        if matcher in self._matchers[method]:
             raise ValueError(f"Request {matcher.request} already mocked")
-        self._matchers.append(matcher)
+        self._matchers[method].append(matcher)
 
         getattr(self._mocker, method)(
             requests_mock.ANY,
@@ -129,7 +130,7 @@ class HttpMocker(contextlib.ContextDecorator):
 
     def assert_number_of_calls(self, request: HttpRequest, number_of_calls: int) -> None:
         corresponding_matchers = list(
-            filter(lambda matcher: matcher.request == request, self._matchers)
+            filter(lambda matcher: matcher.request is request, self._get_matchers())
         )
         if len(corresponding_matchers) != 1:
             raise ValueError(
@@ -150,7 +151,7 @@ class HttpMocker(contextlib.ContextDecorator):
                     result = f(*args, **kwargs)
                 except requests_mock.NoMockAddress as no_mock_exception:
                     matchers_as_string = "\n\t".join(
-                        map(lambda matcher: str(matcher.request), self._matchers)
+                        map(lambda matcher: str(matcher.request), self._get_matchers())
                     )
                     raise ValueError(
                         f"No matcher matches {no_mock_exception.args[0]} with headers `{no_mock_exception.request.headers}` "
@@ -175,6 +176,10 @@ class HttpMocker(contextlib.ContextDecorator):
 
         return wrapper
 
+    def _get_matchers(self) -> Iterable[HttpRequestMatcher]:
+        for matchers in self._matchers.values():
+            yield from matchers
+
     def clear_all_matchers(self) -> None:
         """Clears all stored matchers by resetting the _matchers list to an empty state."""
-        self._matchers = []
+        self._matchers = defaultdict(list)

{airbyte_cdk-6.41.2.dev0 → airbyte_cdk-6.41.4}/pyproject.toml

@@ -23,7 +23,7 @@ classifiers = [
 keywords = ["airbyte", "connector-development-kit", "cdk"]
 
 # Python CDK uses dynamic versioning: https://github.com/mtkennerly/poetry-dynamic-versioning
-version = "6.41.2dev0"  # Version will be calculated dynamically.
+version = "6.41.4"  # Version will be calculated dynamically.
 
 [tool.poetry-dynamic-versioning]
 enable = false