airbyte-cdk 6.60.10__py3-none-any.whl → 6.60.11__py3-none-any.whl

airbyte_cdk/sources/declarative/checks/check_dynamic_stream.py

@@ -3,12 +3,13 @@
 #
 
 import logging
-import traceback
 from dataclasses import InitVar, dataclass
-from typing import Any, List, Mapping, Tuple
+from typing import Any, List, Mapping, Tuple, Union
 
-from airbyte_cdk import AbstractSource
+from airbyte_cdk.sources.abstract_source import AbstractSource
+from airbyte_cdk.sources.declarative.checks.check_stream import evaluate_availability
 from airbyte_cdk.sources.declarative.checks.connection_checker import ConnectionChecker
+from airbyte_cdk.sources.streams.concurrent.abstract_stream import AbstractStream
 from airbyte_cdk.sources.streams.http.availability_strategy import HttpAvailabilityStrategy
 
 
@@ -34,20 +35,16 @@ class CheckDynamicStream(ConnectionChecker):
     def check_connection(
         self, source: AbstractSource, logger: logging.Logger, config: Mapping[str, Any]
     ) -> Tuple[bool, Any]:
-        streams = source.streams(config=config)
+        streams: List[Union[Stream, AbstractStream]] = source.streams(config=config)  # type: ignore  # this is a migration step and we expect the declarative CDK to migrate off of ConnectionChecker
 
         if len(streams) == 0:
             return False, f"No streams to connect to from source {source}"
         if not self.use_check_availability:
             return True, None
 
-        availability_strategy = HttpAvailabilityStrategy()
-
         try:
             for stream in streams[: min(self.stream_count, len(streams))]:
-                stream_is_available, reason = availability_strategy.check_availability(
-                    stream, logger
-                )
+                stream_is_available, reason = evaluate_availability(stream, logger)
                 if not stream_is_available:
                     logger.warning(f"Stream {stream.name} is not available: {reason}")
                     return False, reason

airbyte_cdk/sources/declarative/checks/check_stream.py

@@ -5,13 +5,30 @@
 import logging
 import traceback
 from dataclasses import InitVar, dataclass
-from typing import Any, Dict, List, Mapping, Optional, Tuple
+from typing import Any, Dict, List, Mapping, Optional, Tuple, Union
 
-from airbyte_cdk import AbstractSource
+from airbyte_cdk.sources.abstract_source import AbstractSource
 from airbyte_cdk.sources.declarative.checks.connection_checker import ConnectionChecker
+from airbyte_cdk.sources.streams.concurrent.abstract_stream import AbstractStream
+from airbyte_cdk.sources.streams.core import Stream
 from airbyte_cdk.sources.streams.http.availability_strategy import HttpAvailabilityStrategy
 
 
