airbyte-cdk 6.34.0.dev1__py3-none-any.whl → 6.34.1.dev0__py3-none-any.whl

airbyte_cdk/sources/declarative/partition_routers/substream_partition_router.py

@@ -4,7 +4,7 @@
 import copy
 import logging
 from dataclasses import InitVar, dataclass
-from typing import TYPE_CHECKING, Any, Iterable, List, Mapping, MutableMapping, Optional, Union
+from typing import TYPE_CHECKING, Any, Iterable, List, Mapping, Optional, Union
 
 import dpath
 
@@ -118,7 +118,7 @@ class SubstreamPartitionRouter(PartitionRouter):
     def _get_request_option(
         self, option_type: RequestOptionType, stream_slice: Optional[StreamSlice]
     ) -> Mapping[str, Any]:
-        params: MutableMapping[str, Any] = {}
+        params = {}
         if stream_slice:
             for parent_config in self.parent_stream_configs:
                 if (
@@ -128,7 +128,13 @@ class SubstreamPartitionRouter(PartitionRouter):
                     key = parent_config.partition_field.eval(self.config)  # type: ignore # partition_field is always casted to an interpolated string
                     value = stream_slice.get(key)
                     if value:
-                        parent_config.request_option.inject_into_request(params, value, self.config)
+                        params.update(
+                            {
+                                parent_config.request_option.field_name.eval(  # type: ignore [union-attr]
+                                    config=self.config
+                                ): value
+                            }
+                        )
         return params
 
     def stream_slices(self) -> Iterable[StreamSlice]:
@@ -299,33 +305,23 @@ class SubstreamPartitionRouter(PartitionRouter):
 
     def _migrate_child_state_to_parent_state(self, stream_state: StreamState) -> StreamState:
         """
-        Migrate the child or global stream state into the parent stream's state format.
-
-        This method converts the child stream state—or, if present, the global state—into a format that is
-        compatible with parent streams that use incremental synchronization. The migration occurs only for
-        parent streams with incremental dependencies. It filters out per-partition states and retains only the
-        global state in the form {cursor_field: cursor_value}.
+        Migrate the child stream state to the parent stream's state format.
 
-        The method supports multiple input formats:
-          - A simple global state, e.g.:
-                {"updated_at": "2023-05-27T00:00:00Z"}
-          - A state object that contains a "state" key (which is assumed to hold the global state), e.g.:
-                {"state": {"updated_at": "2023-05-27T00:00:00Z"}, ...}
-            In this case, the migration uses the first value from the "state" dictionary.
-          - Any per-partition state formats or other non-simple structures are ignored during migration.
+        This method converts the global or child state into a format compatible with parent
+        streams. The migration occurs only for parent streams with incremental dependencies.
+        The method filters out per-partition states and retains only the global state in the
+        format `{cursor_field: cursor_value}`.
 
         Args:
             stream_state (StreamState): The state to migrate. Expected formats include:
                 - {"updated_at": "2023-05-27T00:00:00Z"}
-                - {"state": {"updated_at": "2023-05-27T00:00:00Z"}, ...}
-                  (In this format, only the first global state value is used, and per-partition states are ignored.)
+                - {"states": [...] } (ignored during migration)
 
         Returns:
             StreamState: A migrated state for parent streams in the format:
                 {
                     "parent_stream_name": {"parent_stream_cursor": "2023-05-27T00:00:00Z"}
                 }
-            where each parent stream with an incremental dependency is assigned its corresponding cursor value.
 
         Example:
             Input: {"updated_at": "2023-05-27T00:00:00Z"}
@@ -336,15 +332,11 @@ class SubstreamPartitionRouter(PartitionRouter):
         substream_state_values = list(stream_state.values())
         substream_state = substream_state_values[0] if substream_state_values else {}
 
-        # Ignore per-partition states or invalid formats.
+        # Ignore per-partition states or invalid formats
         if isinstance(substream_state, (list, dict)) or len(substream_state_values) != 1:
-            # If a global state is present under the key "state", use its first value.
-            if "state" in stream_state and isinstance(stream_state["state"], dict):
-                substream_state = list(stream_state["state"].values())[0]
-            else:
-                return {}
+            return {}
 
-        # Build the parent state for all parent streams with incremental dependencies.
+        # Copy child state to parent streams with incremental dependencies
         parent_state = {}
         if substream_state:
             for parent_config in self.parent_stream_configs:

airbyte_cdk/sources/declarative/requesters/http_requester.py

@@ -22,7 +22,6 @@ from airbyte_cdk.sources.declarative.requesters.request_options.interpolated_req
 )
 from airbyte_cdk.sources.declarative.requesters.requester import HttpMethod, Requester
 from airbyte_cdk.sources.message import MessageRepository, NoopMessageRepository
-from airbyte_cdk.sources.streams.call_rate import APIBudget
 from airbyte_cdk.sources.streams.http import HttpClient
 from airbyte_cdk.sources.streams.http.error_handlers import ErrorHandler
 from airbyte_cdk.sources.types import Config, StreamSlice, StreamState
@@ -56,7 +55,6 @@ class HttpRequester(Requester):
     http_method: Union[str, HttpMethod] = HttpMethod.GET
     request_options_provider: Optional[InterpolatedRequestOptionsProvider] = None
     error_handler: Optional[ErrorHandler] = None
-    api_budget: Optional[APIBudget] = None
     disable_retries: bool = False
     message_repository: MessageRepository = NoopMessageRepository()
     use_cache: bool = False
@@ -93,7 +91,6 @@ class HttpRequester(Requester):
             name=self.name,
             logger=self.logger,
             error_handler=self.error_handler,
-            api_budget=self.api_budget,
             authenticator=self._authenticator,
             use_cache=self.use_cache,
             backoff_strategy=backoff_strategies,
@@ -202,9 +199,6 @@ class HttpRequester(Requester):
         Raise a ValueError if there's a key collision
         Returned merged mapping otherwise
         """
-
-        is_body_json = requester_method.__name__ == "get_request_body_json"
-
         return combine_mappings(
             [
                 requester_method(
@@ -214,8 +208,7 @@ class HttpRequester(Requester):
                 ),
                 auth_options_method(),
                 extra_options,
-            ],
-            allow_same_value_merge=is_body_json,
+            ]
         )
 
     def _request_headers(

airbyte_cdk/sources/declarative/requesters/paginators/default_paginator.py

@@ -23,9 +23,6 @@ from airbyte_cdk.sources.declarative.requesters.request_option import (
 )
 from airbyte_cdk.sources.declarative.requesters.request_path import RequestPath
 from airbyte_cdk.sources.types import Config, Record, StreamSlice, StreamState
-from airbyte_cdk.utils.mapping_helpers import (
-    _validate_component_request_option_paths,
-)
 
 
 @dataclass
@@ -116,13 +113,6 @@ class DefaultPaginator(Paginator):
         if isinstance(self.url_base, str):
             self.url_base = InterpolatedString(string=self.url_base, parameters=parameters)
 
-        if self.page_token_option and not isinstance(self.page_token_option, RequestPath):
-            _validate_component_request_option_paths(
-                self.config,
-                self.page_size_option,
-                self.page_token_option,
-            )
-
     def get_initial_token(self) -> Optional[Any]:
         """
         Return the page token that should be used for the first request of a stream
@@ -197,7 +187,7 @@ class DefaultPaginator(Paginator):
     def _get_request_options(
         self, option_type: RequestOptionType, next_page_token: Optional[Mapping[str, Any]]
     ) -> MutableMapping[str, Any]:
-        options: MutableMapping[str, Any] = {}
+        options = {}
 
         token = next_page_token.get("next_page_token") if next_page_token else None
         if (
@@ -206,16 +196,15 @@ class DefaultPaginator(Paginator):
             and isinstance(self.page_token_option, RequestOption)
             and self.page_token_option.inject_into == option_type
         ):
-            self.page_token_option.inject_into_request(options, token, self.config)
-
+            options[self.page_token_option.field_name.eval(config=self.config)] = token  # type: ignore # field_name is always cast to an interpolated string
         if (
             self.page_size_option
             and self.pagination_strategy.get_page_size()
             and self.page_size_option.inject_into == option_type
         ):
-            page_size = self.pagination_strategy.get_page_size()
-            self.page_size_option.inject_into_request(options, page_size, self.config)
-
+            options[self.page_size_option.field_name.eval(config=self.config)] = (  # type: ignore [union-attr]
+                self.pagination_strategy.get_page_size()
+            )  # type: ignore # field_name is always cast to an interpolated string
         return options
 
 

airbyte_cdk/sources/declarative/requesters/request_option.py

@@ -4,10 +4,9 @@
 
 from dataclasses import InitVar, dataclass
 from enum import Enum
-from typing import Any, List, Literal, Mapping, MutableMapping, Optional, Union
+from typing import Any, Mapping, Union
 
 from airbyte_cdk.sources.declarative.interpolation.interpolated_string import InterpolatedString
-from airbyte_cdk.sources.types import Config
 
 
 class RequestOptionType(Enum):
@@ -27,91 +26,13 @@ class RequestOption:
     Describes an option to set on a request
 
     Attributes:
-        field_name (str): Describes the name of the parameter to inject. Mutually exclusive with field_path.
-        field_path (list(str)): Describes the path to a nested field as a list of field names.
-          Only valid for body_json injection type, and mutually exclusive with field_name.
+        field_name (str): Describes the name of the parameter to inject
         inject_into (RequestOptionType): Describes where in the HTTP request to inject the parameter
     """
 
+    field_name: Union[InterpolatedString, str]
     inject_into: RequestOptionType
     parameters: InitVar[Mapping[str, Any]]
-    field_name: Optional[Union[InterpolatedString, str]] = None
-    field_path: Optional[List[Union[InterpolatedString, str]]] = None
 
     def __post_init__(self, parameters: Mapping[str, Any]) -> None:
-        # Validate inputs. We should expect either field_name or field_path, but not both
-        if self.field_name is None and self.field_path is None:
-            raise ValueError("RequestOption requires either a field_name or field_path")
-
-        if self.field_name is not None and self.field_path is not None:
-            raise ValueError(
-                "Only one of field_name or field_path can be provided to RequestOption"
-            )
-
-        # Nested field injection is only supported for body JSON injection
-        if self.field_path is not None and self.inject_into != RequestOptionType.body_json:
-            raise ValueError(
-                "Nested field injection is only supported for body JSON injection. Please use a top-level field_name for other injection types."
-            )
-
-        # Convert field_name and field_path into InterpolatedString objects if they are strings
-        if self.field_name is not None:
-            self.field_name = InterpolatedString.create(self.field_name, parameters=parameters)
-        elif self.field_path is not None:
-            self.field_path = [
-                InterpolatedString.create(segment, parameters=parameters)
-                for segment in self.field_path
-            ]
-
-    @property
-    def _is_field_path(self) -> bool:
-        """Returns whether this option is a field path (ie, a nested field)"""
-        return self.field_path is not None
-
-    def inject_into_request(
-        self,
-        target: MutableMapping[str, Any],
-        value: Any,
-        config: Config,
-    ) -> None:
-        """
-        Inject a request option value into a target request structure using either field_name or field_path.
-        For non-body-json injection, only top-level field names are supported.
-        For body-json injection, both field names and nested field paths are supported.
-
-        Args:
-            target: The request structure to inject the value into
-            value: The value to inject
-            config: The config object to use for interpolation
-        """
-        if self._is_field_path:
-            if self.inject_into != RequestOptionType.body_json:
-                raise ValueError(
-                    "Nested field injection is only supported for body JSON injection. Please use a top-level field_name for other injection types."
-                )
-
-            assert self.field_path is not None  # for type checker
-            current = target
-            # Convert path segments into strings, evaluating any interpolated segments
-            # Example: ["data", "{{ config[user_type] }}", "id"] -> ["data", "admin", "id"]
-            *path_parts, final_key = [
-                str(
-                    segment.eval(config=config)
-                    if isinstance(segment, InterpolatedString)
-                    else segment
-                )
-                for segment in self.field_path
-            ]
-
-            # Build a nested dictionary structure and set the final value at the deepest level
-            for part in path_parts:
-                current = current.setdefault(part, {})
-            current[final_key] = value
-        else:
-            # For non-nested fields, evaluate the field name if it's an interpolated string
-            key = (
-                self.field_name.eval(config=config)
-                if isinstance(self.field_name, InterpolatedString)
-                else self.field_name
-            )
-            target[str(key)] = value
+        self.field_name = InterpolatedString.create(self.field_name, parameters=parameters)

airbyte_cdk/sources/declarative/requesters/request_options/datetime_based_request_options_provider.py

@@ -80,13 +80,12 @@ class DatetimeBasedRequestOptionsProvider(RequestOptionsProvider):
         options: MutableMapping[str, Any] = {}
         if not stream_slice:
             return options
-
         if self.start_time_option and self.start_time_option.inject_into == option_type:
-            start_time_value = stream_slice.get(self._partition_field_start.eval(self.config))
-            self.start_time_option.inject_into_request(options, start_time_value, self.config)
-
+            options[self.start_time_option.field_name.eval(config=self.config)] = stream_slice.get(  # type: ignore # field_name is always casted to an interpolated string
+                self._partition_field_start.eval(self.config)
+            )
         if self.end_time_option and self.end_time_option.inject_into == option_type:
-            end_time_value = stream_slice.get(self._partition_field_end.eval(self.config))
-            self.end_time_option.inject_into_request(options, end_time_value, self.config)
-
+            options[self.end_time_option.field_name.eval(config=self.config)] = stream_slice.get(  # type: ignore [union-attr]
+                self._partition_field_end.eval(self.config)
+            )
         return options

airbyte_cdk/sources/declarative/retrievers/async_retriever.py

@@ -6,7 +6,7 @@ from typing import Any, Iterable, Mapping, Optional
 
 from typing_extensions import deprecated
 
-from airbyte_cdk.sources.declarative.async_job.job import AsyncJob
+from airbyte_cdk.models import FailureType
 from airbyte_cdk.sources.declarative.async_job.job_orchestrator import AsyncPartition
 from airbyte_cdk.sources.declarative.extractors.record_selector import RecordSelector
 from airbyte_cdk.sources.declarative.partition_routers.async_job_partition_router import (
@@ -16,6 +16,7 @@ from airbyte_cdk.sources.declarative.retrievers.retriever import Retriever
 from airbyte_cdk.sources.source import ExperimentalClassWarning
 from airbyte_cdk.sources.streams.core import StreamData
 from airbyte_cdk.sources.types import Config, StreamSlice, StreamState
+from airbyte_cdk.utils.traced_exception import AirbyteTracedException
 
 
 @deprecated(
@@ -56,9 +57,9 @@ class AsyncRetriever(Retriever):
 
         return self.state
 
-    def _validate_and_get_stream_slice_jobs(
+    def _validate_and_get_stream_slice_partition(
         self, stream_slice: Optional[StreamSlice] = None
-    ) -> Iterable[AsyncJob]:
+    ) -> AsyncPartition:
         """
         Validates the stream_slice argument and returns the partition from it.
 
@@ -72,7 +73,12 @@ class AsyncRetriever(Retriever):
             AirbyteTracedException: If the stream_slice is not an instance of StreamSlice or if the partition is not present in the stream_slice.
 
         """
-        return stream_slice.extra_fields.get("jobs", []) if stream_slice else []
+        if not isinstance(stream_slice, StreamSlice) or "partition" not in stream_slice.partition:
+            raise AirbyteTracedException(
+                message="Invalid arguments to AsyncRetriever.read_records: stream_slice is not optional. Please contact Airbyte Support",
+                failure_type=FailureType.system_error,
+            )
+        return stream_slice["partition"]  # type: ignore  # stream_slice["partition"] has been added as an AsyncPartition as part of stream_slices
 
     def stream_slices(self) -> Iterable[Optional[StreamSlice]]:
         return self.stream_slicer.stream_slices()
@@ -83,8 +89,8 @@ class AsyncRetriever(Retriever):
         stream_slice: Optional[StreamSlice] = None,
     ) -> Iterable[StreamData]:
         stream_state: StreamState = self._get_stream_state()
-        jobs: Iterable[AsyncJob] = self._validate_and_get_stream_slice_jobs(stream_slice)
-        records: Iterable[Mapping[str, Any]] = self.stream_slicer.fetch_records(jobs)
+        partition: AsyncPartition = self._validate_and_get_stream_slice_partition(stream_slice)
+        records: Iterable[Mapping[str, Any]] = self.stream_slicer.fetch_records(partition)
 
         yield from self.record_selector.filter_and_transform(
             all_data=records,

airbyte_cdk/sources/declarative/retrievers/simple_retriever.py

@@ -128,9 +128,6 @@ class SimpleRetriever(Retriever):
         Returned merged mapping otherwise
         """
         # FIXME we should eventually remove the usage of stream_state as part of the interpolation
-
-        is_body_json = paginator_method.__name__ == "get_request_body_json"
-
         mappings = [
             paginator_method(
                 stream_state=stream_state,
@@ -146,7 +143,7 @@ class SimpleRetriever(Retriever):
                     next_page_token=next_page_token,
                 )
             )
-        return combine_mappings(mappings, allow_same_value_merge=is_body_json)
+        return combine_mappings(mappings)
 
     def _request_headers(
         self,

airbyte_cdk/sources/file_based/config/abstract_file_based_spec.py

@@ -11,7 +11,6 @@ from pydantic.v1 import AnyUrl, BaseModel, Field
 
 from airbyte_cdk import OneOfOptionConfig
 from airbyte_cdk.sources.file_based.config.file_based_stream_config import FileBasedStreamConfig
-from airbyte_cdk.sources.specs.transfer_modes import DeliverPermissions
 from airbyte_cdk.sources.utils import schema_helpers
 
 
@@ -66,7 +65,7 @@ class AbstractFileBasedSpec(BaseModel):
         order=10,
     )
 
-    delivery_method: Union[DeliverRecords, DeliverRawFiles, DeliverPermissions] = Field(
+    delivery_method: Union[DeliverRecords, DeliverRawFiles] = Field(
         title="Delivery Method",
         discriminator="delivery_type",
         type="object",

airbyte_cdk/sources/file_based/file_based_source.py

@@ -33,12 +33,6 @@ from airbyte_cdk.sources.file_based.config.file_based_stream_config import (
     FileBasedStreamConfig,
     ValidationPolicy,
 )
-from airbyte_cdk.sources.file_based.config.validate_config_transfer_modes import (
-    include_identities_stream,
-    preserve_directory_structure,
-    use_file_transfer,
-    use_permissions_transfer,
-)
 from airbyte_cdk.sources.file_based.discovery_policy import (
     AbstractDiscoveryPolicy,
     DefaultDiscoveryPolicy,
@@ -55,12 +49,7 @@ from airbyte_cdk.sources.file_based.schema_validation_policies import (
     DEFAULT_SCHEMA_VALIDATION_POLICIES,
     AbstractSchemaValidationPolicy,
 )
-from airbyte_cdk.sources.file_based.stream import (
-    AbstractFileBasedStream,
-    DefaultFileBasedStream,
-    FileIdentitiesStream,
-    PermissionsFileBasedStream,
-)
+from airbyte_cdk.sources.file_based.stream import AbstractFileBasedStream, DefaultFileBasedStream
 from airbyte_cdk.sources.file_based.stream.concurrent.adapters import FileBasedStreamFacade
 from airbyte_cdk.sources.file_based.stream.concurrent.cursor import (
     AbstractConcurrentFileBasedCursor,
@@ -77,7 +66,6 @@ from airbyte_cdk.utils.traced_exception import AirbyteTracedException
 DEFAULT_CONCURRENCY = 100
 MAX_CONCURRENCY = 100
 INITIAL_N_PARTITIONS = MAX_CONCURRENCY // 2
-IDENTITIES_STREAM = "identities"
 
 
 class FileBasedSource(ConcurrentSourceAdapter, ABC):
@@ -169,20 +157,13 @@ class FileBasedSource(ConcurrentSourceAdapter, ABC):
         errors = []
         tracebacks = []
         for stream in streams:
-            if isinstance(stream, FileIdentitiesStream):
-                identity = next(iter(stream.load_identity_groups()))
-                if not identity:
-                    errors.append(
-                        "Unable to get identities for current configuration, please check your credentials"
-                    )
-                continue
             if not isinstance(stream, AbstractFileBasedStream):
                 raise ValueError(f"Stream {stream} is not a file-based stream.")
             try:
                 parsed_config = self._get_parsed_config(config)
                 availability_method = (
                     stream.availability_strategy.check_availability
-                    if use_file_transfer(parsed_config) or use_permissions_transfer(parsed_config)
+                    if self._use_file_transfer(parsed_config)
                     else stream.availability_strategy.check_availability_and_parsability
                 )
                 (
@@ -258,7 +239,7 @@ class FileBasedSource(ConcurrentSourceAdapter, ABC):
                         message_repository=self.message_repository,
                     )
                     stream = FileBasedStreamFacade.create_from_stream(
-                        stream=self._make_file_based_stream(
+                        stream=self._make_default_stream(
                             stream_config=stream_config,
                             cursor=cursor,
                             parsed_config=parsed_config,
@@ -289,7 +270,7 @@ class FileBasedSource(ConcurrentSourceAdapter, ABC):
                         CursorField(DefaultFileBasedStream.ab_last_mod_col),
                     )
                     stream = FileBasedStreamFacade.create_from_stream(
-                        stream=self._make_file_based_stream(
+                        stream=self._make_default_stream(
                             stream_config=stream_config,
                             cursor=cursor,
                             parsed_config=parsed_config,
@@ -301,17 +282,13 @@ class FileBasedSource(ConcurrentSourceAdapter, ABC):
                     )
                 else:
                     cursor = self.cursor_cls(stream_config)
-                    stream = self._make_file_based_stream(
+                    stream = self._make_default_stream(
                         stream_config=stream_config,
                         cursor=cursor,
                         parsed_config=parsed_config,
                     )
 
                 streams.append(stream)
-
-            if include_identities_stream(parsed_config):
-                identities_stream = self._make_identities_stream()
-                streams.append(identities_stream)
             return streams
 
         except ValidationError as exc:
@@ -333,48 +310,8 @@ class FileBasedSource(ConcurrentSourceAdapter, ABC):
             validation_policy=self._validate_and_get_validation_policy(stream_config),
             errors_collector=self.errors_collector,
             cursor=cursor,
-            use_file_transfer=use_file_transfer(parsed_config),
-            preserve_directory_structure=preserve_directory_structure(parsed_config),
-        )
-
-    def _make_permissions_stream(
-        self, stream_config: FileBasedStreamConfig, cursor: Optional[AbstractFileBasedCursor]
-    ) -> AbstractFileBasedStream:
-        return PermissionsFileBasedStream(
-            config=stream_config,
-            catalog_schema=self.stream_schemas.get(stream_config.name),
-            stream_reader=self.stream_reader,
-            availability_strategy=self.availability_strategy,
-            discovery_policy=self.discovery_policy,
-            parsers=self.parsers,
-            validation_policy=self._validate_and_get_validation_policy(stream_config),
-            errors_collector=self.errors_collector,
-            cursor=cursor,
-        )
-
-    def _make_file_based_stream(
-        self,
-        stream_config: FileBasedStreamConfig,
-        cursor: Optional[AbstractFileBasedCursor],
-        parsed_config: AbstractFileBasedSpec,
-    ) -> AbstractFileBasedStream:
-        """
-        Creates different streams depending on the type of the transfer mode selected
-        """
-        if use_permissions_transfer(parsed_config):
-            return self._make_permissions_stream(stream_config, cursor)
-        # we should have a stream for File transfer mode to decouple from DefaultFileBasedStream
-        else:
-            return self._make_default_stream(stream_config, cursor, parsed_config)
-
-    def _make_identities_stream(
-        self,
-    ) -> Stream:
-        return FileIdentitiesStream(
-            catalog_schema=self.stream_schemas.get(FileIdentitiesStream.IDENTITIES_STREAM_NAME),
-            stream_reader=self.stream_reader,
-            discovery_policy=self.discovery_policy,
-            errors_collector=self.errors_collector,
+            use_file_transfer=self._use_file_transfer(parsed_config),
+            preserve_directory_structure=self._preserve_directory_structure(parsed_config),
         )
 
     def _get_stream_from_catalog(
@@ -441,3 +378,33 @@ class FileBasedSource(ConcurrentSourceAdapter, ABC):
                 "`input_schema` and `schemaless` options cannot both be set",
                 model=FileBasedStreamConfig,
             )
+
+    @staticmethod
+    def _use_file_transfer(parsed_config: AbstractFileBasedSpec) -> bool:
+        use_file_transfer = (
+            hasattr(parsed_config.delivery_method, "delivery_type")
+            and parsed_config.delivery_method.delivery_type == "use_file_transfer"
+        )
+        return use_file_transfer
+
+    @staticmethod
+    def _preserve_directory_structure(parsed_config: AbstractFileBasedSpec) -> bool:
+        """
+        Determines whether to preserve directory structure during file transfer.
+
+        When enabled, files maintain their subdirectory paths in the destination.
+        When disabled, files are flattened to the root of the destination.
+
+        Args:
+            parsed_config: The parsed configuration containing delivery method settings
+
+        Returns:
+            True if directory structure should be preserved (default), False otherwise
+        """
+        if (
+            FileBasedSource._use_file_transfer(parsed_config)
+            and hasattr(parsed_config.delivery_method, "preserve_directory_structure")
+            and parsed_config.delivery_method.preserve_directory_structure is not None
+        ):
+            return parsed_config.delivery_method.preserve_directory_structure
+        return True