airbyte-cdk 6.5.3rc2__py3-none-any.whl → 6.6.0__py3-none-any.whl

airbyte_cdk/sources/declarative/incremental/per_partition_cursor.py

@@ -8,7 +8,9 @@ from typing import Any, Callable, Iterable, Mapping, Optional, Union
 
 from airbyte_cdk.sources.declarative.incremental.declarative_cursor import DeclarativeCursor
 from airbyte_cdk.sources.declarative.partition_routers.partition_router import PartitionRouter
-from airbyte_cdk.sources.streams.checkpoint.per_partition_key_serializer import PerPartitionKeySerializer
+from airbyte_cdk.sources.streams.checkpoint.per_partition_key_serializer import (
+    PerPartitionKeySerializer,
+)
 from airbyte_cdk.sources.types import Record, StreamSlice, StreamState
 
 logger = logging.getLogger("airbyte")
@@ -67,12 +69,18 @@ class PerPartitionCursor(DeclarativeCursor):
 
         cursor = self._cursor_per_partition.get(self._to_partition_key(partition.partition))
         if not cursor:
-            partition_state = self._state_to_migrate_from if self._state_to_migrate_from else self._NO_CURSOR_STATE
+            partition_state = (
+                self._state_to_migrate_from
+                if self._state_to_migrate_from
+                else self._NO_CURSOR_STATE
+            )
             cursor = self._create_cursor(partition_state)
             self._cursor_per_partition[self._to_partition_key(partition.partition)] = cursor
 
         for cursor_slice in cursor.stream_slices():
-            yield StreamSlice(partition=partition, cursor_slice=cursor_slice, extra_fields=partition.extra_fields)
+            yield StreamSlice(
+                partition=partition, cursor_slice=cursor_slice, extra_fields=partition.extra_fields
+            )
 
     def _ensure_partition_limit(self) -> None:
         """
@@ -80,7 +88,9 @@ class PerPartitionCursor(DeclarativeCursor):
         """
         while len(self._cursor_per_partition) > self.DEFAULT_MAX_PARTITIONS_NUMBER - 1:
             self._over_limit += 1
-            oldest_partition = self._cursor_per_partition.popitem(last=False)[0]  # Remove the oldest partition
+            oldest_partition = self._cursor_per_partition.popitem(last=False)[
+                0
+            ]  # Remove the oldest partition
             logger.warning(
                 f"The maximum number of partitions has been reached. Dropping the oldest partition: {oldest_partition}. Over limit: {self._over_limit}."
             )
@@ -128,7 +138,9 @@ class PerPartitionCursor(DeclarativeCursor):
 
         else:
             for state in stream_state["states"]:
-                self._cursor_per_partition[self._to_partition_key(state["partition"])] = self._create_cursor(state["cursor"])
+                self._cursor_per_partition[self._to_partition_key(state["partition"])] = (
+                    self._create_cursor(state["cursor"])
+                )
 
             # set default state for missing partitions if it is per partition with fallback to global
             if "state" in stream_state:
@@ -214,7 +226,9 @@ class PerPartitionCursor(DeclarativeCursor):
                 stream_state=stream_state,
                 stream_slice=StreamSlice(partition=stream_slice.partition, cursor_slice={}),
                 next_page_token=next_page_token,