+def evaluate_availability(
+    stream: Union[Stream, AbstractStream], logger: logging.Logger
+) -> Tuple[bool, Optional[str]]:
+    """
+    As a transition period, we want to support both Stream and AbstractStream until we migrate everything to AbstractStream.
+    """
+    if isinstance(stream, Stream):
+        return HttpAvailabilityStrategy().check_availability(stream, logger)
+    elif isinstance(stream, AbstractStream):
+        availability = stream.check_availability()
+        return availability.is_available, availability.reason
+    else:
+        raise ValueError(f"Unsupported stream type {type(stream)}")
+
+
 @dataclass(frozen=True)
 class DynamicStreamCheckConfig:
     """Defines the configuration for dynamic stream during connection checking. This class specifies
@@ -51,7 +68,7 @@ class CheckStream(ConnectionChecker):
     ) -> Tuple[bool, Any]:
         """Checks the connection to the source and its streams."""
         try:
-            streams = source.streams(config=config)
+            streams: List[Union[Stream, AbstractStream]] = source.streams(config=config)  # type: ignore  # this is a migration step and we expect the declarative CDK to migrate off of ConnectionChecker
             if not streams:
                 return False, f"No streams to connect to from source {source}"
         except Exception as error:
@@ -82,13 +99,15 @@ class CheckStream(ConnectionChecker):
         return True, None
 
     def _check_stream_availability(
-        self, stream_name_to_stream: Dict[str, Any], stream_name: str, logger: logging.Logger
+        self,
+        stream_name_to_stream: Dict[str, Union[Stream, AbstractStream]],
+        stream_name: str,
+        logger: logging.Logger,
     ) -> Tuple[bool, Any]:
         """Checks if streams are available."""
-        availability_strategy = HttpAvailabilityStrategy()
         try:
             stream = stream_name_to_stream[stream_name]
-            stream_is_available, reason = availability_strategy.check_availability(stream, logger)
+            stream_is_available, reason = evaluate_availability(stream, logger)
             if not stream_is_available:
                 message = f"Stream {stream_name} is not available: {reason}"
                 logger.warning(message)
@@ -98,7 +117,10 @@ class CheckStream(ConnectionChecker):
         return True, None
 
     def _check_dynamic_streams_availability(
-        self, source: AbstractSource, stream_name_to_stream: Dict[str, Any], logger: logging.Logger
+        self,
+        source: AbstractSource,
+        stream_name_to_stream: Dict[str, Union[Stream, AbstractStream]],
+        logger: logging.Logger,
     ) -> Tuple[bool, Any]:
         """Checks the availability of dynamic streams."""
         dynamic_streams = source.resolved_manifest.get("dynamic_streams", [])  # type: ignore[attr-defined] # The source's resolved_manifest manifest is checked before calling this method
@@ -135,18 +157,15 @@ class CheckStream(ConnectionChecker):
     def _check_generated_streams_availability(
         self,
         generated_streams: List[Dict[str, Any]],
-        stream_name_to_stream: Dict[str, Any],
+        stream_name_to_stream: Dict[str, Union[Stream, AbstractStream]],
         logger: logging.Logger,
         max_count: int,
     ) -> Tuple[bool, Any]:
         """Checks availability of generated dynamic streams."""
-        availability_strategy = HttpAvailabilityStrategy()
         for declarative_stream in generated_streams[: min(max_count, len(generated_streams))]:
             stream = stream_name_to_stream[declarative_stream["name"]]
             try:
-                stream_is_available, reason = availability_strategy.check_availability(
-                    stream, logger
-                )
+                stream_is_available, reason = evaluate_availability(stream, logger)
                 if not stream_is_available:
                     message = f"Dynamic Stream {stream.name} is not available: {reason}"
                     logger.warning(message)

airbyte_cdk/sources/declarative/concurrent_declarative_source.py

@@ -52,9 +52,6 @@ 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,
-)
 from airbyte_cdk.sources.streams.concurrent.cursor import ConcurrentCursor, FinalStateCursor
 from airbyte_cdk.sources.streams.concurrent.default_stream import DefaultStream
 from airbyte_cdk.sources.streams.concurrent.helpers import get_primary_key_from_stream
@@ -325,7 +322,6 @@ class ConcurrentDeclarativeSource(ManifestDeclarativeSource, Generic[TState]):
                             partition_generator=partition_generator,
                             name=declarative_stream.name,
                             json_schema=declarative_stream.get_json_schema(),
-                            availability_strategy=AlwaysAvailableAvailabilityStrategy(),
                             primary_key=get_primary_key_from_stream(declarative_stream.primary_key),
                             cursor_field=cursor.cursor_field.cursor_field_key
                             if hasattr(cursor, "cursor_field")
@@ -362,7 +358,6 @@ class ConcurrentDeclarativeSource(ManifestDeclarativeSource, Generic[TState]):
                             partition_generator=partition_generator,
                             name=declarative_stream.name,
                             json_schema=declarative_stream.get_json_schema(),
-                            availability_strategy=AlwaysAvailableAvailabilityStrategy(),
                             primary_key=get_primary_key_from_stream(declarative_stream.primary_key),
                             cursor_field=None,
                             logger=self.logger,
@@ -417,7 +412,6 @@ class ConcurrentDeclarativeSource(ManifestDeclarativeSource, Generic[TState]):
                             partition_generator=partition_generator,
                             name=declarative_stream.name,
                             json_schema=declarative_stream.get_json_schema(),
-                            availability_strategy=AlwaysAvailableAvailabilityStrategy(),
                             primary_key=get_primary_key_from_stream(declarative_stream.primary_key),
                             cursor_field=perpartition_cursor.cursor_field.cursor_field_key,
                             logger=self.logger,

airbyte_cdk/sources/file_based/availability_strategy/__init__.py

@@ -1,11 +1,7 @@
-from .abstract_file_based_availability_strategy import (
-    AbstractFileBasedAvailabilityStrategy,
-    AbstractFileBasedAvailabilityStrategyWrapper,
-)
+from .abstract_file_based_availability_strategy import AbstractFileBasedAvailabilityStrategy
 from .default_file_based_availability_strategy import DefaultFileBasedAvailabilityStrategy
 
 __all__ = [
     "AbstractFileBasedAvailabilityStrategy",
-    "AbstractFileBasedAvailabilityStrategyWrapper",
     "DefaultFileBasedAvailabilityStrategy",
 ]

airbyte_cdk/sources/file_based/availability_strategy/abstract_file_based_availability_strategy.py

@@ -10,12 +10,6 @@ from typing import TYPE_CHECKING, Optional, Tuple
 
 from airbyte_cdk.sources import Source
 from airbyte_cdk.sources.streams.availability_strategy import AvailabilityStrategy
-from airbyte_cdk.sources.streams.concurrent.availability_strategy import (
-    AbstractAvailabilityStrategy,
-    StreamAvailability,
-    StreamAvailable,
-    StreamUnavailable,
-)
 from airbyte_cdk.sources.streams.core import Stream
 
 if TYPE_CHECKING:
@@ -28,7 +22,7 @@ class AbstractFileBasedAvailabilityStrategy(AvailabilityStrategy):
         self,
         stream: Stream,
         logger: logging.Logger,
-        _: Optional[Source],
+        source: Optional[Source] = None,
     ) -> Tuple[bool, Optional[str]]:
         """
         Perform a connection check for the stream.
