ethyca-fides 2.71.1b1__py2.py3-none-any.whl → 2.74.0rc1__py2.py3-none-any.whl

fides/api/service/connectors/saas/connector_registry_service.py

@@ -1,24 +1,18 @@
 # pylint: disable=protected-access
 import os
 from abc import ABC, abstractmethod
-from typing import Dict, Iterable, List, Optional, Type
+from typing import Dict, List, Optional, Type
 from zipfile import ZipFile
 
 from fideslang.models import Dataset
 from loguru import logger
-from packaging.version import Version
 from packaging.version import parse as parse_version
 from sqlalchemy.orm import Session
 
 from fides.api.api.deps import get_api_session
 from fides.api.common_exceptions import ValidationError
 from fides.api.cryptography.cryptographic_util import str_to_b64_str
-from fides.api.models.connectionconfig import ConnectionConfig
 from fides.api.models.custom_connector_template import CustomConnectorTemplate
-from fides.api.models.datasetconfig import DatasetConfig
-from fides.api.schemas.connection_configuration.saas_config_template_values import (
-    SaasConnectionTemplateValues,
-)
 from fides.api.schemas.saas.connector_template import ConnectorTemplate
 from fides.api.schemas.saas.saas_config import SaaSConfig
 from fides.api.service.authentication.authentication_strategy_oauth2_authorization_code import (
@@ -31,8 +25,6 @@ from fides.api.util.saas_util import (
     load_config_from_string,
     load_dataset_from_string,
     load_yaml_as_string,
-    replace_config_placeholders,
-    replace_dataset_placeholders,
     replace_version,
 )
 from fides.api.util.unsafe_file_util import verify_svg, verify_zip
@@ -317,132 +309,3 @@ class ConnectorRegistry:
         Returns an object containing the various SaaS connector artifacts
         """
         return cls._get_combined_templates().get(connector_type)
-
-
-def create_connection_config_from_template_no_save(
-    db: Session,
-    template: ConnectorTemplate,
-    template_values: SaasConnectionTemplateValues,
-    system_id: Optional[str] = None,
-) -> ConnectionConfig:
-    """Creates a SaaS connection config from a template without saving it."""
-    # Load SaaS config from template and replace every instance of "<instance_fides_key>" with the fides_key
-    # the user has chosen
-    config_from_template: Dict = replace_config_placeholders(
-        template.config, "<instance_fides_key>", template_values.instance_key
-    )
-
-    data = template_values.generate_config_data_from_template(
-        config_from_template=config_from_template
-    )
-
-    if system_id:
-        data["system_id"] = system_id
-
-    # Create SaaS ConnectionConfig
-    connection_config = ConnectionConfig.create_without_saving(db, data=data)
-
-    return connection_config
-
-
-def upsert_dataset_config_from_template(
-    db: Session,
-    connection_config: ConnectionConfig,
-    template: ConnectorTemplate,
-    template_values: SaasConnectionTemplateValues,
-) -> DatasetConfig:
-    """
-    Creates a `DatasetConfig` from a template
-    and associates it with a ConnectionConfig.
-    If the `DatasetConfig` already exists in the db,
-    then the existing record is updated.
-    """
-    # Load the dataset config from template and replace every instance of "<instance_fides_key>" with the fides_key
-    # the user has chosen
-    dataset_from_template: Dict = replace_dataset_placeholders(
-        template.dataset, "<instance_fides_key>", template_values.instance_key
-    )
-    data = {
-        "connection_config_id": connection_config.id,
-        "fides_key": template_values.instance_key,
-        "dataset": dataset_from_template,  # Currently used for upserting a CTL Dataset
-    }
-    dataset_config = DatasetConfig.create_or_update(db, data=data)
-    return dataset_config
-
-
-def update_saas_configs(db: Session) -> None:
-    """
-    Updates SaaS config instances currently in the DB if to the
-    corresponding template in the registry are found.
-
-    Effectively an "update script" for SaaS config instances,
-    to be run on server bootstrap.
-    """
-    for connector_type in ConnectorRegistry.connector_types():
-        logger.debug(
-            "Determining if any updates are needed for connectors of type {} based on templates...",
-            connector_type,
-        )
-        template: ConnectorTemplate = ConnectorRegistry.get_connector_template(  # type: ignore
-            connector_type
-        )
-        saas_config = SaaSConfig(**load_config_from_string(template.config))
-        template_version: Version = parse_version(saas_config.version)
-
-        connection_configs: Iterable[ConnectionConfig] = ConnectionConfig.filter(
-            db=db,
-            conditions=(ConnectionConfig.saas_config["type"].astext == connector_type),
-        ).all()
-        for connection_config in connection_configs:
-            saas_config_instance = SaaSConfig.model_validate(
-                connection_config.saas_config
-            )
-            if parse_version(saas_config_instance.version) < template_version:
-                logger.info(
-                    "Updating SaaS config instance '{}' of type '{}' as its version, {}, was found to be lower than the template version {}",
-                    saas_config_instance.fides_key,
-                    connector_type,
-                    saas_config_instance.version,
-                    template_version,
-                )
-                try:
-                    update_saas_instance(
-                        db,
-                        connection_config,
-                        template,
-                        saas_config_instance,
-                    )
-                except Exception:
-                    logger.exception(
-                        "Encountered error attempting to update SaaS config instance {}",
-                        saas_config_instance.fides_key,
-                    )
-
-
-def update_saas_instance(
-    db: Session,
-    connection_config: ConnectionConfig,
-    template: ConnectorTemplate,
-    saas_config_instance: SaaSConfig,
-) -> None:
-    """
-    Replace in the DB the existing SaaS instance configuration data
-    (SaaSConfig, DatasetConfig) associated with the given ConnectionConfig
-    with new instance configuration data based on the given ConnectorTemplate
-    """
-    template_vals = SaasConnectionTemplateValues(
-        name=connection_config.name,
-        key=connection_config.key,
-        description=connection_config.description,
-        secrets=connection_config.secrets,
-        instance_key=saas_config_instance.fides_key,
-    )
-
-    config_from_template: Dict = replace_config_placeholders(
-        template.config, "<instance_fides_key>", template_vals.instance_key
-    )
-
-    connection_config.update_saas_config(db, SaaSConfig(**config_from_template))
-
-    upsert_dataset_config_from_template(db, connection_config, template, template_vals)

fides/api/service/connectors/saas_connector.py

@@ -10,18 +10,18 @@ from requests import Response
 from sqlalchemy.orm import Session
 from starlette.status import HTTP_204_NO_CONTENT
 
+from fides.api.api.deps import get_autoclose_db_session as get_db
 from fides.api.common_exceptions import (
-    AwaitingAsyncTask,
+    ClientUnsuccessfulException,
+    ConnectionException,
     FidesopsException,
     PostProcessingException,
-    PrivacyRequestError,
     SkippingConsentPropagation,
 )
 from fides.api.graph.execution import ExecutionNode
 from fides.api.models.connectionconfig import ConnectionConfig, ConnectionTestStatus
 from fides.api.models.policy import Policy
 from fides.api.models.privacy_request import PrivacyRequest, RequestTask
-from fides.api.models.privacy_request.request_task import AsyncTaskType
 from fides.api.schemas.consentable_item import (
     ConsentableItem,
     build_consent_item_hierarchy,
@@ -39,6 +39,10 @@ from fides.api.schemas.saas.shared_schemas import (
     ConsentPropagationStatus,
     SaaSRequestParams,
 )
+from fides.api.service.async_dsr.strategies.async_dsr_strategy import AsyncDSRStrategy
+from fides.api.service.async_dsr.strategies.async_dsr_strategy_factory import (
+    get_strategy,
+)
 from fides.api.service.connectors.base_connector import BaseConnector
 from fides.api.service.connectors.query_configs.saas_query_config import SaaSQueryConfig
 from fides.api.service.connectors.saas.authenticated_client import AuthenticatedClient
@@ -65,7 +69,9 @@ from fides.api.util.logger_context_utils import (
 from fides.api.util.saas_util import (
     ALL_OBJECT_FIELDS,
     CUSTOM_PRIVACY_REQUEST_FIELDS,
+    PRIVACY_REQUEST_OBJECT,
     assign_placeholders,
+    check_dataset_missing_reference_values,
     map_param_values,
 )
 
@@ -216,17 +222,14 @@ class SaaSConnector(BaseConnector[AuthenticatedClient], Contextualizable):
         request_task: RequestTask,
         input_data: Dict[str, List[Any]],
     ) -> List[Row]:
-        """Retrieve data from SaaS APIs"""
+        """
+        Retrieve data from SaaS APIs.
+
+        Handles sync requests directly and delegates async requests to external handlers.
+        """
 
         # pylint: disable=too-many-branches
         self.set_privacy_request_state(privacy_request, node, request_task)
-        if request_task.callback_succeeded:
-            # If this is True, we assume we've received results from a third party
-            # asynchronously and we can proceed to the next node.
-            logger.info(
-                "Access callback succeeded for request task '{}'", request_task.id
-            )
-            return request_task.get_access_data()
         query_config: SaaSQueryConfig = self.query_config(node)
 
         # generate initial set of requests if read request is defined, otherwise raise an exception
@@ -264,37 +267,32 @@ class SaaSConnector(BaseConnector[AuthenticatedClient], Contextualizable):
         if custom_privacy_request_fields:
             input_data[CUSTOM_PRIVACY_REQUEST_FIELDS] = [custom_privacy_request_fields]
 
-        rows: List[Row] = []
-        awaiting_async_processing: bool = False
-
+        input_data[PRIVACY_REQUEST_OBJECT] = [privacy_request.to_safe_dict()]
+        # check all the values specified by param_values are provided in input_data
         for read_request in read_requests:
-            self.set_saas_request_state(read_request)
-            if (
-                read_request.async_config is not None
-                and request_task.id  # Only supported in DSR 3.0
-            ):
-                # Asynchronous read request detected. We will exit below and put the
-                # Request Task in an "awaiting_processing" status.
-                awaiting_async_processing = True
-
-                # Validate async strategy with proper enum value checking
-                strategy_value = read_request.async_config.strategy
-                valid_strategies = [task_type.value for task_type in AsyncTaskType]
-
-                if strategy_value not in valid_strategies:
-                    raise PrivacyRequestError(
-                        f"Invalid async type '{strategy_value}' for request task {request_task.id}. "
-                        f"Valid types are: {valid_strategies}"
-                    )
-
-                request_task.async_type = AsyncTaskType(strategy_value)
-
-            # check all the values specified by param_values are provided in input_data
             if self._missing_dataset_reference_values(
                 input_data, read_request.param_values
             ):
                 return []
 
+        # Delegate async requests
+        with get_db() as db:
+            # Guard clause to ensure we only run async access requests for access requests
+            if self.guard_access_request(policy):
+                if async_dsr_strategy := _get_async_dsr_strategy(
+                    db, request_task, query_config, ActionType.access
+                ):
+                    return async_dsr_strategy.async_retrieve_data(
+                        client=self.create_client(),
+                        request_task_id=request_task.id,
+                        query_config=query_config,
+                        input_data=input_data,
+                    )
+
+        rows: List[Row] = []
+        for read_request in read_requests:
+            self.set_saas_request_state(read_request)
+
             # hook for user-provided request override functions
             if read_request.request_override:
                 return self._invoke_read_request_override(
@@ -310,7 +308,12 @@ class SaaSConnector(BaseConnector[AuthenticatedClient], Contextualizable):
             # if a path is provided, it means we want to generate HTTP requests from the config
             if read_request.path:
                 prepared_requests: List[Tuple[SaaSRequestParams, Dict[str, Any]]] = (
-                    query_config.generate_requests(input_data, policy, read_request)
+                    query_config.generate_requests(
+                        input_data,
+                        policy,
+                        read_request,
+                        privacy_request=privacy_request,
+                    )
                 )
 
                 # Iterates through initial list of prepared requests and through subsequent
@@ -334,7 +337,7 @@ class SaaSConnector(BaseConnector[AuthenticatedClient], Contextualizable):
             # This allows us to build an output object even if we didn't generate and execute
             # any HTTP requests. This is useful if we just want to select specific input_data
             # values to provide as row data to the mask_data function
-            elif read_request.output:
+            elif not read_request.path and read_request.output:
                 rows.extend(
                     self._apply_output_template(
                         query_config.generate_param_value_maps(
@@ -345,19 +348,21 @@ class SaaSConnector(BaseConnector[AuthenticatedClient], Contextualizable):
                 )
 
         self.unset_connector_state()
-        if awaiting_async_processing:
-            # If a read request was marked to expect async results, original response data here is ignored.
-            # We'll instead use the data received in the callback URL later.
-            # However for polling async request we want to save the request data for ids that we will use on the pollings status
-            if request_task.async_type == AsyncTaskType.polling:
-                # Saving the request task access data to use it on the polling status request
-                # TODO: Consider if we want to clean up the rows. Currently this is the concern of the GraphTask.
-                request_task.access_data = rows
-            # Raising an AwaitingAsyncTask to put this task in an awaiting_processing state
-            raise AwaitingAsyncTask()
-
         return rows
 
+    def guard_access_request(self, policy: Policy) -> bool:
+        """
+        Guard clause to ensure we only run async access requests
+        if the access request is enabled and we are in an Access Request
+        """
+        if (
+            self.configuration.enabled_actions is None
+            or ActionType.access in self.configuration.enabled_actions
+        ):
+            if policy.get_rules_for_action(ActionType.access):
+                return True
+        return False
+
     def _apply_output_template(
         self,
         param_value_maps: List[Dict[str, Any]],
@@ -387,29 +392,15 @@ class SaaSConnector(BaseConnector[AuthenticatedClient], Contextualizable):
         return result
 
     def _missing_dataset_reference_values(
-        self, input_data: Dict[str, Any], param_values: Optional[List[ParamValue]]
+        self, input_data: Dict[str, List[Any]], param_values: Optional[List[ParamValue]]
     ) -> List[str]:
         """Return a list of dataset reference values that are not found in the input_data map"""
-
-        # get the list of param_value references
-        required_param_value_references = [
-            param_value.name
-            for param_value in param_values or []
-            if param_value.references
-        ]
-
-        # extract the keys from inside the fides_grouped_inputs and append them the other input_data keys
-        provided_input_keys = (
-            list(input_data.get("fidesops_grouped_inputs")[0].keys())  # type: ignore
-            if input_data.get("fidesops_grouped_inputs")
-            else []
-        ) + list(input_data.keys())
-
-        # find the missing values
-        missing_dataset_reference_values = list(
-            set(required_param_value_references) - set(provided_input_keys)
+        missing_dataset_reference_values = check_dataset_missing_reference_values(
+            input_data, param_values
+        )
+        logger.info(
+            f"Missing dataset reference values: {missing_dataset_reference_values}"
         )
-
         if missing_dataset_reference_values:
             logger.info(
                 "The '{}' request of {} is missing the following dataset reference values [{}], skipping traversal",
@@ -536,22 +527,27 @@ class SaaSConnector(BaseConnector[AuthenticatedClient], Contextualizable):
         rows: List[Row],
         input_data: Optional[Dict[str, List[Any]]] = None,
     ) -> int:
-        """Execute a masking request. Return the number of rows that have been updated."""
-        self.set_privacy_request_state(privacy_request, node, request_task)
-        if request_task.callback_succeeded:
-            # If this is True, we assume the data was masked
-            # asynchronously and we can proceed to the next node.
-            logger.info(
-                "Masking callback succeeded for request task '{}'", request_task.id
-            )
-            # If we've received the callback for this node, return rows_masked directly
-            return request_task.rows_masked or 0
+        """
+        Execute masking requests.
 
+        Handles synchronous requests directly and delegates async requests to external handlers.
+        """
         self.set_privacy_request_state(privacy_request, node, request_task)
+
         query_config = self.query_config(node)
 
-        session = Session.object_session(privacy_request)
-        masking_request = query_config.get_masking_request(session)
+        # Delegate async requests
+        with get_db() as db:
+            if async_dsr_strategy := _get_async_dsr_strategy(
+                db, request_task, query_config, ActionType.erasure
+            ):
+                return async_dsr_strategy.async_mask_data(
+                    client=self.create_client(),
+                    request_task_id=request_task.id,
+                    query_config=query_config,
+                    rows=rows,
+                )
+        masking_request = query_config.get_masking_request()
         rows_updated = 0
 
         if not masking_request:
@@ -596,7 +592,7 @@ class SaaSConnector(BaseConnector[AuthenticatedClient], Contextualizable):
         for row in rows:
             try:
                 prepared_request = query_config.generate_update_stmt(
-                    row, policy, privacy_request
+                    row, policy, privacy_request, input_data
                 )
             except ValueError as exc:
                 if masking_request.skip_missing_param_values:
@@ -648,18 +644,6 @@ class SaaSConnector(BaseConnector[AuthenticatedClient], Contextualizable):
                 )
 
         self.unset_connector_state()
-
-        awaiting_async_callback: bool = bool(
-            masking_request.async_config
-            and masking_request.async_config.strategy == AsyncTaskType.callback.value
-        ) and bool(
-            request_task.id
-        )  # Only supported in DSR 3.0
-        if awaiting_async_callback:
-            # Asynchronous masking request detected in saas config.
-            # If the masking request was marked to expect async results, original responses are ignored
-            # and we raise an AwaitingAsyncTask to put this task in an awaiting_processing state.
-            raise AwaitingAsyncTask()
         return rows_updated
 
     @staticmethod
@@ -967,6 +951,9 @@ class SaaSConnector(BaseConnector[AuthenticatedClient], Contextualizable):
                 client,
                 secrets,
             )  # type: ignore
+        except (ConnectionException, ClientUnsuccessfulException):
+            # Re-raise these exceptions as-is so the connection service can handle them properly
+            raise
         except Exception as exc:
             logger.error(
                 "Encountered error executing override test function '{}'",
@@ -1112,3 +1099,38 @@ class SaaSConnector(BaseConnector[AuthenticatedClient], Contextualizable):
             return []
 
         return consent_requests.opt_in if opt_in else consent_requests.opt_out  # type: ignore
+
+
+def _get_async_dsr_strategy(
+    session: Session,
+    request_task: RequestTask,
+    query_config: SaaSQueryConfig,
+    action_type: ActionType,
+) -> Optional[AsyncDSRStrategy]:
+    """
+    Returns the async DSR strategy if any of the read or masking requests have an async_config.
+    """
+
+    # Async processing is only supported for DSR 3.0.
+    # A request task with an ID of None is an indicator that the request is not DSR 3.0.
+    if request_task.id is None:
+        return None
+
+    if action_type == ActionType.access:
+        read_requests = query_config.get_read_requests_by_identity()
+        for request in read_requests:
+            if request.async_config is not None:
+                return get_strategy(
+                    request.async_config.strategy,
+                    session,
+                    request.async_config.configuration,
+                )
+    elif action_type == ActionType.erasure:
+        masking_request = query_config.get_masking_request()
+        if masking_request is not None and masking_request.async_config is not None:
+            return get_strategy(
+                masking_request.async_config.strategy,
+                session,
+                masking_request.async_config.configuration,
+            )
+    return None

fides/api/service/connectors/sql_connector.py

@@ -345,7 +345,7 @@ class SQLConnector(BaseConnector[Engine]):
 
                 # For simple table names
                 if "." not in qualified_table_name:
-                    return inspector.has_table(qualified_table_name)
+                    return self._check_table_exists(inspector, qualified_table_name)
 
                 # For qualified names like schema.table or database.schema.table
                 parts = qualified_table_name.split(".")
@@ -353,15 +353,15 @@ class SQLConnector(BaseConnector[Engine]):
                 if len(parts) == 2:
                     # schema.table format
                     schema_name, table_name = parts
-                    return inspector.has_table(table_name, schema=schema_name)
+                    return self._check_table_exists(inspector, table_name, schema_name)
 
                 if len(parts) >= 3:
                     # database.schema.table format (use schema.table)
                     schema_name, table_name = parts[-2], parts[-1]
-                    return inspector.has_table(table_name, schema=schema_name)
+                    return self._check_table_exists(inspector, table_name, schema_name)
 
                 # Fallback for unexpected format
-                return inspector.has_table(qualified_table_name)
+                return self._check_table_exists(inspector, qualified_table_name)
 
         except Exception as exc:
             # Graceful fallback - if we can't check, assume table exists
@@ -369,6 +369,16 @@ class SQLConnector(BaseConnector[Engine]):
             logger.error("Unable to check if table exists, assuming it does: {}", exc)
             return True
 
+    def _check_table_exists(
+        self, inspector: Any, table_name: str, schema: Optional[str] = None
+    ) -> bool:
+        """Helper method to check table existence and log if not found."""
+        table_exists = inspector.has_table(table_name, schema=schema)
+        if not table_exists:
+            qualified_name = f"{schema}.{table_name}" if schema else table_name
+            logger.error("Table '{}' does not exist", qualified_name)
+        return table_exists
+
     def handle_table_not_found(
         self,
         node: ExecutionNode,

fides/api/service/deps.py

@@ -6,6 +6,7 @@ from fides.api.api.deps import get_config, get_config_proxy, get_db
 from fides.api.db.ctl_session import get_async_db
 from fides.config import FidesConfig
 from fides.config.config_proxy import ConfigProxy
+from fides.service.connection.connection_service import ConnectionService
 from fides.service.dataset.dataset_config_service import DatasetConfigService
 from fides.service.dataset.dataset_service import DatasetService
 from fides.service.event_audit_service import EventAuditService
@@ -59,5 +60,12 @@ def get_taxonomy_service(
     return TaxonomyService(db, event_audit_service)
 
 
+def get_connection_service(
+    db: Session = Depends(get_db),
+    event_audit_service: EventAuditService = Depends(get_event_audit_service),
+) -> ConnectionService:
+    return ConnectionService(db, event_audit_service)
+
+
 def get_system_service(db: AsyncSession = Depends(get_async_db)) -> SystemService:
     return SystemService(db)

fides/api/service/messaging/message_dispatch_service.py

@@ -28,6 +28,7 @@ from fides.api.schemas.messaging.messaging import (
     ErrorNotificationBodyParams,
     ExternalUserWelcomeBodyParams,
     FidesopsMessage,
+    ManualTaskDigestBodyParams,
     MessagingActionType,
     MessagingMethod,
     MessagingServiceDetails,
@@ -177,6 +178,7 @@ def dispatch_message(
             UserInviteBodyParams,
             ErrorNotificationBodyParams,
             ExternalUserWelcomeBodyParams,
+            ManualTaskDigestBodyParams,
         ]
     ] = None,
     subject_override: Optional[str] = None,
@@ -352,7 +354,7 @@ def _render(template_str: str, variables: Optional[Dict] = None) -> str:
     return template_str
 
 
-def _build_email(  # pylint: disable=too-many-return-statements, too-many-branches
+def _build_email(  # pylint: disable=too-many-return-statements, too-many-branches, too-many-statements
     config_proxy: ConfigProxy,
     action_type: MessagingActionType,
     body_params: Any,
@@ -494,6 +496,41 @@ def _build_email(  # pylint: disable=too-many-return-statements, too-many-branch
             template_variables=variables,
         )
 
+    if action_type == MessagingActionType.MANUAL_TASK_DIGEST:
+        variables = {
+            "vendor_contact_name": body_params.vendor_contact_name,
+            "organization_name": body_params.organization_name,
+            "portal_url": body_params.portal_url,
+            "imminent_task_count": body_params.imminent_task_count,
+            "upcoming_task_count": body_params.upcoming_task_count,
+            "total_task_count": body_params.total_task_count,
+            "company_logo_url": body_params.company_logo_url,
+        }
+
+        # Start with default subject
+        subject = f"Weekly DSR Summary from {body_params.organization_name}"
+
+        # If messaging template exists, extract customizable content
+        if messaging_template:
+            # Use custom subject if provided
+            if "subject" in messaging_template.content:
+                subject = _render(messaging_template.content["subject"], variables)
+
+            # Use custom body content to replace the intro text in HTML template
+            custom_body = messaging_template.content.get("body", "")
+            if custom_body.strip():
+                # Replace the default intro text with the custom body content
+                rendered_custom_body = _render(custom_body, variables)
+                variables["intro_text"] = rendered_custom_body
+
+        # Always use the HTML template
+        base_template = get_email_template(action_type)
+        return EmailForActionType(
+            subject=subject,
+            body=base_template.render(variables),
+            template_variables=variables,
+        )
+
     logger.error("Message action type {} is not implemented", action_type)
     raise MessageDispatchException(
         f"Message action type {action_type} is not implemented"

fides/api/service/privacy_request/attachment_handling.py

@@ -5,7 +5,7 @@ from typing import Any, Dict, Iterator, List, Optional, Tuple
 from loguru import logger
 
 from fides.api.models.attachment import Attachment, AttachmentType
-from fides.api.schemas.storage.storage import StorageDetails
+from fides.api.schemas.storage.storage import StorageDetails, StorageType
 
 
 @dataclass
@@ -84,12 +84,19 @@ def get_attachments_content(
                 continue
 
             processed_count += 1
+
+            # Handle bucket_name differently for different storage types
+            bucket_name = None
+            if attachment.config.type in [StorageType.s3, StorageType.gcs]:
+                bucket_name = attachment.config.details[StorageDetails.BUCKET.value]
+            # For local storage, bucket_name is not needed
+
             yield AttachmentData(
                 file_name=attachment.file_name,
                 file_size=size,
                 download_url=str(url) if url else None,
                 content_type=attachment.content_type,
-                bucket_name=attachment.config.details[StorageDetails.BUCKET.value],
+                bucket_name=bucket_name or "",  # Empty string for local storage
                 file_key=attachment.file_key,
                 storage_key=attachment.storage_key,
             )