-            ) | self._cursor_per_partition[self._to_partition_key(stream_slice.partition)].get_request_params(
+            ) | self._cursor_per_partition[
+                self._to_partition_key(stream_slice.partition)
+            ].get_request_params(
                 stream_state=stream_state,
                 stream_slice=StreamSlice(partition={}, cursor_slice=stream_slice.cursor_slice),
                 next_page_token=next_page_token,
@@ -234,7 +248,9 @@ class PerPartitionCursor(DeclarativeCursor):
                 stream_state=stream_state,
                 stream_slice=StreamSlice(partition=stream_slice.partition, cursor_slice={}),
                 next_page_token=next_page_token,
-            ) | self._cursor_per_partition[self._to_partition_key(stream_slice.partition)].get_request_headers(
+            ) | self._cursor_per_partition[
+                self._to_partition_key(stream_slice.partition)
+            ].get_request_headers(
                 stream_state=stream_state,
                 stream_slice=StreamSlice(partition={}, cursor_slice=stream_slice.cursor_slice),
                 next_page_token=next_page_token,
@@ -254,7 +270,9 @@ class PerPartitionCursor(DeclarativeCursor):
                 stream_state=stream_state,
                 stream_slice=StreamSlice(partition=stream_slice.partition, cursor_slice={}),
                 next_page_token=next_page_token,
-            ) | self._cursor_per_partition[self._to_partition_key(stream_slice.partition)].get_request_body_data(
+            ) | self._cursor_per_partition[
+                self._to_partition_key(stream_slice.partition)
+            ].get_request_body_data(
                 stream_state=stream_state,
                 stream_slice=StreamSlice(partition={}, cursor_slice=stream_slice.cursor_slice),
                 next_page_token=next_page_token,
@@ -274,7 +292,9 @@ class PerPartitionCursor(DeclarativeCursor):
                 stream_state=stream_state,
                 stream_slice=StreamSlice(partition=stream_slice.partition, cursor_slice={}),
                 next_page_token=next_page_token,
-            ) | self._cursor_per_partition[self._to_partition_key(stream_slice.partition)].get_request_body_json(
+            ) | self._cursor_per_partition[
+                self._to_partition_key(stream_slice.partition)
+            ].get_request_body_json(
                 stream_state=stream_state,
                 stream_slice=StreamSlice(partition={}, cursor_slice=stream_slice.cursor_slice),
                 next_page_token=next_page_token,
@@ -283,32 +303,43 @@ class PerPartitionCursor(DeclarativeCursor):
             raise ValueError("A partition needs to be provided in order to get request body json")
 
     def should_be_synced(self, record: Record) -> bool:
-        return self._get_cursor(record).should_be_synced(self._convert_record_to_cursor_record(record))
+        return self._get_cursor(record).should_be_synced(
+            self._convert_record_to_cursor_record(record)
+        )
 
     def is_greater_than_or_equal(self, first: Record, second: Record) -> bool:
         if not first.associated_slice or not second.associated_slice:
-            raise ValueError(f"Both records should have an associated slice but got {first.associated_slice} and {second.associated_slice}")
+            raise ValueError(
+                f"Both records should have an associated slice but got {first.associated_slice} and {second.associated_slice}"
+            )
         if first.associated_slice.partition != second.associated_slice.partition:
             raise ValueError(
                 f"To compare records, partition should be the same but got {first.associated_slice.partition} and {second.associated_slice.partition}"
             )
 
         return self._get_cursor(first).is_greater_than_or_equal(
-            self._convert_record_to_cursor_record(first), self._convert_record_to_cursor_record(second)
+            self._convert_record_to_cursor_record(first),
+            self._convert_record_to_cursor_record(second),
         )
 
     @staticmethod
     def _convert_record_to_cursor_record(record: Record) -> Record:
         return Record(
             record.data,
-            StreamSlice(partition={}, cursor_slice=record.associated_slice.cursor_slice) if record.associated_slice else None,
+            StreamSlice(partition={}, cursor_slice=record.associated_slice.cursor_slice)
+            if record.associated_slice
+            else None,
         )
 
     def _get_cursor(self, record: Record) -> DeclarativeCursor:
         if not record.associated_slice:
-            raise ValueError("Invalid state as stream slices that are emitted should refer to an existing cursor")
+            raise ValueError(
+                "Invalid state as stream slices that are emitted should refer to an existing cursor"
+            )
         partition_key = self._to_partition_key(record.associated_slice.partition)
         if partition_key not in self._cursor_per_partition:
-            raise ValueError("Invalid state as stream slices that are emitted should refer to an existing cursor")
+            raise ValueError(
+                "Invalid state as stream slices that are emitted should refer to an existing cursor"
+            )
         cursor = self._cursor_per_partition[partition_key]
         return cursor

airbyte_cdk/sources/declarative/incremental/per_partition_with_global.py

@@ -5,8 +5,14 @@ from typing import Any, Iterable, Mapping, MutableMapping, Optional, Union
 
 from airbyte_cdk.sources.declarative.incremental.datetime_based_cursor import DatetimeBasedCursor
 from airbyte_cdk.sources.declarative.incremental.declarative_cursor import DeclarativeCursor
-from airbyte_cdk.sources.declarative.incremental.global_substream_cursor import GlobalSubstreamCursor, iterate_with_last_flag_and_state
-from airbyte_cdk.sources.declarative.incremental.per_partition_cursor import CursorFactory, PerPartitionCursor
+from airbyte_cdk.sources.declarative.incremental.global_substream_cursor import (
+    GlobalSubstreamCursor,
+    iterate_with_last_flag_and_state,
+)
+from airbyte_cdk.sources.declarative.incremental.per_partition_cursor import (
+    CursorFactory,
+    PerPartitionCursor,
+)
 from airbyte_cdk.sources.declarative.partition_routers.partition_router import PartitionRouter
 from airbyte_cdk.sources.types import Record, StreamSlice, StreamState
 
@@ -60,7 +66,12 @@ class PerPartitionWithGlobalCursor(DeclarativeCursor):
     Suitable for streams where the number of partitions may vary significantly, requiring dynamic switching between per-partition and global state management to ensure data consistency and efficient synchronization.
     """
 
-    def __init__(self, cursor_factory: CursorFactory, partition_router: PartitionRouter, stream_cursor: DatetimeBasedCursor):
+    def __init__(
+        self,
+        cursor_factory: CursorFactory,
+        partition_router: PartitionRouter,
+        stream_cursor: DatetimeBasedCursor,
+    ):
         self._partition_router = partition_router
         self._per_partition_cursor = PerPartitionCursor(cursor_factory, partition_router)
         self._global_cursor = GlobalSubstreamCursor(stream_cursor, partition_router)
@@ -82,7 +93,8 @@ class PerPartitionWithGlobalCursor(DeclarativeCursor):
             # Generate slices for the current cursor and handle the last slice using the flag
             self._parent_state = parent_state
             for slice, is_last_slice, _ in iterate_with_last_flag_and_state(
-                self._get_active_cursor().generate_slices_from_partition(partition=partition), lambda: None
+                self._get_active_cursor().generate_slices_from_partition(partition=partition),
+                lambda: None,
             ):
                 self._global_cursor.register_slice(is_last_slice and is_last_partition)
                 yield slice
@@ -182,7 +194,9 @@ class PerPartitionWithGlobalCursor(DeclarativeCursor):
         )
 
     def should_be_synced(self, record: Record) -> bool:
-        return self._global_cursor.should_be_synced(record) or self._per_partition_cursor.should_be_synced(record)
+        return self._global_cursor.should_be_synced(
+            record
+        ) or self._per_partition_cursor.should_be_synced(record)
 
     def is_greater_than_or_equal(self, first: Record, second: Record) -> bool:
         return self._global_cursor.is_greater_than_or_equal(first, second)

airbyte_cdk/sources/declarative/incremental/resumable_full_refresh_cursor.py

@@ -30,7 +30,9 @@ class ResumableFullRefreshCursor(DeclarativeCursor):
     def close_slice(self, stream_slice: StreamSlice, *args: Any) -> None:
         # The ResumableFullRefreshCursor doesn't support nested streams yet so receiving a partition is unexpected
         if stream_slice.partition:
-            raise ValueError(f"Stream slice {stream_slice} should not have a partition. Got {stream_slice.partition}.")
+            raise ValueError(
+                f"Stream slice {stream_slice} should not have a partition. Got {stream_slice.partition}."
+            )
         self._cursor = stream_slice.cursor_slice
 
     def should_be_synced(self, record: Record) -> bool:

airbyte_cdk/sources/declarative/interpolation/interpolated_boolean.py

@@ -8,7 +8,21 @@ from typing import Any, Final, List, Mapping
 from airbyte_cdk.sources.declarative.interpolation.jinja import JinjaInterpolation
 from airbyte_cdk.sources.types import Config
 
-FALSE_VALUES: Final[List[Any]] = ["False", "false", "{}", "[]", "()", "", "0", "0.0", {}, False, [], (), set()]
+FALSE_VALUES: Final[List[Any]] = [
+    "False",
+    "false",
+    "{}",
+    "[]",
+    "()",
+    "",
+    "0",
+    "0.0",
+    {},
+    False,
+    [],
+    (),
+    set(),
+]
 
 
 @dataclass
@@ -40,7 +54,11 @@ class InterpolatedBoolean:
             return self.condition
         else:
             evaluated = self._interpolation.eval(
-                self.condition, config, self._default, parameters=self._parameters, **additional_parameters
+                self.condition,
+                config,
+                self._default,
+                parameters=self._parameters,
+                **additional_parameters,
             )
             if evaluated in FALSE_VALUES:
                 return False

airbyte_cdk/sources/declarative/interpolation/interpolated_mapping.py

@@ -38,7 +38,11 @@ class InterpolatedMapping:
         valid_value_types = additional_parameters.pop("valid_value_types", None)
         return {
             self._interpolation.eval(
-                name, config, valid_types=valid_key_types, parameters=self._parameters, **additional_parameters
+                name,
+                config,
+                valid_types=valid_key_types,
+                parameters=self._parameters,
+                **additional_parameters,
             ): self._eval(value, config, valid_types=valid_value_types, **additional_parameters)
             for name, value in self.mapping.items()
         }

airbyte_cdk/sources/declarative/interpolation/interpolated_nested_mapping.py

@@ -9,7 +9,9 @@ from typing import Any, Mapping, Optional, Union
 from airbyte_cdk.sources.declarative.interpolation.jinja import JinjaInterpolation
 from airbyte_cdk.sources.types import Config
 
-NestedMappingEntry = Union[dict[str, "NestedMapping"], list["NestedMapping"], str, int, float, bool, None]
+NestedMappingEntry = Union[
+    dict[str, "NestedMapping"], list["NestedMapping"], str, int, float, bool, None
+]
 NestedMapping = Union[dict[str, NestedMappingEntry], str]
 
 
@@ -32,12 +34,17 @@ class InterpolatedNestedMapping:
     def eval(self, config: Config, **additional_parameters: Any) -> Any:
         return self._eval(self.mapping, config, **additional_parameters)
 
-    def _eval(self, value: Union[NestedMapping, NestedMappingEntry], config: Config, **kwargs: Any) -> Any:
+    def _eval(
+        self, value: Union[NestedMapping, NestedMappingEntry], config: Config, **kwargs: Any
+    ) -> Any:
         # Recursively interpolate dictionaries and lists
         if isinstance(value, str):
             return self._interpolation.eval(value, config, parameters=self._parameters, **kwargs)
         elif isinstance(value, dict):
-            interpolated_dict = {self._eval(k, config, **kwargs): self._eval(v, config, **kwargs) for k, v in value.items()}
+            interpolated_dict = {
+                self._eval(k, config, **kwargs): self._eval(v, config, **kwargs)
+                for k, v in value.items()
+            }
             return {k: v for k, v in interpolated_dict.items() if v is not None}
         elif isinstance(value, list):
             return [self._eval(v, config, **kwargs) for v in value]

airbyte_cdk/sources/declarative/interpolation/interpolated_string.py

@@ -45,10 +45,14 @@ class InterpolatedString:
         if self._is_plain_string is None:
             # Let's check whether output from evaluation is the same as input.
             # This indicates occurrence of a plain string, not a template and we can skip Jinja in subsequent runs.
-            evaluated = self._interpolation.eval(self.string, config, self.default, parameters=self._parameters, **kwargs)
+            evaluated = self._interpolation.eval(
+                self.string, config, self.default, parameters=self._parameters, **kwargs
+            )
             self._is_plain_string = self.string == evaluated
             return evaluated
-        return self._interpolation.eval(self.string, config, self.default, parameters=self._parameters, **kwargs)
+        return self._interpolation.eval(
+            self.string, config, self.default, parameters=self._parameters, **kwargs
+        )
 
     def __eq__(self, other: Any) -> bool:
         if not isinstance(other, InterpolatedString):

airbyte_cdk/sources/declarative/interpolation/interpolation.py

@@ -14,7 +14,13 @@ class Interpolation(ABC):
     """
 
     @abstractmethod
-    def eval(self, input_str: str, config: Config, default: Optional[str] = None, **additional_options: Any) -> Any:
+    def eval(
+        self,
+        input_str: str,
+        config: Config,
+        default: Optional[str] = None,
+        **additional_options: Any,
+    ) -> Any:
         """
         Interpolates the input string using the config, and additional options passed as parameter.
 

airbyte_cdk/sources/declarative/interpolation/jinja.py

@@ -61,7 +61,9 @@ class JinjaInterpolation(Interpolation):
     # By default, these Python builtin functions are available in the Jinja context.
     # We explicitely remove them because of the potential security risk.
     # Please add a unit test to test_jinja.py when adding a restriction.
-    RESTRICTED_BUILTIN_FUNCTIONS = ["range"]  # The range function can cause very expensive computations
+    RESTRICTED_BUILTIN_FUNCTIONS = [
+        "range"
+    ]  # The range function can cause very expensive computations
 
     def __init__(self) -> None:
         self._environment = StreamPartitionAccessEnvironment()
@@ -119,7 +121,9 @@ class JinjaInterpolation(Interpolation):
             undeclared = self._find_undeclared_variables(s)
             undeclared_not_in_context = {var for var in undeclared if var not in context}
             if undeclared_not_in_context:
-                raise ValueError(f"Jinja macro has undeclared variables: {undeclared_not_in_context}. Context: {context}")
+                raise ValueError(
+                    f"Jinja macro has undeclared variables: {undeclared_not_in_context}. Context: {context}"
+                )
             return self._compile(s).render(context)  # type: ignore # from_string is able to handle None
         except TypeError:
             # The string is a static value, not a jinja template

airbyte_cdk/sources/declarative/interpolation/macros.py

@@ -104,7 +104,9 @@ def day_delta(num_days: int, format: str = "%Y-%m-%dT%H:%M:%S.%f%z") -> str:
     :param num_days: number of days to add to current date time
     :return: datetime formatted as RFC3339
     """
-    return (datetime.datetime.now(datetime.timezone.utc) + datetime.timedelta(days=num_days)).strftime(format)
+    return (
+        datetime.datetime.now(datetime.timezone.utc) + datetime.timedelta(days=num_days)
+    ).strftime(format)
 
 
 def duration(datestring: str) -> Union[datetime.timedelta, isodate.Duration]:
@@ -117,7 +119,9 @@ def duration(datestring: str) -> Union[datetime.timedelta, isodate.Duration]:
     return parse_duration(datestring)  # type: ignore # mypy thinks this returns Any for some reason
 
 
-def format_datetime(dt: Union[str, datetime.datetime], format: str, input_format: Optional[str] = None) -> str:
+def format_datetime(
+    dt: Union[str, datetime.datetime], format: str, input_format: Optional[str] = None
+) -> str:
     """
     Converts datetime to another format
 
@@ -130,11 +134,22 @@ def format_datetime(dt: Union[str, datetime.datetime], format: str, input_format
     """
     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)