@@ -51,23 +45,3 @@ class AbstractFileBasedAvailabilityStrategy(AvailabilityStrategy):
         Returns (True, None) if successful, otherwise (False, <error message>).
         """
         ...
-
-
-class AbstractFileBasedAvailabilityStrategyWrapper(AbstractAvailabilityStrategy):
-    def __init__(self, stream: AbstractFileBasedStream) -> None:
-        self.stream = stream
-
-    def check_availability(self, logger: logging.Logger) -> StreamAvailability:
-        is_available, reason = self.stream.availability_strategy.check_availability(
-            self.stream, logger, None
-        )
-        if is_available:
-            return StreamAvailable()
-        return StreamUnavailable(reason or "")
-
-    def check_availability_and_parsability(
-        self, logger: logging.Logger
-    ) -> Tuple[bool, Optional[str]]:
-        return self.stream.availability_strategy.check_availability_and_parsability(
-            self.stream, logger, None
-        )

airbyte_cdk/sources/file_based/stream/abstract_file_based_stream.py

@@ -179,7 +179,6 @@ class AbstractFileBasedStream(Stream):
             )
 
     @cached_property
-    @deprecated("Deprecated as of CDK version 3.7.0.")
     def availability_strategy(self) -> AbstractFileBasedAvailabilityStrategy:
         return self._availability_strategy
 

airbyte_cdk/sources/file_based/stream/concurrent/adapters.py

@@ -21,7 +21,6 @@ from airbyte_cdk.sources import AbstractSource
 from airbyte_cdk.sources.connector_state_manager import ConnectorStateManager
 from airbyte_cdk.sources.file_based.availability_strategy import (
     AbstractFileBasedAvailabilityStrategy,
-    AbstractFileBasedAvailabilityStrategyWrapper,
 )
 from airbyte_cdk.sources.file_based.config.file_based_stream_config import PrimaryKeyType
 from airbyte_cdk.sources.file_based.file_types.file_type_parser import FileTypeParser
@@ -97,7 +96,6 @@ class FileBasedStreamFacade(AbstractStreamFacade[DefaultStream], AbstractFileBas
                 ),
                 name=stream.name,
                 json_schema=stream.get_json_schema(),
-                availability_strategy=AbstractFileBasedAvailabilityStrategyWrapper(stream),
                 primary_key=pk,
                 cursor_field=cursor_field,
                 logger=logger,

airbyte_cdk/sources/streams/availability_strategy.py

@@ -14,6 +14,7 @@ if typing.TYPE_CHECKING:
     from airbyte_cdk.sources import Source
 
 
+# FIXME this
 class AvailabilityStrategy(ABC):
     """
     Abstract base class for checking stream availability.

airbyte_cdk/sources/streams/concurrent/abstract_stream.py

@@ -64,12 +64,6 @@ class AbstractStream(ABC):
         :return: The name of the field used as a cursor. Nested cursor fields are not supported.
         """
 
-    @abstractmethod
-    def check_availability(self) -> StreamAvailability:
-        """
-        :return: The stream's availability
-        """
-
     @abstractmethod
     def get_json_schema(self) -> Mapping[str, Any]:
         """
@@ -94,3 +88,9 @@ class AbstractStream(ABC):
         """
         :return: The cursor associated with this stream.
         """
+
+    @abstractmethod
+    def check_availability(self) -> StreamAvailability:
+        """
+        :return: If the stream is available and if not, why
+        """

airbyte_cdk/sources/streams/concurrent/adapters.py

@@ -24,12 +24,7 @@ from airbyte_cdk.sources.connector_state_manager import ConnectorStateManager
 from airbyte_cdk.sources.message import MessageRepository
 from airbyte_cdk.sources.source import ExperimentalClassWarning
 from airbyte_cdk.sources.streams import Stream
-from airbyte_cdk.sources.streams.availability_strategy import AvailabilityStrategy
 from airbyte_cdk.sources.streams.concurrent.abstract_stream_facade import AbstractStreamFacade
