airbyte-cdk 6.36.0__tar.gz → 6.36.0.dev0__tar.gz

{airbyte_cdk-6.36.0 → airbyte_cdk-6.36.0.dev0}/PKG-INFO

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

{airbyte_cdk-6.36.0 → airbyte_cdk-6.36.0.dev0}/airbyte_cdk/sources/declarative/concurrent_declarative_source.py

@@ -24,6 +24,7 @@ from airbyte_cdk.sources.declarative.incremental.datetime_based_cursor import Da
 from airbyte_cdk.sources.declarative.incremental.per_partition_with_global import (
     PerPartitionWithGlobalCursor,
 )
+from airbyte_cdk.sources.declarative.interpolation import InterpolatedString
 from airbyte_cdk.sources.declarative.manifest_declarative_source import ManifestDeclarativeSource
 from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
     ConcurrencyLevel as ConcurrencyLevelModel,
@@ -35,16 +36,17 @@ from airbyte_cdk.sources.declarative.parsers.model_to_component_factory import (
     ModelToComponentFactory,
 )
 from airbyte_cdk.sources.declarative.partition_routers import AsyncJobPartitionRouter
+from airbyte_cdk.sources.declarative.requesters import HttpRequester
 from airbyte_cdk.sources.declarative.retrievers import AsyncRetriever, Retriever, SimpleRetriever
 from airbyte_cdk.sources.declarative.stream_slicers.declarative_partition_generator import (
     DeclarativePartitionFactory,
     StreamSlicerPartitionGenerator,
 )
+from airbyte_cdk.sources.declarative.transformations.add_fields import AddFields
 from airbyte_cdk.sources.declarative.types import ConnectionDefinition
 from airbyte_cdk.sources.source import TState
 from airbyte_cdk.sources.streams import Stream
 from airbyte_cdk.sources.streams.concurrent.abstract_stream import AbstractStream
-from airbyte_cdk.sources.streams.concurrent.abstract_stream_facade import AbstractStreamFacade
 from airbyte_cdk.sources.streams.concurrent.availability_strategy import (
     AlwaysAvailableAvailabilityStrategy,
 )
@@ -119,12 +121,6 @@ class ConcurrentDeclarativeSource(ManifestDeclarativeSource, Generic[TState]):
             message_repository=self.message_repository,
         )
 
-    # TODO: Remove this. This property is necessary to safely migrate Stripe during the transition state.
-    @property
-    def is_partially_declarative(self) -> bool:
-        """This flag used to avoid unexpected AbstractStreamFacade processing as concurrent streams."""
-        return False
-
     def read(
         self,
         logger: logging.Logger,
@@ -325,6 +321,9 @@ class ConcurrentDeclarativeSource(ManifestDeclarativeSource, Generic[TState]):
                     incremental_sync_component_definition
                     and incremental_sync_component_definition.get("type", "")
                     == DatetimeBasedCursorModel.__name__
+                    and self._stream_supports_concurrent_partition_processing(
+                        declarative_stream=declarative_stream
+                    )
                     and hasattr(declarative_stream.retriever, "stream_slicer")
                     and isinstance(
                         declarative_stream.retriever.stream_slicer, PerPartitionWithGlobalCursor
@@ -376,14 +375,6 @@ class ConcurrentDeclarativeSource(ManifestDeclarativeSource, Generic[TState]):
                     )
                 else:
                     synchronous_streams.append(declarative_stream)
-            # TODO: Remove this. This check is necessary to safely migrate Stripe during the transition state.
-            # Condition below needs to ensure that concurrent support is not lost for sources that already support
-            # it before migration, but now are only partially migrated to declarative implementation (e.g., Stripe).
-            elif (
-                isinstance(declarative_stream, AbstractStreamFacade)
-                and self.is_partially_declarative
-            ):
-                concurrent_streams.append(declarative_stream.get_underlying_stream())
             else:
                 synchronous_streams.append(declarative_stream)
 
@@ -399,6 +390,9 @@ class ConcurrentDeclarativeSource(ManifestDeclarativeSource, Generic[TState]):
             and bool(incremental_sync_component_definition)
             and incremental_sync_component_definition.get("type", "")
             == DatetimeBasedCursorModel.__name__
+            and self._stream_supports_concurrent_partition_processing(
+                declarative_stream=declarative_stream
+            )
             and hasattr(declarative_stream.retriever, "stream_slicer")
             and (
                 isinstance(declarative_stream.retriever.stream_slicer, DatetimeBasedCursor)
@@ -406,6 +400,72 @@ class ConcurrentDeclarativeSource(ManifestDeclarativeSource, Generic[TState]):
             )
         )
 
