airbyte-cdk 6.9.1__py3-none-any.whl → 6.9.1.dev1__py3-none-any.whl

airbyte_cdk/sources/declarative/concurrent_declarative_source.py

@@ -56,9 +56,8 @@ from airbyte_cdk.sources.types import Config, StreamState
 
 
 class ConcurrentDeclarativeSource(ManifestDeclarativeSource, Generic[TState]):
-    # By default, we defer to a value of 2. A value lower than than could cause a PartitionEnqueuer to be stuck in a state of deadlock
-    # because it has hit the limit of futures but not partition reader is consuming them.
-    _LOWEST_SAFE_CONCURRENCY_LEVEL = 2
+    # By default, we defer to a value of 1 which represents running a connector using the Concurrent CDK engine on only one thread.
+    SINGLE_THREADED_CONCURRENCY_LEVEL = 1
 
     def __init__(
         self,
@@ -87,10 +86,23 @@ class ConcurrentDeclarativeSource(ManifestDeclarativeSource, Generic[TState]):
             component_factory=component_factory,
         )
 
-        # todo: We could remove state from initialization. Now that streams are grouped during the read(), a source
-        #  no longer needs to store the original incoming state. But maybe there's an edge case?
         self._state = state
 
+        self._concurrent_streams: Optional[List[AbstractStream]]
+        self._synchronous_streams: Optional[List[Stream]]
+
+        # If the connector command was SPEC, there is no incoming config, and we cannot instantiate streams because
+        # they might depend on it. Ideally we want to have a static method on this class to get the spec without
+        # any other arguments, but the existing entrypoint.py isn't designed to support this. Just noting this
+        # for our future improvements to the CDK.
+        if config:
+            self._concurrent_streams, self._synchronous_streams = self._group_streams(
+                config=config or {}
+            )
+        else:
+            self._concurrent_streams = None
+            self._synchronous_streams = None
+
         concurrency_level_from_manifest = self._source_config.get("concurrency_level")
         if concurrency_level_from_manifest:
             concurrency_level_component = self._constructor.create_component(
@@ -108,8 +120,8 @@ class ConcurrentDeclarativeSource(ManifestDeclarativeSource, Generic[TState]):
                 concurrency_level // 2, 1
             )  # Partition_generation iterates using range based on this value. If this is floored to zero we end up in a dead lock during start up
         else:
-            concurrency_level = self._LOWEST_SAFE_CONCURRENCY_LEVEL
-            initial_number_of_partitions_to_generate = self._LOWEST_SAFE_CONCURRENCY_LEVEL // 2
+            concurrency_level = self.SINGLE_THREADED_CONCURRENCY_LEVEL
+            initial_number_of_partitions_to_generate = self.SINGLE_THREADED_CONCURRENCY_LEVEL
 
         self._concurrent_source = ConcurrentSource.create(
             num_workers=concurrency_level,
@@ -124,20 +136,17 @@ class ConcurrentDeclarativeSource(ManifestDeclarativeSource, Generic[TState]):
         logger: logging.Logger,
         config: Mapping[str, Any],
         catalog: ConfiguredAirbyteCatalog,
-        state: Optional[List[AirbyteStateMessage]] = None,
+        state: Optional[Union[List[AirbyteStateMessage]]] = None,
     ) -> Iterator[AirbyteMessage]:
-        concurrent_streams, _ = self._group_streams(config=config)
-
-        # ConcurrentReadProcessor pops streams that are finished being read so before syncing, the names of
-        # the concurrent streams must be saved so that they can be removed from the catalog before starting
-        # synchronous streams
-        if len(concurrent_streams) > 0:
+        # ConcurrentReadProcessor pops streams that are finished being read so before syncing, the names of the concurrent
+        # streams must be saved so that they can be removed from the catalog before starting synchronous streams
+        if self._concurrent_streams:
             concurrent_stream_names = set(
-                [concurrent_stream.name for concurrent_stream in concurrent_streams]
+                [concurrent_stream.name for concurrent_stream in self._concurrent_streams]
             )
 
             selected_concurrent_streams = self._select_streams(
-                streams=concurrent_streams, configured_catalog=catalog
+                streams=self._concurrent_streams, configured_catalog=catalog
             )
             # It would appear that passing in an empty set of streams causes an infinite loop in ConcurrentReadProcessor.
             # This is also evident in concurrent_source_adapter.py so I'll leave this out of scope to fix for now