-from airbyte_cdk.sources.streams.concurrent.availability_strategy import (
-    AbstractAvailabilityStrategy,
-    AlwaysAvailableAvailabilityStrategy,
-)
 from airbyte_cdk.sources.streams.concurrent.cursor import Cursor, FinalStateCursor
 from airbyte_cdk.sources.streams.concurrent.default_stream import DefaultStream
 from airbyte_cdk.sources.streams.concurrent.exceptions import ExceptionWithDisplayMessage
@@ -101,7 +96,6 @@ class StreamFacade(AbstractStreamFacade[DefaultStream], Stream):
                 name=stream.name,
                 namespace=stream.namespace,
                 json_schema=stream.get_json_schema(),
-                availability_strategy=AlwaysAvailableAvailabilityStrategy(),
                 primary_key=pk,
                 cursor_field=cursor_field,
                 logger=logger,
@@ -210,18 +204,6 @@ class StreamFacade(AbstractStreamFacade[DefaultStream], Stream):
     def supports_incremental(self) -> bool:
         return self._legacy_stream.supports_incremental
 
-    def check_availability(
-        self, logger: logging.Logger, source: Optional["Source"] = None
-    ) -> Tuple[bool, Optional[str]]:
-        """
-        Verifies the stream is available. Delegates to the underlying AbstractStream and ignores the parameters
-        :param logger: (ignored)
-        :param source:  (ignored)
-        :return:
-        """
-        availability = self._abstract_stream.check_availability()
-        return availability.is_available(), availability.message()
-
     def as_airbyte_stream(self) -> AirbyteStream:
         return self._abstract_stream.as_airbyte_stream()
 
@@ -370,28 +352,3 @@ class StreamPartitionGenerator(PartitionGenerator):
                 self._cursor_field,
                 self._state,
             )
-
-
-@deprecated(
-    "Availability strategy has been soft deprecated. Do not use. Class is subject to removal",
-    category=ExperimentalClassWarning,
-)
-class AvailabilityStrategyFacade(AvailabilityStrategy):
-    def __init__(self, abstract_availability_strategy: AbstractAvailabilityStrategy):
-        self._abstract_availability_strategy = abstract_availability_strategy
-
-    def check_availability(
-        self, stream: Stream, logger: logging.Logger, source: Optional["Source"] = None
-    ) -> Tuple[bool, Optional[str]]:
-        """
-        Checks stream availability.
-
-        Important to note that the stream and source parameters are not used by the underlying AbstractAvailabilityStrategy.
-
-        :param stream: (unused)
-        :param logger: logger object to use
-        :param source: (unused)
-        :return: A tuple of (boolean, str). If boolean is true, then the stream
-        """
-        stream_availability = self._abstract_availability_strategy.check_availability(logger)
-        return stream_availability.is_available(), stream_availability.message()

airbyte_cdk/sources/streams/concurrent/availability_strategy.py

@@ -2,93 +2,36 @@
 # Copyright (c) 2023 Airbyte, Inc., all rights reserved.
 #
 
-import logging
 from abc import ABC, abstractmethod
 from typing import Optional
 
-from typing_extensions import deprecated
 
-from airbyte_cdk.sources.source import ExperimentalClassWarning
+class StreamAvailability:
+    @classmethod
+    def available(cls) -> "StreamAvailability":
+        return cls(True)
 
+    @classmethod
+    def unavailable(cls, reason: str) -> "StreamAvailability":
+        return cls(False, reason)
 
-class StreamAvailability(ABC):
-    @abstractmethod
-    def is_available(self) -> bool:
-        """
-        :return: True if the stream is available. False if the stream is not
-        """
-
-    @abstractmethod
-    def message(self) -> Optional[str]:
-        """
-        :return: A message describing why the stream is not available. If the stream is available, this should return None.
-        """
+    def __init__(self, available: bool, reason: Optional[str] = None) -> None:
+        self._available = available
+        self._reason = reason
 
+        if not available:
+            assert reason, "A reason needs to be provided if the stream is not available"
 
-class StreamAvailable(StreamAvailability):
+    @property
     def is_available(self) -> bool:
-        return True
-
-    def message(self) -> Optional[str]:
-        return None
-
-
-class StreamUnavailable(StreamAvailability):
-    def __init__(self, message: str):
-        self._message = message
-
-    def is_available(self) -> bool:
-        return False
-
-    def message(self) -> Optional[str]:
-        return self._message
-
-
-# Singleton instances of StreamAvailability to avoid the overhead of creating new dummy objects
-STREAM_AVAILABLE = StreamAvailable()
-
-
-@deprecated(
-    "This class is experimental. Use at your own risk.",
-    category=ExperimentalClassWarning,
-)
-class AbstractAvailabilityStrategy(ABC):
-    """
-    AbstractAvailabilityStrategy is an experimental interface developed as part of the Concurrent CDK.
-    This interface is not yet stable and may change in the future. Use at your own risk.
-
-    Why create a new interface instead of using the existing AvailabilityStrategy?
-    The existing AvailabilityStrategy is tightly coupled with Stream and Source, which yields to circular dependencies and makes it difficult to move away from the Stream interface to AbstractStream.
-    """
-
-    @abstractmethod
-    def check_availability(self, logger: logging.Logger) -> StreamAvailability:
         """
-        Checks stream availability.
-
-        :param logger: logger object to use
-        :return: A StreamAvailability object describing the stream's availability
+        :return: True if the stream is available. False if the stream is not
         """