+    def _stream_supports_concurrent_partition_processing(
+        self, declarative_stream: DeclarativeStream
+    ) -> bool:
+        """
+        Many connectors make use of stream_state during interpolation on a per-partition basis under the assumption that
+        state is updated sequentially. Because the concurrent CDK engine processes different partitions in parallel,
+        stream_state is no longer a thread-safe interpolation context. It would be a race condition because a cursor's
+        stream_state can be updated in any order depending on which stream partition's finish first.
+
+        We should start to move away from depending on the value of stream_state for low-code components that operate
+        per-partition, but we need to gate this otherwise some connectors will be blocked from publishing. See the
+        cdk-migrations.md for the full list of connectors.
+        """
+
+        if isinstance(declarative_stream.retriever, SimpleRetriever) and isinstance(
+            declarative_stream.retriever.requester, HttpRequester
+        ):
+            http_requester = declarative_stream.retriever.requester
+            if "stream_state" in http_requester._path.string:
+                self.logger.warning(
+                    f"Low-code stream '{declarative_stream.name}' uses interpolation of stream_state in the HttpRequester which is not thread-safe. Defaulting to synchronous processing"
+                )
+                return False
+
+            request_options_provider = http_requester._request_options_provider
+            if request_options_provider.request_options_contain_stream_state():
+                self.logger.warning(
+                    f"Low-code stream '{declarative_stream.name}' uses interpolation of stream_state in the HttpRequester which is not thread-safe. Defaulting to synchronous processing"
+                )
+                return False
+
+            record_selector = declarative_stream.retriever.record_selector
+            if isinstance(record_selector, RecordSelector):
+                if (
+                    record_selector.record_filter
+                    and not isinstance(
+                        record_selector.record_filter, ClientSideIncrementalRecordFilterDecorator
+                    )
+                    and "stream_state" in record_selector.record_filter.condition
+                ):
+                    self.logger.warning(
+                        f"Low-code stream '{declarative_stream.name}' uses interpolation of stream_state in the RecordFilter which is not thread-safe. Defaulting to synchronous processing"
+                    )
+                    return False
+
+                for add_fields in [
+                    transformation
+                    for transformation in record_selector.transformations
+                    if isinstance(transformation, AddFields)
+                ]:
+                    for field in add_fields.fields:
+                        if isinstance(field.value, str) and "stream_state" in field.value:
+                            self.logger.warning(
+                                f"Low-code stream '{declarative_stream.name}' uses interpolation of stream_state in the AddFields which is not thread-safe. Defaulting to synchronous processing"
+                            )
+                            return False
+                        if (
+                            isinstance(field.value, InterpolatedString)
+                            and "stream_state" in field.value.string
+                        ):
+                            self.logger.warning(
+                                f"Low-code stream '{declarative_stream.name}' uses interpolation of stream_state in the AddFields which is not thread-safe. Defaulting to synchronous processing"
+                            )
+                            return False
+        return True
+
     @staticmethod
     def _get_retriever(
         declarative_stream: DeclarativeStream, stream_state: Mapping[str, Any]

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

@@ -82,6 +82,7 @@ definitions:
           - stream_interval
           - stream_partition
           - stream_slice
+          - stream_state
         examples:
           - "{{ record['updates'] }}"
           - "{{ record['MetaData']['LastUpdatedTime'] }}"
@@ -1490,11 +1491,7 @@ definitions:
       limit:
         title: Limit
         description: The maximum number of calls allowed within the interval.
-        anyOf:
-          - type: integer
-          - type: string
-        interpolation_context:
-          - config
+        type: integer
       interval:
         title: Interval
         description: The time interval for the rate limit.
@@ -1779,6 +1776,7 @@ definitions:
           - stream_interval
           - stream_partition
           - stream_slice
+          - stream_state
         examples:
           - "/products"
           - "/quotes/{{ stream_partition['id'] }}/quote_line_groups"
@@ -1828,6 +1826,7 @@ definitions:
           - stream_interval
           - stream_partition
           - stream_slice
+          - stream_state
         examples:
           - |
             [{"clause": {"type": "timestamp", "operator": 10, "parameters":
@@ -1845,6 +1844,7 @@ definitions:
           - stream_interval
           - stream_partition
           - stream_slice
+          - stream_state
         examples:
           - sort_order: "ASC"
             sort_field: "CREATED_AT"
@@ -1865,6 +1865,7 @@ definitions:
           - stream_interval
           - stream_partition
           - stream_slice
+          - stream_state
         examples:
           - Output-Format: JSON
           - Version: "{{ config['version'] }}"
@@ -1881,6 +1882,7 @@ definitions:
           - stream_interval
           - stream_partition
           - stream_slice
+          - stream_state
         examples:
           - unit: "day"
           - query: 'last_event_time BETWEEN TIMESTAMP "{{ stream_interval.start_time }}" AND TIMESTAMP "{{ stream_interval.end_time }}"'
@@ -2235,6 +2237,7 @@ definitions:
         interpolation_context:
           - config
           - record
+          - stream_state
           - stream_slice
       new:
         type: string
@@ -2248,6 +2251,7 @@ definitions:
         interpolation_context:
           - config
           - record
+          - stream_state
           - stream_slice
       $parameters:
         type: object
@@ -2897,6 +2901,7 @@ definitions:
           - stream_interval
           - stream_partition
           - stream_slice
+          - stream_state
         examples:
           - "{{ record['created_at'] >= stream_interval['start_time'] }}"
           - "{{ record.status in ['active', 'expired'] }}"
@@ -3684,6 +3689,12 @@ interpolation:
     - title: stream_slice
       description: This variable is deprecated. Use stream_interval or stream_partition instead.
       type: object
+    - title: stream_state
+      description: The current state of the stream. The object's keys are defined by the incremental sync's cursor_field the and partition router's values.
+      type: object
+      examples:
+        - created_at: "2020-01-01 00:00:00.000+00:00"
+        - updated_at: "2020-01-02 00:00:00.000+00:00"
   macros:
     - title: now_utc
       description: Returns the current date and time in the UTC timezone.
@@ -3748,16 +3759,6 @@ interpolation:
         - "{{ format_datetime(config['start_time'], '%Y-%m-%d') }}"
         - "{{ format_datetime(config['start_date'], '%Y-%m-%dT%H:%M:%S.%fZ') }}"
         - "{{ format_datetime(config['start_date'], '%Y-%m-%dT%H:%M:%S.%fZ', '%a, %d %b %Y %H:%M:%S %z') }}"
-    - title: str_to_datetime
-      description: Converts a string to a datetime object with UTC timezone.
-      arguments:
-        s: The string to convert.
-      return_type: datetime.datetime
-      examples:
-        - "{{ str_to_datetime('2022-01-14') }}"
-        - "{{ str_to_datetime('2022-01-01 13:45:30') }}"
-        - "{{ str_to_datetime('2022-01-01T13:45:30+00:00') }}"
-        - "{{ str_to_datetime('2022-01-01T13:45:30.123456Z') }}"
   filters:
     - title: hash
       description: Convert the specified value to a hashed string.

{airbyte_cdk-6.36.0 → airbyte_cdk-6.36.0.dev0}/airbyte_cdk/sources/declarative/decoders/composite_raw_decoder.py

@@ -107,16 +107,6 @@ class CsvParser(Parser):
     encoding: Optional[str] = "utf-8"
     delimiter: Optional[str] = ","
 
-    def _get_delimiter(self) -> Optional[str]:
-        """
-        Get delimiter from the configuration. Check for the escape character and decode it.
-        """
-        if self.delimiter is not None:
-            if self.delimiter.startswith("\\"):
-                self.delimiter = self.delimiter.encode("utf-8").decode("unicode_escape")
-
-        return self.delimiter
-
     def parse(
         self,
         data: BufferedIOBase,
@@ -125,7 +115,7 @@ class CsvParser(Parser):
         Parse CSV data from decompressed bytes.
         """
         text_data = TextIOWrapper(data, encoding=self.encoding)  # type: ignore
-        reader = csv.DictReader(text_data, delimiter=self._get_delimiter() or ",")
+        reader = csv.DictReader(text_data, delimiter=self.delimiter or ",")
         yield from reader
 
 

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

@@ -95,6 +95,10 @@ class ConcurrentPerPartitionCursor(Cursor):
         # the oldest partitions can be efficiently removed, maintaining the most recent partitions.
         self._cursor_per_partition: OrderedDict[str, ConcurrentCursor] = OrderedDict()
         self._semaphore_per_partition: OrderedDict[str, threading.Semaphore] = OrderedDict()
+
+        # Parent-state tracking: store each partition’s parent state in creation order
+        self._partition_parent_state_map: OrderedDict[str, Mapping[str, Any]] = OrderedDict()
+
         self._finished_partitions: set[str] = set()
         self._lock = threading.Lock()
         self._timer = Timer()
@@ -155,11 +159,62 @@ class ConcurrentPerPartitionCursor(Cursor):
                     and self._semaphore_per_partition[partition_key]._value == 0
                 ):
                     self._update_global_cursor(cursor.state[self.cursor_field.cursor_field_key])
-                self._emit_state_message()
+
+            self._check_and_update_parent_state()
+
+            self._emit_state_message()
+
+    def _check_and_update_parent_state(self) -> None:
+        """
+        Pop the leftmost partition state from _partition_parent_state_map only if
+        *all partitions* up to (and including) that partition key in _semaphore_per_partition
+        are fully finished (i.e. in _finished_partitions and semaphore._value == 0).
+        Additionally, delete finished semaphores with a value of 0 to free up memory,
+        as they are only needed to track errors and completion status.
+        """
+        last_closed_state = None
+
+        while self._partition_parent_state_map:
+            # Look at the earliest partition key in creation order
+            earliest_key = next(iter(self._partition_parent_state_map))
+
+            # Verify ALL partitions from the left up to earliest_key are finished
+            all_left_finished = True
+            for p_key, sem in list(
+                self._semaphore_per_partition.items()
+            ):  # Use list to allow modification during iteration
+                # If any earlier partition is still not finished, we must stop
+                if p_key not in self._finished_partitions or sem._value != 0:
+                    all_left_finished = False
+                    break
+                # Once we've reached earliest_key in the semaphore order, we can stop checking
+                if p_key == earliest_key:
+                    break
+
+            # If the partitions up to earliest_key are not all finished, break the while-loop
+            if not all_left_finished:
+                break
+
+            # Pop the leftmost entry from parent-state map
+            _, closed_parent_state = self._partition_parent_state_map.popitem(last=False)
+            last_closed_state = closed_parent_state
+
+            # Clean up finished semaphores with value 0 up to and including earliest_key
+            for p_key in list(self._semaphore_per_partition.keys()):
+                sem = self._semaphore_per_partition[p_key]
+                if p_key in self._finished_partitions and sem._value == 0:
+                    del self._semaphore_per_partition[p_key]
+                    logger.debug(f"Deleted finished semaphore for partition {p_key} with value 0")
+                if p_key == earliest_key:
+                    break
+
+        # Update _parent_state if we popped at least one partition
+        if last_closed_state is not None:
+            self._parent_state = last_closed_state
 
     def ensure_at_least_one_state_emitted(self) -> None:
         """
-        The platform expect to have at least one state message on successful syncs. Hence, whatever happens, we expect this method to be
+        The platform expects at least one state message on successful syncs. Hence, whatever happens, we expect this method to be
         called.
         """
         if not any(
@@ -196,18 +251,25 @@ class ConcurrentPerPartitionCursor(Cursor):
         self._message_repository.emit_message(state_message)
 
     def stream_slices(self) -> Iterable[StreamSlice]:
+        print("stream_slices")
         if self._timer.is_running():
             raise RuntimeError("stream_slices has been executed more than once.")
 
         slices = self._partition_router.stream_slices()
         self._timer.start()
-        for partition in slices:
-            yield from self._generate_slices_from_partition(partition)
+        for partition, last, parent_state in iterate_with_last_flag_and_state(
+            slices, self._partition_router.get_stream_state
+        ):
+            yield from self._generate_slices_from_partition(partition, parent_state)
 
-    def _generate_slices_from_partition(self, partition: StreamSlice) -> Iterable[StreamSlice]:
+    def _generate_slices_from_partition(
+        self, partition: StreamSlice, parent_state: Mapping[str, Any]
+    ) -> Iterable[StreamSlice]:
         # Ensure the maximum number of partitions is not exceeded
         self._ensure_partition_limit()
 
+        partition_key = self._to_partition_key(partition.partition)
+
         cursor = self._cursor_per_partition.get(self._to_partition_key(partition.partition))
         if not cursor:
             cursor = self._create_cursor(
@@ -216,18 +278,26 @@ class ConcurrentPerPartitionCursor(Cursor):
             )
             with self._lock:
                 self._number_of_partitions += 1
-                self._cursor_per_partition[self._to_partition_key(partition.partition)] = cursor
-            self._semaphore_per_partition[self._to_partition_key(partition.partition)] = (
-                threading.Semaphore(0)
-            )
+                self._cursor_per_partition[partition_key] = cursor
+        self._semaphore_per_partition[partition_key] = threading.Semaphore(0)
+
+        with self._lock:
+            if (
+                len(self._partition_parent_state_map) == 0
+                or self._partition_parent_state_map[
+                    next(reversed(self._partition_parent_state_map))
+                ]
+                != parent_state
+            ):
+                self._partition_parent_state_map[partition_key] = deepcopy(parent_state)
 
         for cursor_slice, is_last_slice, _ in iterate_with_last_flag_and_state(
             cursor.stream_slices(),
             lambda: None,
         ):
-            self._semaphore_per_partition[self._to_partition_key(partition.partition)].release()
+            self._semaphore_per_partition[partition_key].release()
             if is_last_slice:
-                self._finished_partitions.add(self._to_partition_key(partition.partition))
+                self._finished_partitions.add(partition_key)
             yield StreamSlice(
                 partition=partition, cursor_slice=cursor_slice, extra_fields=partition.extra_fields
             )
@@ -257,9 +327,9 @@ class ConcurrentPerPartitionCursor(Cursor):
             while len(self._cursor_per_partition) > self.DEFAULT_MAX_PARTITIONS_NUMBER - 1:
                 # Try removing finished partitions first
                 for partition_key in list(self._cursor_per_partition.keys()):
-                    if (
-                        partition_key in self._finished_partitions
-                        and self._semaphore_per_partition[partition_key]._value == 0
+                    if partition_key in self._finished_partitions and (
+                        partition_key not in self._semaphore_per_partition
+                        or self._semaphore_per_partition[partition_key]._value == 0
                     ):
                         oldest_partition = self._cursor_per_partition.pop(
                             partition_key
@@ -338,9 +408,6 @@ class ConcurrentPerPartitionCursor(Cursor):
                 self._cursor_per_partition[self._to_partition_key(state["partition"])] = (
                     self._create_cursor(state["cursor"])
                 )
-                self._semaphore_per_partition[self._to_partition_key(state["partition"])] = (
-                    threading.Semaphore(0)
-                )
 
             # set default state for missing partitions if it is per partition with fallback to global
             if self._GLOBAL_STATE_KEY in stream_state:

{airbyte_cdk-6.36.0 → airbyte_cdk-6.36.0.dev0}/airbyte_cdk/sources/declarative/incremental/global_substream_cursor.py

@@ -115,9 +115,7 @@ class GlobalSubstreamCursor(DeclarativeCursor):
         * Yield the last slice. At that point, once there are as many slices yielded as closes, the global slice will be closed too
         """
         slice_generator = (
-            StreamSlice(
-                partition=partition, cursor_slice=cursor_slice, extra_fields=partition.extra_fields
-            )
+            StreamSlice(partition=partition, cursor_slice=cursor_slice)
             for partition in self._partition_router.stream_slices()
             for cursor_slice in self._stream_cursor.stream_slices()
         )
@@ -133,9 +131,7 @@ class GlobalSubstreamCursor(DeclarativeCursor):
 
     def generate_slices_from_partition(self, partition: StreamSlice) -> Iterable[StreamSlice]:
         slice_generator = (
-            StreamSlice(
-                partition=partition, cursor_slice=cursor_slice, extra_fields=partition.extra_fields
-            )
+            StreamSlice(partition=partition, cursor_slice=cursor_slice)
             for cursor_slice in self._stream_cursor.stream_slices()
         )
 

{airbyte_cdk-6.36.0 → airbyte_cdk-6.36.0.dev0}/airbyte_cdk/sources/declarative/interpolation/__init__.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2025 Airbyte, Inc., all rights reserved.
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
 #
 
 from airbyte_cdk.sources.declarative.interpolation.interpolated_boolean import InterpolatedBoolean

{airbyte_cdk-6.36.0 → airbyte_cdk-6.36.0.dev0}/airbyte_cdk/sources/declarative/interpolation/filters.py

@@ -1,7 +1,6 @@
 #
-# Copyright (c) 2025 Airbyte, Inc., all rights reserved.
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
 #
-
 import base64
 import hashlib
 import json

{airbyte_cdk-6.36.0 → airbyte_cdk-6.36.0.dev0}/airbyte_cdk/sources/declarative/interpolation/interpolated_boolean.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2025 Airbyte, Inc., all rights reserved.
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
 #
 
 from dataclasses import InitVar, dataclass

{airbyte_cdk-6.36.0 → airbyte_cdk-6.36.0.dev0}/airbyte_cdk/sources/declarative/interpolation/interpolated_mapping.py

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

{airbyte_cdk-6.36.0 → airbyte_cdk-6.36.0.dev0}/airbyte_cdk/sources/declarative/interpolation/interpolated_nested_mapping.py

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

{airbyte_cdk-6.36.0 → airbyte_cdk-6.36.0.dev0}/airbyte_cdk/sources/declarative/interpolation/interpolated_string.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2025 Airbyte, Inc., all rights reserved.
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
 #
 
 from dataclasses import InitVar, dataclass

{airbyte_cdk-6.36.0 → airbyte_cdk-6.36.0.dev0}/airbyte_cdk/sources/declarative/interpolation/interpolation.py

@@ -1,8 +1,7 @@
 #
-# Copyright (c) 2025 Airbyte, Inc., all rights reserved.
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
 #
 
-
 from abc import ABC, abstractmethod
 from typing import Any, Optional
 

{airbyte_cdk-6.36.0 → airbyte_cdk-6.36.0.dev0}/airbyte_cdk/sources/declarative/interpolation/jinja.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2025 Airbyte, Inc., all rights reserved.
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
 #
 
 import ast
@@ -11,12 +11,10 @@ from jinja2.environment import Template
 from jinja2.exceptions import UndefinedError
 from jinja2.sandbox import SandboxedEnvironment
 
-from airbyte_cdk.models import FailureType
 from airbyte_cdk.sources.declarative.interpolation.filters import filters
 from airbyte_cdk.sources.declarative.interpolation.interpolation import Interpolation
 from airbyte_cdk.sources.declarative.interpolation.macros import macros
 from airbyte_cdk.sources.types import Config
-from airbyte_cdk.utils import AirbyteTracedException
 
 
 class StreamPartitionAccessEnvironment(SandboxedEnvironment):
@@ -38,10 +36,6 @@ _ALIASES = {
     "stream_partition": "stream_slice",  # Use stream_partition to access partition router's values
 }
 
-_UNSUPPORTED_INTERPOLATION_VARIABLES: Mapping[str, str] = {
-    "stream_state": "`stream_state` is no longer supported for interpolation. We recommend using `stream_interval` instead. Please reference the CDK Migration Guide for more information.",
-}
-
 # These extensions are not installed so they're not currently a problem,
 # but we're still explicitly removing them from the jinja context.
 # At worst, this is documentation that we do NOT want to include these extensions because of the potential security risks
@@ -101,13 +95,6 @@ class JinjaInterpolation(Interpolation):
             elif equivalent in context:
                 context[alias] = context[equivalent]
 
-        for variable_name in _UNSUPPORTED_INTERPOLATION_VARIABLES:
-            if variable_name in input_str:
-                raise AirbyteTracedException(
-                    message=_UNSUPPORTED_INTERPOLATION_VARIABLES[variable_name],
-                    internal_message=_UNSUPPORTED_INTERPOLATION_VARIABLES[variable_name],
-                    failure_type=FailureType.config_error,
-                )
         try:
             if isinstance(input_str, str):
                 result = self._eval(input_str, context)

{airbyte_cdk-6.36.0 → airbyte_cdk-6.36.0.dev0}/airbyte_cdk/sources/declarative/interpolation/macros.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2025 Airbyte, Inc., all rights reserved.
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
 #
 
 import builtins
@@ -63,24 +63,10 @@ def timestamp(dt: Union[float, str]) -> Union[int, float]:
     if isinstance(dt, (int, float)):
         return int(dt)
     else:
-        return str_to_datetime(dt).astimezone(pytz.utc).timestamp()
+        return _str_to_datetime(dt).astimezone(pytz.utc).timestamp()
 
 
-def str_to_datetime(s: str) -> datetime.datetime:
-    """
-    Converts a string to a datetime object with UTC timezone
-
-    If the input string does not contain timezone information, UTC is assumed.
-    Supports both basic date strings like "2022-01-14" and datetime strings with optional timezone
-    like "2022-01-01T13:45:30+00:00".
-
-    Usage:
-    `"{{ str_to_datetime('2022-01-14') }}"`
-
-    :param s: string to parse as datetime
-    :return: datetime object in UTC timezone
-    """
-
+def _str_to_datetime(s: str) -> datetime.datetime:
     parsed_date = parser.isoparse(s)
     if not parsed_date.tzinfo:
         # Assume UTC if the input does not contain a timezone
@@ -169,7 +155,7 @@ def format_datetime(
     if isinstance(dt, datetime.datetime):
         return dt.strftime(format)
     dt_datetime = (
-        datetime.datetime.strptime(dt, input_format) if input_format else str_to_datetime(dt)
+        datetime.datetime.strptime(dt, input_format) if input_format else _str_to_datetime(dt)
     )
     if format == "%s":
         return str(int(dt_datetime.timestamp()))
@@ -186,6 +172,5 @@ _macros_list = [
     duration,
     format_datetime,
     today_with_timezone,
-    str_to_datetime,
 ]
 macros = {f.__name__: f for f in _macros_list}

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

@@ -646,7 +646,7 @@ class Rate(BaseModel):
     class Config:
         extra = Extra.allow
 
-    limit: Union[int, str] = Field(
+    limit: int = Field(
         ...,
         description="The maximum number of calls allowed within the interval.",
         title="Limit",

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

@@ -3024,9 +3024,8 @@ class ModelToComponentFactory:
         )
 
     def create_rate(self, model: RateModel, config: Config, **kwargs: Any) -> Rate:
-        interpolated_limit = InterpolatedString.create(str(model.limit), parameters={})
         return Rate(
-            limit=int(interpolated_limit.eval(config=config)),
+            limit=model.limit,
             interval=parse_duration(model.interval),
         )
 

{airbyte_cdk-6.36.0 → airbyte_cdk-6.36.0.dev0}/airbyte_cdk/sources/declarative/requesters/http_requester.py

@@ -123,6 +123,7 @@ class HttpRequester(Requester):
         next_page_token: Optional[Mapping[str, Any]],
     ) -> str:
         kwargs = {
+            "stream_state": stream_state,
             "stream_slice": stream_slice,
             "next_page_token": next_page_token,
         }