+    dt_datetime = (
+        datetime.datetime.strptime(dt, input_format) if input_format else _str_to_datetime(dt)
+    )
     if format == "%s":
         return str(int(dt_datetime.timestamp()))
     return dt_datetime.strftime(format)
 
 
-_macros_list = [now_utc, today_utc, timestamp, max, day_delta, duration, format_datetime, today_with_timezone]
+_macros_list = [
+    now_utc,
+    today_utc,
+    timestamp,
+    max,
+    day_delta,
+    duration,
+    format_datetime,
+    today_with_timezone,
+]
 macros = {f.__name__: f for f in _macros_list}

airbyte_cdk/sources/declarative/manifest_declarative_source.py

@@ -20,16 +20,30 @@ from airbyte_cdk.models import (
 )
 from airbyte_cdk.sources.declarative.checks.connection_checker import ConnectionChecker
 from airbyte_cdk.sources.declarative.declarative_source import DeclarativeSource
-from airbyte_cdk.sources.declarative.models.declarative_component_schema import CheckStream as CheckStreamModel
-from airbyte_cdk.sources.declarative.models.declarative_component_schema import DeclarativeStream as DeclarativeStreamModel
+from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
+    CheckStream as CheckStreamModel,
+)
+from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
+    DeclarativeStream as DeclarativeStreamModel,
+)
 from airbyte_cdk.sources.declarative.models.declarative_component_schema import Spec as SpecModel