+        return self._available
 
-
-@deprecated(
-    "This class is experimental. Use at your own risk.",
-    category=ExperimentalClassWarning,
-)
-class AlwaysAvailableAvailabilityStrategy(AbstractAvailabilityStrategy):
-    """
-    An availability strategy that always indicates a stream is available.
-
-    This strategy is used to avoid breaking changes and serves as a soft
-    deprecation of the availability strategy, allowing a smoother transition
-    without disrupting existing functionality.
-    """
-
-    def check_availability(self, logger: logging.Logger) -> StreamAvailability:
+    @property
+    def reason(self) -> Optional[str]:
         """
-        Checks stream availability.
-
-        :param logger: logger object to use
-        :return: A StreamAvailability object describing the stream's availability
+        :return: A message describing why the stream is not available. If the stream is available, this should return None.
         """
-        return StreamAvailable()
+        return self._reason

airbyte_cdk/sources/streams/concurrent/default_stream.py

@@ -8,13 +8,11 @@ from typing import Any, Iterable, List, Mapping, Optional
 
 from airbyte_cdk.models import AirbyteStream, SyncMode
 from airbyte_cdk.sources.streams.concurrent.abstract_stream import AbstractStream
-from airbyte_cdk.sources.streams.concurrent.availability_strategy import (
-    AbstractAvailabilityStrategy,
-    StreamAvailability,
-)
+from airbyte_cdk.sources.streams.concurrent.availability_strategy import StreamAvailability
 from airbyte_cdk.sources.streams.concurrent.cursor import Cursor
 from airbyte_cdk.sources.streams.concurrent.partitions.partition import Partition
 from airbyte_cdk.sources.streams.concurrent.partitions.partition_generator import PartitionGenerator
+from airbyte_cdk.utils.traced_exception import AirbyteTracedException
 
 
 class DefaultStream(AbstractStream):
@@ -23,7 +21,6 @@ class DefaultStream(AbstractStream):
         partition_generator: PartitionGenerator,
         name: str,
         json_schema: Mapping[str, Any],
-        availability_strategy: AbstractAvailabilityStrategy,
         primary_key: List[str],
         cursor_field: Optional[str],
         logger: Logger,
@@ -34,7 +31,6 @@ class DefaultStream(AbstractStream):
         self._stream_partition_generator = partition_generator
         self._name = name
         self._json_schema = json_schema
-        self._availability_strategy = availability_strategy
         self._primary_key = primary_key
         self._cursor_field = cursor_field
         self._logger = logger
@@ -53,9 +49,6 @@ class DefaultStream(AbstractStream):
     def namespace(self) -> Optional[str]:
         return self._namespace
 
-    def check_availability(self) -> StreamAvailability:
-        return self._availability_strategy.check_availability(self._logger)
-
     @property
     def cursor_field(self) -> Optional[str]:
         return self._cursor_field
@@ -100,3 +93,33 @@ class DefaultStream(AbstractStream):
     @property
     def cursor(self) -> Cursor:
         return self._cursor
+
+    def check_availability(self) -> StreamAvailability:
+        """
+        Check stream availability by attempting to read the first record of the stream.
+        """
+        try:
+            partition = next(iter(self.generate_partitions()))
+        except StopIteration:
+            # NOTE: The following comment was copied from legacy stuff and I don't know how relevant it is:
+            # If stream_slices has no `next()` item (Note - this is different from stream_slices returning [None]!)
+            # This can happen when a substream's `stream_slices` method does a `for record in parent_records: yield <something>`
+            # without accounting for the case in which the parent stream is empty.
+            return StreamAvailability.unavailable(
+                f"Cannot attempt to connect to stream {self.name} - no stream slices were found"
+            )
+        except AirbyteTracedException as error:
+            return StreamAvailability.unavailable(
+                error.message or error.internal_message or "<no error message>"
+            )
+
+        try:
+            next(iter(partition.read()))
+            return StreamAvailability.available()
+        except StopIteration:
+            self._logger.info(f"Successfully connected to stream {self.name}, but got 0 records.")
+            return StreamAvailability.available()
+        except AirbyteTracedException as error:
+            return StreamAvailability.unavailable(
+                error.message or error.internal_message or "<no error message>"
+            )

{airbyte_cdk-6.60.10.dist-info → airbyte_cdk-6.60.11.dist-info}/METADATA

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