@@ -156,7 +165,8 @@ class ConcurrentDeclarativeSource(ManifestDeclarativeSource, Generic[TState]):
         yield from super().read(logger, config, filtered_catalog, state)
 
     def discover(self, logger: logging.Logger, config: Mapping[str, Any]) -> AirbyteCatalog:
-        concurrent_streams, synchronous_streams = self._group_streams(config=config)
+        concurrent_streams = self._concurrent_streams or []
+        synchronous_streams = self._synchronous_streams or []
         return AirbyteCatalog(
             streams=[
                 stream.as_airbyte_stream() for stream in concurrent_streams + synchronous_streams
@@ -182,13 +192,9 @@ class ConcurrentDeclarativeSource(ManifestDeclarativeSource, Generic[TState]):
 
         state_manager = ConnectorStateManager(state=self._state)  # type: ignore  # state is always in the form of List[AirbyteStateMessage]. The ConnectorStateManager should use generics, but this can be done later
 
-        # Combine streams and dynamic_streams. Note: both cannot be empty at the same time,
-        # and this is validated during the initialization of the source.
-        streams = self._stream_configs(self._source_config) + self._dynamic_stream_configs(
-            self._source_config, config
-        )
-
-        name_to_stream_mapping = {stream["name"]: stream for stream in streams}
+        name_to_stream_mapping = {
+            stream["name"]: stream for stream in self.resolved_manifest["streams"]
+        }
 
         for declarative_stream in self.streams(config=config):
             # Some low-code sources use a combination of DeclarativeStream and regular Python streams. We can't inspect
@@ -196,7 +202,7 @@ class ConcurrentDeclarativeSource(ManifestDeclarativeSource, Generic[TState]):
             # so we need to treat them as synchronous
             if (
                 isinstance(declarative_stream, DeclarativeStream)
-                and name_to_stream_mapping[declarative_stream.name]["retriever"]["type"]
+                and name_to_stream_mapping[declarative_stream.name].get("retriever")["type"]
                 == "SimpleRetriever"
             ):
                 incremental_sync_component_definition = name_to_stream_mapping[
@@ -205,7 +211,7 @@ class ConcurrentDeclarativeSource(ManifestDeclarativeSource, Generic[TState]):
 
                 partition_router_component_definition = (
                     name_to_stream_mapping[declarative_stream.name]
-                    .get("retriever", {})
+                    .get("retriever")
                     .get("partition_router")
                 )
                 is_without_partition_router_or_cursor = not bool(
@@ -227,7 +233,7 @@ class ConcurrentDeclarativeSource(ManifestDeclarativeSource, Generic[TState]):
                     cursor = self._constructor.create_concurrent_cursor_from_datetime_based_cursor(
                         state_manager=state_manager,
                         model_type=DatetimeBasedCursorModel,
-                        component_definition=incremental_sync_component_definition,  # type: ignore  # Not None because of the if condition above
+                        component_definition=incremental_sync_component_definition,
                         stream_name=declarative_stream.name,
                         stream_namespace=declarative_stream.namespace,
                         config=config or {},
@@ -310,11 +316,10 @@ class ConcurrentDeclarativeSource(ManifestDeclarativeSource, Generic[TState]):
     def _is_datetime_incremental_without_partition_routing(
         self,
         declarative_stream: DeclarativeStream,
-        incremental_sync_component_definition: Mapping[str, Any] | None,
+        incremental_sync_component_definition: Mapping[str, Any],
     ) -> bool:
         return (
-            incremental_sync_component_definition is not None
-            and bool(incremental_sync_component_definition)
+            bool(incremental_sync_component_definition)
             and incremental_sync_component_definition.get("type", "")
             == DatetimeBasedCursorModel.__name__
             and self._stream_supports_concurrent_partition_processing(

airbyte_cdk/sources/declarative/declarative_component_schema.yaml

@@ -7,12 +7,8 @@ version: 1.0.0
 required:
   - type
   - check
+  - streams
   - version
-anyOf:
-  - required:
-      - streams
-  - required:
-      - dynamic_streams
 properties:
   type:
     type: string
@@ -23,10 +19,6 @@ properties:
     type: array
     items:
       "$ref": "#/definitions/DeclarativeStream"
-  dynamic_streams:
-    type: array
-    items:
-      "$ref": "#/definitions/DynamicDeclarativeStream"
   version:
     type: string
     description: The version of the Airbyte CDK used to build and test the source.
@@ -327,7 +319,7 @@ definitions:
         additionalProperties: true
   ConcurrencyLevel:
     title: Concurrency Level
-    description: Defines the amount of parallelization for the streams that are being synced. The factor of parallelization is how many partitions or streams are synced at the same time. For example, with a concurrency_level of 10, ten streams or partitions of data will processed at the same time. Note that a value of 1 could create deadlock if a stream has a very high number of partitions.
+    description: Defines the amount of parallelization for the streams that are being synced. The factor of parallelization is how many partitions or streams are synced at the same time. For example, with a concurrency_level of 10, ten streams or partitions of data will processed at the same time.
     type: object
     required:
       - default_concurrency
@@ -1329,7 +1321,7 @@ definitions:
         type: array
         items:
           - type: string
-        interpolation_context:
+        interpolation_content:
           - config
         examples:
           - ["data"]
@@ -2903,96 +2895,6 @@ definitions:
       $parameters:
         type: object
         additionalProperties: true
-  ComponentMappingDefinition:
-    title: Component Mapping Definition
-    description: (This component is experimental. Use at your own risk.) Specifies a mapping definition to update or add fields in a record or configuration. This allows dynamic mapping of data by interpolating values into the template based on provided contexts.
-    type: object
-    required:
-      - type
-      - field_path
-      - value
-    properties:
-      type:
-        type: string
-        enum: [ComponentMappingDefinition]
-      field_path:
-        title: Field Path
-        description: A list of potentially nested fields indicating the full path where value will be added or updated.
-        type: array
-        items:
-          - type: string
-        interpolation_context:
-          - config
-          - components_values
-          - stream_template_config
-        examples:
-          - ["data"]
-          - ["data", "records"]
-          - ["data", "{{ parameters.name }}"]
-          - ["data", "*", "record"]
-      value:
-        title: Value
-        description: The dynamic or static value to assign to the key. Interpolated values can be used to dynamically determine the value during runtime.
-        type: string
-        interpolation_context:
-          - config
-          - stream_template_config
-          - components_values
-        examples:
-          - "{{ components_values['updates'] }}"
-          - "{{ components_values['MetaData']['LastUpdatedTime'] }}"
-          - "{{ config['segment_id'] }}"
-      value_type:
-        title: Value Type
-        description: The expected data type of the value. If omitted, the type will be inferred from the value provided.
-        "$ref": "#/definitions/ValueType"
-      $parameters:
-        type: object
-        additionalProperties: true
-  HttpComponentsResolver:
-    type: object
-    description: (This component is experimental. Use at your own risk.) Component resolve and populates stream templates with components fetched via an HTTP retriever.
-    properties:
-      type:
-        type: string
-        enum: [HttpComponentsResolver]
-      retriever:
-        title: Retriever
-        description: Component used to coordinate how records are extracted across stream slices and request pages.
-        anyOf:
-          - "$ref": "#/definitions/AsyncRetriever"
-          - "$ref": "#/definitions/CustomRetriever"
-          - "$ref": "#/definitions/SimpleRetriever"
-      components_mapping:
-        type: array
-        items:
-          "$ref": "#/definitions/ComponentMappingDefinition"
-      $parameters:
-        type: object
-        additionalProperties: true
-    required:
-      - type
-      - retriever
-      - components_mapping
-  DynamicDeclarativeStream:
-    type: object
-    description: (This component is experimental. Use at your own risk.) A component that described how will be created declarative streams based on stream template.
-    properties:
-      type:
-        type: string
-        enum: [DynamicDeclarativeStream]
-      stream_template:
-        title: Stream Template
-        description: Reference to the stream template.
-        "$ref": "#/definitions/DeclarativeStream"
-      components_resolver:
-        title: Components Resolver
-        description: Component resolve and populates stream templates with components values.
-        "$ref": "#/definitions/HttpComponentsResolver"
-    required:
-      - type
-      - stream_template
-      - components_resolver
 interpolation:
   variables:
     - title: config

airbyte_cdk/sources/declarative/interpolation/jinja.py

@@ -4,7 +4,7 @@
 
 import ast
 from functools import cache
-from typing import Any, Mapping, Optional, Set, Tuple, Type
+from typing import Any, Mapping, Optional, Tuple, Type
 
 from jinja2 import meta
 from jinja2.environment import Template
@@ -27,35 +27,7 @@ class StreamPartitionAccessEnvironment(SandboxedEnvironment):
     def is_safe_attribute(self, obj: Any, attr: str, value: Any) -> bool:
         if attr in ["_partition"]:
             return True
-        return super().is_safe_attribute(obj, attr, value)  # type: ignore  # for some reason, mypy says 'Returning Any from function declared to return "bool"'
-
-
-# These aliases are used to deprecate existing keywords without breaking all existing connectors.
-_ALIASES = {
-    "stream_interval": "stream_slice",  # Use stream_interval to access incremental_sync values
-    "stream_partition": "stream_slice",  # Use stream_partition to access partition router's values
-}
-
-# 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
-_RESTRICTED_EXTENSIONS = ["jinja2.ext.loopcontrols"]  # Adds support for break continue in loops
-
-# By default, these Python builtin functions are available in the Jinja context.
-# We explicitly 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
-
-_ENVIRONMENT = StreamPartitionAccessEnvironment()
-_ENVIRONMENT.filters.update(**filters)
-_ENVIRONMENT.globals.update(**macros)
-
-for extension in _RESTRICTED_EXTENSIONS:
-    _ENVIRONMENT.extensions.pop(extension, None)
-for builtin in _RESTRICTED_BUILTIN_FUNCTIONS:
-    _ENVIRONMENT.globals.pop(builtin, None)
+        return super().is_safe_attribute(obj, attr, value)
 
 
 class JinjaInterpolation(Interpolation):
@@ -76,6 +48,34 @@ class JinjaInterpolation(Interpolation):
     Additional information on jinja templating can be found at https://jinja.palletsprojects.com/en/3.1.x/templates/#
     """
 
+    # These aliases are used to deprecate existing keywords without breaking all existing connectors.
+    ALIASES = {
+        "stream_interval": "stream_slice",  # Use stream_interval to access incremental_sync values
+        "stream_partition": "stream_slice",  # Use stream_partition to access partition router's values
+    }
+
+    # These extensions are not installed so they're not currently a problem,
+    # but we're still explicitely 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
+    RESTRICTED_EXTENSIONS = ["jinja2.ext.loopcontrols"]  # Adds support for break continue in loops
+
+    # 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
+
+    def __init__(self) -> None:
+        self._environment = StreamPartitionAccessEnvironment()
+        self._environment.filters.update(**filters)
+        self._environment.globals.update(**macros)
+
+        for extension in self.RESTRICTED_EXTENSIONS:
+            self._environment.extensions.pop(extension, None)
+        for builtin in self.RESTRICTED_BUILTIN_FUNCTIONS:
+            self._environment.globals.pop(builtin, None)
+
     def eval(
         self,
         input_str: str,
@@ -86,7 +86,7 @@ class JinjaInterpolation(Interpolation):
     ) -> Any:
         context = {"config": config, **additional_parameters}
 
-        for alias, equivalent in _ALIASES.items():
+        for alias, equivalent in self.ALIASES.items():
             if alias in context:
                 # This is unexpected. We could ignore or log a warning, but failing loudly should result in fewer surprises
                 raise ValueError(
@@ -105,7 +105,6 @@ class JinjaInterpolation(Interpolation):
                 raise Exception(f"Expected a string, got {input_str}")
         except UndefinedError:
             pass
-
         # If result is empty or resulted in an undefined error, evaluate and return the default string
         return self._literal_eval(self._eval(default, context), valid_types)
 
@@ -133,16 +132,16 @@ class JinjaInterpolation(Interpolation):
             return s
 
     @cache
-    def _find_undeclared_variables(self, s: Optional[str]) -> Set[str]:
+    def _find_undeclared_variables(self, s: Optional[str]) -> set[str]:
         """
         Find undeclared variables and cache them
         """
-        ast = _ENVIRONMENT.parse(s)  # type: ignore # parse is able to handle None
+        ast = self._environment.parse(s)  # type: ignore # parse is able to handle None
         return meta.find_undeclared_variables(ast)
 
     @cache
-    def _compile(self, s: str) -> Template:
+    def _compile(self, s: Optional[str]) -> Template:
         """
         We must cache the Jinja Template ourselves because we're using `from_string` instead of a template loader
         """
-        return _ENVIRONMENT.from_string(s)
+        return self._environment.from_string(s)  # type: ignore [arg-type]  # Expected `str | Template` but passed `str | None`

airbyte_cdk/sources/declarative/manifest_declarative_source.py

@@ -39,7 +39,6 @@ from airbyte_cdk.sources.declarative.parsers.manifest_reference_resolver import
 from airbyte_cdk.sources.declarative.parsers.model_to_component_factory import (
     ModelToComponentFactory,
 )
-from airbyte_cdk.sources.declarative.resolvers import COMPONENTS_RESOLVER_TYPE_MAPPING
 from airbyte_cdk.sources.message import MessageRepository
 from airbyte_cdk.sources.streams.core import Stream
 from airbyte_cdk.sources.types import ConnectionDefinition
@@ -121,10 +120,7 @@ class ManifestDeclarativeSource(DeclarativeSource):
         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) + self._dynamic_stream_configs(
-            self._source_config, config
-        )
+        stream_configs = self._stream_configs(self._source_config)
 
         source_streams = [
             self._constructor.create_component(
@@ -238,8 +234,7 @@ class ManifestDeclarativeSource(DeclarativeSource):
             )
 
         streams = self._source_config.get("streams")
-        dynamic_streams = self._source_config.get("dynamic_streams")
-        if not (streams or dynamic_streams):
+        if not streams:
             raise ValidationError(
                 f"A valid manifest should have at least one stream defined. Got {streams}"
             )
@@ -308,51 +303,5 @@ class ManifestDeclarativeSource(DeclarativeSource):
                 s["type"] = "DeclarativeStream"
         return stream_configs
 
-    def _dynamic_stream_configs(
-        self, manifest: Mapping[str, Any], config: Mapping[str, Any]
-    ) -> List[Dict[str, Any]]:
-        dynamic_stream_definitions: List[Dict[str, Any]] = manifest.get("dynamic_streams", [])
-        dynamic_stream_configs: List[Dict[str, Any]] = []
-
-        for dynamic_definition in dynamic_stream_definitions:
-            components_resolver_config = dynamic_definition["components_resolver"]
-
-            if not components_resolver_config:
-                raise ValueError(
-                    f"Missing 'components_resolver' in dynamic definition: {dynamic_definition}"
-                )
-
-            resolver_type = components_resolver_config.get("type")
-            if not resolver_type:
-                raise ValueError(
-                    f"Missing 'type' in components resolver configuration: {components_resolver_config}"
-                )
-
-            if resolver_type not in COMPONENTS_RESOLVER_TYPE_MAPPING:
-                raise ValueError(
-                    f"Invalid components resolver type '{resolver_type}'. "
-                    f"Expected one of {list(COMPONENTS_RESOLVER_TYPE_MAPPING.keys())}."
-                )
-
-            if "retriever" in components_resolver_config:
-                components_resolver_config["retriever"]["requester"]["use_cache"] = True
-
-            # Create a resolver for dynamic components based on type
-            components_resolver = self._constructor.create_component(
-                COMPONENTS_RESOLVER_TYPE_MAPPING[resolver_type], components_resolver_config, config
-            )
-
-            stream_template_config = dynamic_definition["stream_template"]
-
-            for dynamic_stream in components_resolver.resolve_components(
-                stream_template_config=stream_template_config
-            ):
-                if "type" not in dynamic_stream:
-                    dynamic_stream["type"] = "DeclarativeStream"
-
-                dynamic_stream_configs.append(dynamic_stream)
-
-        return dynamic_stream_configs
-
     def _emit_manifest_debug_message(self, extra_args: dict[str, Any]) -> None:
         self.logger.debug("declarative source created from manifest", extra=extra_args)

airbyte_cdk/sources/declarative/models/declarative_component_schema.py

@@ -1158,37 +1158,6 @@ class WaitUntilTimeFromHeader(BaseModel):
     parameters: Optional[Dict[str, Any]] = Field(None, alias="$parameters")
 
 
-class ComponentMappingDefinition(BaseModel):
-    type: Literal["ComponentMappingDefinition"]
-    field_path: List[str] = Field(
-        ...,
-        description="A list of potentially nested fields indicating the full path where value will be added or updated.",
-        examples=[
-            ["data"],
-            ["data", "records"],
-            ["data", "{{ parameters.name }}"],
-            ["data", "*", "record"],
-        ],
-        title="Field Path",
-    )
-    value: str = Field(
-        ...,
-        description="The dynamic or static value to assign to the key. Interpolated values can be used to dynamically determine the value during runtime.",
-        examples=[
-            "{{ components_values['updates'] }}",
-            "{{ components_values['MetaData']['LastUpdatedTime'] }}",
-            "{{ config['segment_id'] }}",
-        ],
-        title="Value",
-    )
-    value_type: Optional[ValueType] = Field(
-        None,
-        description="The expected data type of the value. If omitted, the type will be inferred from the value provided.",
-        title="Value Type",
-    )
-    parameters: Optional[Dict[str, Any]] = Field(None, alias="$parameters")
-
-
 class AddedFieldDefinition(BaseModel):
     type: Literal["AddedFieldDefinition"]
     path: List[str] = Field(
@@ -1486,40 +1455,13 @@ class CompositeErrorHandler(BaseModel):
     parameters: Optional[Dict[str, Any]] = Field(None, alias="$parameters")
 
 
-class DeclarativeSource1(BaseModel):
+class DeclarativeSource(BaseModel):
     class Config:
         extra = Extra.forbid
 
     type: Literal["DeclarativeSource"]
     check: CheckStream
     streams: List[DeclarativeStream]
-    dynamic_streams: Optional[List[DynamicDeclarativeStream]] = None
-    version: str = Field(
-        ...,
-        description="The version of the Airbyte CDK used to build and test the source.",
-    )
-    schemas: Optional[Schemas] = None
-    definitions: Optional[Dict[str, Any]] = None
-    spec: Optional[Spec] = None
-    concurrency_level: Optional[ConcurrencyLevel] = None
-    metadata: Optional[Dict[str, Any]] = Field(
-        None,
-        description="For internal Airbyte use only - DO NOT modify manually. Used by consumers of declarative manifests for storing related metadata.",
-    )
-    description: Optional[str] = Field(
-        None,
-        description="A description of the connector. It will be presented on the Source documentation page.",
-    )
-
-
-class DeclarativeSource2(BaseModel):
-    class Config:
-        extra = Extra.forbid
-
-    type: Literal["DeclarativeSource"]
-    check: CheckStream
-    streams: Optional[List[DeclarativeStream]] = None
-    dynamic_streams: List[DynamicDeclarativeStream]
     version: str = Field(
         ...,
         description="The version of the Airbyte CDK used to build and test the source.",
@@ -1538,17 +1480,6 @@ class DeclarativeSource2(BaseModel):
     )
 
 
-class DeclarativeSource(BaseModel):
-    class Config:
-        extra = Extra.forbid
-
-    __root__: Union[DeclarativeSource1, DeclarativeSource2] = Field(
-        ...,
-        description="An API source that extracts data according to its declarative components.",
-        title="DeclarativeSource",
-    )
-
-
 class SelectiveAuthenticator(BaseModel):
     class Config:
         extra = Extra.allow
@@ -1952,32 +1883,8 @@ class SubstreamPartitionRouter(BaseModel):
     parameters: Optional[Dict[str, Any]] = Field(None, alias="$parameters")
 
 
-class HttpComponentsResolver(BaseModel):
-    type: Literal["HttpComponentsResolver"]
-    retriever: Union[AsyncRetriever, CustomRetriever, SimpleRetriever] = Field(
-        ...,
-        description="Component used to coordinate how records are extracted across stream slices and request pages.",
-        title="Retriever",
-    )
-    components_mapping: List[ComponentMappingDefinition]
-    parameters: Optional[Dict[str, Any]] = Field(None, alias="$parameters")
-
-
-class DynamicDeclarativeStream(BaseModel):
-    type: Literal["DynamicDeclarativeStream"]
-    stream_template: DeclarativeStream = Field(
-        ..., description="Reference to the stream template.", title="Stream Template"
-    )
-    components_resolver: HttpComponentsResolver = Field(
-        ...,
-        description="Component resolve and populates stream templates with components values.",
-        title="Components Resolver",
-    )
-
-
 CompositeErrorHandler.update_forward_refs()
-DeclarativeSource1.update_forward_refs()
-DeclarativeSource2.update_forward_refs()
+DeclarativeSource.update_forward_refs()
 SelectiveAuthenticator.update_forward_refs()
 DeclarativeStream.update_forward_refs()
 SessionTokenAuthenticator.update_forward_refs()

airbyte_cdk/sources/declarative/parsers/manifest_component_transformer.py

@@ -31,12 +31,6 @@ DEFAULT_MODEL_TYPES: Mapping[str, str] = {
     # DeclarativeStream
     "DeclarativeStream.retriever": "SimpleRetriever",
     "DeclarativeStream.schema_loader": "JsonFileSchemaLoader",
-    # DynamicDeclarativeStream
-    "DynamicDeclarativeStream.stream_template": "DeclarativeStream",
-    "DynamicDeclarativeStream.components_resolver": "HttpComponentsResolver",
-    # HttpComponentsResolver
-    "HttpComponentsResolver.retriever": "SimpleRetriever",
-    "HttpComponentsResolver.components_mapping": "ComponentMappingDefinition",
     # DefaultErrorHandler
     "DefaultErrorHandler.response_filters": "HttpResponseFilter",
     # DefaultPaginator