-from airbyte_cdk.sources.declarative.parsers.manifest_component_transformer import ManifestComponentTransformer
-from airbyte_cdk.sources.declarative.parsers.manifest_reference_resolver import ManifestReferenceResolver
-from airbyte_cdk.sources.declarative.parsers.model_to_component_factory import ModelToComponentFactory
+from airbyte_cdk.sources.declarative.parsers.manifest_component_transformer import (
+    ManifestComponentTransformer,
+)
+from airbyte_cdk.sources.declarative.parsers.manifest_reference_resolver import (
+    ManifestReferenceResolver,
+)
+from airbyte_cdk.sources.declarative.parsers.model_to_component_factory import (
+    ModelToComponentFactory,
+)
 from airbyte_cdk.sources.message import MessageRepository
 from airbyte_cdk.sources.streams.core import Stream
 from airbyte_cdk.sources.types import ConnectionDefinition
-from airbyte_cdk.sources.utils.slice_logger import AlwaysLogSliceLogger, DebugSliceLogger, SliceLogger
+from airbyte_cdk.sources.utils.slice_logger import (
+    AlwaysLogSliceLogger,
+    DebugSliceLogger,
+    SliceLogger,
+)
 from jsonschema.exceptions import ValidationError
 from jsonschema.validators import validate
 