{airbyte_cdk-6.60.10.dist-info → airbyte_cdk-6.60.11.dist-info}/RECORD

@@ -81,12 +81,12 @@ airbyte_cdk/sources/declarative/auth/selective_authenticator.py,sha256=qGwC6YsCl
 airbyte_cdk/sources/declarative/auth/token.py,sha256=2EnE78EhBOY9hbeZnQJ9AuFaM-G7dccU-oKo_LThRQk,11070
 airbyte_cdk/sources/declarative/auth/token_provider.py,sha256=Jzuxlmt1_-_aFC_n0OmP8L1nDOacLzbEVVx3kjdX_W8,3104
 airbyte_cdk/sources/declarative/checks/__init__.py,sha256=cpoBwEbRNcMi7Rmi5pD63ppUvAOZsAWzasmc57ob9rc,873
-airbyte_cdk/sources/declarative/checks/check_dynamic_stream.py,sha256=HUktywjI8pqOeED08UGqponUSwxs2TOAECTowlWlrRE,2138
-airbyte_cdk/sources/declarative/checks/check_stream.py,sha256=QeExVmpSYjr_CnghHuJBn5oHW6wyKmAr7rotSSfcWp8,7145
+airbyte_cdk/sources/declarative/checks/check_dynamic_stream.py,sha256=AF3qzwvvln5Q7NgmdCUu5TBVLNhMLDNPIHop7Cq7ad0,2354
+airbyte_cdk/sources/declarative/checks/check_stream.py,sha256=sV-ZY7dZ03V8GdAxPYyYJoGfYBSJZ6qxu_9lF1rGbpE,8012
 airbyte_cdk/sources/declarative/checks/connection_checker.py,sha256=MBRJo6WJlZQHpIfOGaNOkkHUmgUl_4wDM6VPo41z5Ss,1383
 airbyte_cdk/sources/declarative/concurrency_level/__init__.py,sha256=5XUqrmlstYlMM0j6crktlKQwALek0uiz2D3WdM46MyA,191
 airbyte_cdk/sources/declarative/concurrency_level/concurrency_level.py,sha256=YIwCTCpOr_QSNW4ltQK0yUGWInI8PKNY216HOOegYLk,2101
-airbyte_cdk/sources/declarative/concurrent_declarative_source.py,sha256=IwKlf20G5C4j-am9FrLhRN0qv61A5rU097xPnnFmt5U,27022
+airbyte_cdk/sources/declarative/concurrent_declarative_source.py,sha256=_C0IKcPlumc3HAGxccmeyS8lSQo7HxPr4jcNFok_9oU,26637
 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
@@ -247,8 +247,8 @@ airbyte_cdk/sources/declarative/validators/validator.py,sha256=MAwo8OievUsuzBuPx
 airbyte_cdk/sources/declarative/yaml_declarative_source.py,sha256=-pHwGO7ZW-x8lmsqSpbrN0pOgIyjJhFDGUNwB3kQWWc,2794
 airbyte_cdk/sources/file_based/README.md,sha256=iMqww4VZ882jfNQIdljjDgqreKs-mkdtSrRKA94iX6A,11085
 airbyte_cdk/sources/file_based/__init__.py,sha256=EaxHv_9ot-eRlUCR47ZMZ0IOtB-n0HH24om7Bfn-uuQ,868
-airbyte_cdk/sources/file_based/availability_strategy/__init__.py,sha256=ddKQfUmk-Ls7LJaG8gtrqDybG3d8S7KXOAEjLeYLrTg,399
-airbyte_cdk/sources/file_based/availability_strategy/abstract_file_based_availability_strategy.py,sha256=01Nd4b7ERAbp-OZo_8rrAzFXWPTMwr02SnWiN17nx8Q,2363
+airbyte_cdk/sources/file_based/availability_strategy/__init__.py,sha256=VY-0PcTaPttXU_mGf-7w7u5VKQD7iQWJbKMvIYAOhcQ,288
+airbyte_cdk/sources/file_based/availability_strategy/abstract_file_based_availability_strategy.py,sha256=VA3_qymdY74VRLcu7-waj7MAZaCCmlKDmvMT13lO9nc,1443
 airbyte_cdk/sources/file_based/availability_strategy/default_file_based_availability_strategy.py,sha256=j9T5TimfWFUz7nqsaj-83G3xWmDpsmeSbDnaUNmz0UM,5849
 airbyte_cdk/sources/file_based/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 airbyte_cdk/sources/file_based/config/abstract_file_based_spec.py,sha256=purspcxMNWLhGunaqVJa9TISMZK7vlQSwdz4zykFWNA,6989
@@ -283,9 +283,9 @@ airbyte_cdk/sources/file_based/schema_validation_policies/__init__.py,sha256=FkB
 airbyte_cdk/sources/file_based/schema_validation_policies/abstract_schema_validation_policy.py,sha256=kjvX7nOmUALYd7HuZHilUzgJPZ-MnZ08mtvuBnt2tQ0,618
 airbyte_cdk/sources/file_based/schema_validation_policies/default_schema_validation_policies.py,sha256=vjTlmYT_nqzY3DbT5xem7X-bwgA9RyXHoKFqiMO2URk,1728
 airbyte_cdk/sources/file_based/stream/__init__.py,sha256=q_zmeOHHg0JK5j1YNSOIsyXGz-wlTl_0E8z5GKVAcVM,543
-airbyte_cdk/sources/file_based/stream/abstract_file_based_stream.py,sha256=9pQh3BHYcxm8CRC8XawfmBxL8O9HggpWwCCbX_ncINE,7509
+airbyte_cdk/sources/file_based/stream/abstract_file_based_stream.py,sha256=fCF6lBKmPAFS2ZpJb9I0GIGwMxfCkA-41Yhs_fyLTxs,7454
 airbyte_cdk/sources/file_based/stream/concurrent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-airbyte_cdk/sources/file_based/stream/concurrent/adapters.py,sha256=1AIuAOHa_M6zN9l0eAWBHwhKl4fdP4-KlUMOMzTv11U,13525
+airbyte_cdk/sources/file_based/stream/concurrent/adapters.py,sha256=MxK7urU9s4YeYA-4Kjx4gnJak9AyyojqNsW1bYtfbp8,13383
 airbyte_cdk/sources/file_based/stream/concurrent/cursor/__init__.py,sha256=Rx7TwjH8B7e0eee83Tlqxv1bWn-BVXOmlUAH7auM1uM,344
 airbyte_cdk/sources/file_based/stream/concurrent/cursor/abstract_concurrent_file_based_cursor.py,sha256=5dYZMLBEbvCyrCT89lCYdm2FdrLPLuxjdpQSVGP5o0w,1856
 airbyte_cdk/sources/file_based/stream/concurrent/cursor/file_based_concurrent_cursor.py,sha256=lubzER11aRWGureKhdvZqWraM7hOWiv-WrGQofnmcJU,14957
@@ -304,7 +304,7 @@ airbyte_cdk/sources/message/repository.py,sha256=SG7avgti_-dj8FcRHTTrhgLLGJbElv1
 airbyte_cdk/sources/source.py,sha256=KIBBH5VLEb8BZ8B9aROlfaI6OLoJqKDPMJ10jkAR7nk,3611
 airbyte_cdk/sources/specs/transfer_modes.py,sha256=sfSVO0yT6SaGKN5_TP0Nl_ftG0yPhecaBv0WkhAEXA8,932
 airbyte_cdk/sources/streams/__init__.py,sha256=8fzTKpRTnSx5PggXgQPKJzHNZUV2BCA40N-dI6JM1xI,256
-airbyte_cdk/sources/streams/availability_strategy.py,sha256=_RU4JITrxMEN36g1RDHMu0iSw0I_3yWGfo5N8_YRvOg,3247
+airbyte_cdk/sources/streams/availability_strategy.py,sha256=-WORUv8btPo9WI85M9sU43OCN9WE_DfdT9zMdS13sUo,3260
 airbyte_cdk/sources/streams/call_rate.py,sha256=jRsGp1PDZBCDQNxzcGVnVmVzLk0wLHxS1JnJwMAgy9U,27568
 airbyte_cdk/sources/streams/checkpoint/__init__.py,sha256=3oy7Hd4ivVWTZlN6dKAf4Fv_G7U5iZrvhO9hT871UIo,712
 airbyte_cdk/sources/streams/checkpoint/checkpoint_reader.py,sha256=6HMT2NI-FQuaW0nt95NcyWrt5rZN4gF-Arx0sxdgbv4,15221
@@ -314,14 +314,14 @@ airbyte_cdk/sources/streams/checkpoint/resumable_full_refresh_cursor.py,sha256=G
 airbyte_cdk/sources/streams/checkpoint/substream_resumable_full_refresh_cursor.py,sha256=qydclrks-hHJ9B9wOKvbu_FZXJOFiB3yD5U4KwsX80Y,4569
 airbyte_cdk/sources/streams/concurrent/README.md,sha256=0nvgnlCBfZJiPDAofT8yFmUhGc4L99RCb3fL_PI4sSY,1070
 airbyte_cdk/sources/streams/concurrent/__init__.py,sha256=4Hw-PX1-VgESLF16cDdvuYCzGJtHntThLF4qIiULWeo,61
-airbyte_cdk/sources/streams/concurrent/abstract_stream.py,sha256=3OB5VsvOkJmCxIMABKgdJAwvCdZtkxeaAVrUNIW3jMQ,3902
+airbyte_cdk/sources/streams/concurrent/abstract_stream.py,sha256=aalik3FvyEjoeA1S3wUYEV3bgQLGrTnhYKPvT-rgy9E,3919
 airbyte_cdk/sources/streams/concurrent/abstract_stream_facade.py,sha256=QTry1QCBUwJDw1QSCEvz23s7zIEx_7QMxkPq9j-oPIQ,1358
-airbyte_cdk/sources/streams/concurrent/adapters.py,sha256=aZtJ_75gVPmoCS-URtfQQX8mYId5xk5Q5mLQYeTM0N4,15814
-airbyte_cdk/sources/streams/concurrent/availability_strategy.py,sha256=4La5v2UffSjGnhmF4kwNIKt_g3RXk2ux1mSHA1ejgYM,2898
+airbyte_cdk/sources/streams/concurrent/adapters.py,sha256=R9EZza1jF0e_HaLgN9Q_VREjvmlk0p9UfBLsnHB2y48,13936
+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=xFFB8eEbtjGUdb42vkyWT5JB-WTUsaJlZ0gjKoVEycc,22307
 airbyte_cdk/sources/streams/concurrent/cursor_types.py,sha256=ZyWLPpeLX1qXcP5MwS-wxK11IBMsnVPCw9zx8gA2_Ro,843
-airbyte_cdk/sources/streams/concurrent/default_stream.py,sha256=3SBjFa1z955pSE_2qt1C7mAky-RKjOZeQDePbZkWYYs,3371
+airbyte_cdk/sources/streams/concurrent/default_stream.py,sha256=cVBMwCM8OVlsLA39e1YN_eGb7qApqH-GQtnWMs19sGU,4687
 airbyte_cdk/sources/streams/concurrent/exceptions.py,sha256=JOZ446MCLpmF26r9KfS6OO_6rGjcjgJNZdcw6jccjEI,468
 airbyte_cdk/sources/streams/concurrent/helpers.py,sha256=S6AW8TgIASCZ2UuUcQLE8OzgYUHWt2-KPOvNPwnQf-Q,1596
 airbyte_cdk/sources/streams/concurrent/partition_enqueuer.py,sha256=2t64b_z9cEPmlHZnjSiMTO8PEtEdiAJDG0JcYOtUqAE,3363
@@ -424,9 +424,9 @@ airbyte_cdk/utils/slice_hasher.py,sha256=EDxgROHDbfG-QKQb59m7h_7crN1tRiawdf5uU7G
 airbyte_cdk/utils/spec_schema_transformations.py,sha256=-5HTuNsnDBAhj-oLeQXwpTGA0HdcjFOf2zTEMUTTg_Y,816
 airbyte_cdk/utils/stream_status_utils.py,sha256=ZmBoiy5HVbUEHAMrUONxZvxnvfV9CesmQJLDTAIWnWw,1171
 airbyte_cdk/utils/traced_exception.py,sha256=C8uIBuCL_E4WnBAOPSxBicD06JAldoN9fGsQDp463OY,6292
-airbyte_cdk-6.60.10.dist-info/LICENSE.txt,sha256=Wfe61S4BaGPj404v8lrAbvhjYR68SHlkzeYrg3_bbuM,1051
-airbyte_cdk-6.60.10.dist-info/LICENSE_SHORT,sha256=aqF6D1NcESmpn-cqsxBtszTEnHKnlsp8L4x9wAh3Nxg,55
-airbyte_cdk-6.60.10.dist-info/METADATA,sha256=KXyH_12QEMpUTXIqXvPXvEFanE8Km-uA1aAK0Hax_o0,6478
-airbyte_cdk-6.60.10.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-airbyte_cdk-6.60.10.dist-info/entry_points.txt,sha256=AKWbEkHfpzzk9nF9tqBUaw1MbvTM4mGtEzmZQm0ZWvM,139
-airbyte_cdk-6.60.10.dist-info/RECORD,,
+airbyte_cdk-6.60.11.dist-info/LICENSE.txt,sha256=Wfe61S4BaGPj404v8lrAbvhjYR68SHlkzeYrg3_bbuM,1051
+airbyte_cdk-6.60.11.dist-info/LICENSE_SHORT,sha256=aqF6D1NcESmpn-cqsxBtszTEnHKnlsp8L4x9wAh3Nxg,55
+airbyte_cdk-6.60.11.dist-info/METADATA,sha256=ThGpN0itMBbE8stLZwHsuUHiuHa_Zh5eUvybXg-wtTk,6478
+airbyte_cdk-6.60.11.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+airbyte_cdk-6.60.11.dist-info/entry_points.txt,sha256=AKWbEkHfpzzk9nF9tqBUaw1MbvTM4mGtEzmZQm0ZWvM,139
+airbyte_cdk-6.60.11.dist-info/RECORD,,