@@ -57,13 +71,21 @@ class ManifestDeclarativeSource(DeclarativeSource):
             manifest["type"] = "DeclarativeSource"
 
         resolved_source_config = ManifestReferenceResolver().preprocess_manifest(manifest)
-        propagated_source_config = ManifestComponentTransformer().propagate_types_and_parameters("", resolved_source_config, {})
+        propagated_source_config = ManifestComponentTransformer().propagate_types_and_parameters(
+            "", resolved_source_config, {}
+        )
         self._source_config = propagated_source_config
         self._debug = debug
         self._emit_connector_builder_messages = emit_connector_builder_messages
-        self._constructor = component_factory if component_factory else ModelToComponentFactory(emit_connector_builder_messages)
+        self._constructor = (
+            component_factory
+            if component_factory
+            else ModelToComponentFactory(emit_connector_builder_messages)
+        )
         self._message_repository = self._constructor.get_message_repository()
-        self._slice_logger: SliceLogger = AlwaysLogSliceLogger() if emit_connector_builder_messages else DebugSliceLogger()
+        self._slice_logger: SliceLogger = (
+            AlwaysLogSliceLogger() if emit_connector_builder_messages else DebugSliceLogger()
+        )
 
         self._validate_source()
 
@@ -81,20 +103,30 @@ class ManifestDeclarativeSource(DeclarativeSource):
         if "type" not in check:
             check["type"] = "CheckStream"
         check_stream = self._constructor.create_component(
-            CheckStreamModel, check, dict(), emit_connector_builder_messages=self._emit_connector_builder_messages
+            CheckStreamModel,
+            check,
+            dict(),
+            emit_connector_builder_messages=self._emit_connector_builder_messages,
         )
         if isinstance(check_stream, ConnectionChecker):
             return check_stream
         else:
-            raise ValueError(f"Expected to generate a ConnectionChecker component, but received {check_stream.__class__}")
+            raise ValueError(
+                f"Expected to generate a ConnectionChecker component, but received {check_stream.__class__}"
+            )
 
     def streams(self, config: Mapping[str, Any]) -> List[Stream]:
-        self._emit_manifest_debug_message(extra_args={"source_name": self.name, "parsed_config": json.dumps(self._source_config)})
+        self._emit_manifest_debug_message(
+            extra_args={"source_name": self.name, "parsed_config": json.dumps(self._source_config)}
+        )
         stream_configs = self._stream_configs(self._source_config)
 
         source_streams = [
             self._constructor.create_component(
-                DeclarativeStreamModel, stream_config, config, emit_connector_builder_messages=self._emit_connector_builder_messages
+                DeclarativeStreamModel,
+                stream_config,
+                config,
+                emit_connector_builder_messages=self._emit_connector_builder_messages,
             )
             for stream_config in self._initialize_cache_for_parent_streams(deepcopy(stream_configs))
         ]
@@ -102,7 +134,9 @@ class ManifestDeclarativeSource(DeclarativeSource):
         return source_streams
 
     @staticmethod
-    def _initialize_cache_for_parent_streams(stream_configs: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    def _initialize_cache_for_parent_streams(
+        stream_configs: List[Dict[str, Any]],
+    ) -> List[Dict[str, Any]]:
         parent_streams = set()
 
         def update_with_cache_parent_configs(parent_configs: list[dict[str, Any]]) -> None:
@@ -113,12 +147,16 @@ class ManifestDeclarativeSource(DeclarativeSource):
         for stream_config in stream_configs:
             if stream_config.get("incremental_sync", {}).get("parent_stream"):
                 parent_streams.add(stream_config["incremental_sync"]["parent_stream"]["name"])
-                stream_config["incremental_sync"]["parent_stream"]["retriever"]["requester"]["use_cache"] = True
+                stream_config["incremental_sync"]["parent_stream"]["retriever"]["requester"][
+                    "use_cache"
+                ] = True
 
             elif stream_config.get("retriever", {}).get("partition_router", {}):
                 partition_router = stream_config["retriever"]["partition_router"]
 
-                if isinstance(partition_router, dict) and partition_router.get("parent_stream_configs"):
+                if isinstance(partition_router, dict) and partition_router.get(
+                    "parent_stream_configs"
+                ):
                     update_with_cache_parent_configs(partition_router["parent_stream_configs"])
                 elif isinstance(partition_router, list):
                     for router in partition_router:
@@ -139,7 +177,9 @@ class ManifestDeclarativeSource(DeclarativeSource):
         in the project root.
         """
         self._configure_logger_level(logger)
-        self._emit_manifest_debug_message(extra_args={"source_name": self.name, "parsed_config": json.dumps(self._source_config)})
+        self._emit_manifest_debug_message(
+            extra_args={"source_name": self.name, "parsed_config": json.dumps(self._source_config)}
+        )
 
         spec = self._source_config.get("spec")
         if spec:
@@ -176,22 +216,62 @@ class ManifestDeclarativeSource(DeclarativeSource):
         Validates the connector manifest against the declarative component schema
         """
         try:
-            raw_component_schema = pkgutil.get_data("airbyte_cdk", "sources/declarative/declarative_component_schema.yaml")
+            raw_component_schema = pkgutil.get_data(
+                "airbyte_cdk", "sources/declarative/declarative_component_schema.yaml"
+            )
             if raw_component_schema is not None:
-                declarative_component_schema = yaml.load(raw_component_schema, Loader=yaml.SafeLoader)
+                declarative_component_schema = yaml.load(
+                    raw_component_schema, Loader=yaml.SafeLoader
+                )
             else:
-                raise RuntimeError("Failed to read manifest component json schema required for validation")
+                raise RuntimeError(
+                    "Failed to read manifest component json schema required for validation"
+                )
         except FileNotFoundError as e:
-            raise FileNotFoundError(f"Failed to read manifest component json schema required for validation: {e}")
+            raise FileNotFoundError(
+                f"Failed to read manifest component json schema required for validation: {e}"
+            )
 
         streams = self._source_config.get("streams")
         if not streams:
-            raise ValidationError(f"A valid manifest should have at least one stream defined. Got {streams}")
+            raise ValidationError(
+                f"A valid manifest should have at least one stream defined. Got {streams}"
+            )
 
         try:
             validate(self._source_config, declarative_component_schema)
         except ValidationError as e:
-            raise ValidationError("Validation against json schema defined in declarative_component_schema.yaml schema failed") from e
+            raise ValidationError(
+                "Validation against json schema defined in declarative_component_schema.yaml schema failed"
+            ) from e
+
+        cdk_version = metadata.version("airbyte_cdk")
+        cdk_major, cdk_minor, cdk_patch = self._get_version_parts(cdk_version, "airbyte-cdk")
+        manifest_version = self._source_config.get("version")
+        if manifest_version is None:
+            raise RuntimeError(
+                "Manifest version is not defined in the manifest. This is unexpected since it should be a required field. Please contact support."
+            )
+        manifest_major, manifest_minor, manifest_patch = self._get_version_parts(
+            manifest_version, "manifest"
+        )
+
+        if cdk_version.startswith("0.0.0"):
+            # Skipping version compatibility check on unreleased dev branch
+            pass
+        elif cdk_major < manifest_major or (
+            cdk_major == manifest_major and cdk_minor < manifest_minor
+        ):
+            raise ValidationError(
+                f"The manifest version {manifest_version} is greater than the airbyte-cdk package version ({cdk_version}). Your "
+                f"manifest may contain features that are not in the current CDK version."
+            )
+        elif manifest_major == 0 and manifest_minor < 29:
+            raise ValidationError(
+                f"The low-code framework was promoted to Beta in airbyte-cdk version 0.29.0 and contains many breaking changes to the "
+                f"language. The manifest version {manifest_version} is incompatible with the airbyte-cdk package version "
+                f"{cdk_version} which contains these breaking changes."
+            )
 
     @staticmethod
     def _get_version_parts(version: str, version_type: str) -> Tuple[int, int, int]:
@@ -200,7 +280,9 @@ class ManifestDeclarativeSource(DeclarativeSource):
         """
         version_parts = re.split(r"\.", version)
         if len(version_parts) != 3 or not all([part.isdigit() for part in version_parts]):
-            raise ValidationError(f"The {version_type} version {version} specified is not a valid version format (ex. 1.2.3)")
+            raise ValidationError(
+                f"The {version_type} version {version} specified is not a valid version format (ex. 1.2.3)"
+            )
         return tuple(int(part) for part in version_parts)  # type: ignore # We already verified there were 3 parts and they are all digits
 
     def _stream_configs(self, manifest: Mapping[str, Any]) -> List[Dict[str, Any]]: