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

fides/api/models/privacy_request/request_task.py

@@ -8,8 +8,9 @@ from typing import TYPE_CHECKING, List, Optional, Tuple
 from loguru import logger
 from sqlalchemy import Boolean, Column, ForeignKey, Integer, String
 from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy.ext.declarative import declared_attr
 from sqlalchemy.ext.mutable import MutableDict, MutableList
-from sqlalchemy.orm import Query, Session, relationship
+from sqlalchemy.orm import Query, RelationshipProperty, Session, relationship
 from sqlalchemy_utils.types.encrypted.encrypted_type import (
     AesGcmEngine,
     StringEncryptedType,
@@ -183,6 +184,14 @@ class RequestTask(WorkerTask, Base):
         uselist=False,
     )
 
+    # Stores the sub-requests data for async polling tasks
+    sub_requests: "RelationshipProperty[List[RequestTaskSubRequest]]" = relationship(
+        "RequestTaskSubRequest",
+        back_populates="request_task",
+        cascade="all, delete-orphan",
+        order_by="RequestTaskSubRequest.created_at",
+    )
+
     @property
     def request_task_address(self) -> CollectionAddress:
         """Convert the collection_address into Collection Address format"""
@@ -318,3 +327,91 @@ class RequestTask(WorkerTask, Base):
             )
 
         return task_in_flight
+
+
+class RequestTaskSubRequest(Base):
+    """
+    Model for storing individual sub-request data during the execution of a request task.
+    Supports 1:N relationship - each RequestTask can have multiple sub-requests.
+    Currently used for storing request data for polling tasks.
+    """
+
+    @declared_attr
+    def __tablename__(cls) -> str:
+        """Overriding base class method to set the table name."""
+        return "request_task_sub_request"
+
+    request_task_id = Column(
+        String(255),
+        ForeignKey(
+            "requesttask.id",
+            name="request_task_sub_request_request_task_id_fkey",
+            ondelete="CASCADE",
+        ),
+        nullable=False,
+        index=True,
+    )
+
+    request_task = relationship(
+        "RequestTask",
+        back_populates="sub_requests",
+    )
+
+    # Individual sub-request data (e.g., request_id, status, result data)
+    # Additional fields for enhanced sub-request tracking
+    param_values = Column(  # An encrypted JSON String - saved as a dict
+        StringEncryptedType(
+            type_in=JSONTypeOverride,
+            key=CONFIG.security.app_encryption_key,
+            engine=AesGcmEngine,
+            padding="pkcs5",
+        ),
+        nullable=False,
+    )
+    status = Column(String, nullable=False)
+
+    # Raw data retrieved from an access request is stored here.  This contains all of the
+    # intermediate data we retrieved, needed for downstream tasks, but hasn't been filtered
+    # by data category for the end user.
+    _access_data = Column(  # An encrypted JSON String - saved as a list of Rows
+        "access_data",
+        StringEncryptedType(
+            type_in=JSONTypeOverride,
+            key=CONFIG.security.app_encryption_key,
+            engine=AesGcmEngine,
+            padding="pkcs5",
+        ),
+    )
+
+    # Use descriptors for automatic external storage handling
+    access_data = EncryptedLargeDataDescriptor(
+        field_name="access_data", empty_default=[]
+    )
+
+    # Written after an erasure is completed
+    rows_masked = Column(Integer)
+
+    def get_correlation_id(self) -> Optional[str]:
+        """Helper method to extract correlation_id from param_values."""
+        if self.param_values and "request_id" in self.param_values:
+            return self.param_values["request_id"]
+        return None
+
+    def update_status(self, db: Session, status: str) -> None:
+        """Helper method to update the status of this sub-request."""
+        self.status = status
+        self.save(db)
+
+    def cleanup_external_storage(self) -> None:
+        """Clean up all external storage files for this sub-request"""
+        # Access the descriptor from the class to call cleanup
+        RequestTaskSubRequest.access_data.cleanup(self)
+
+    def get_access_data(self) -> List[Row]:
+        """Helper to retrieve access data or default to empty list"""
+        return self.access_data or []
+
+    def delete(self, db: Session) -> None:
+        """Override delete to cleanup external storage first"""
+        self.cleanup_external_storage()
+        super().delete(db)

fides/api/models/worker_task.py

@@ -17,6 +17,14 @@ class ExecutionLogStatus(enum.Enum):
     awaiting_processing = "paused"  # "paused" in the database to avoid a migration, but use "awaiting_processing" in the app
     retrying = "retrying"
     skipped = "skipped"
+    polling = "polling"
+
+
+# Statuses that can be resumed
+RESUMABLE_EXECUTION_LOG_STATUSES = [
+    ExecutionLogStatus.pending,
+    ExecutionLogStatus.polling,
+]
 
 
 class WorkerTask:

fides/api/schemas/saas/async_polling_configuration.py

@@ -0,0 +1,81 @@
+from enum import Enum
+from typing import Any, Dict, List, Optional, Union
+
+from pydantic import BaseModel, Field, model_validator
+
+from fides.api.schemas.saas.saas_config import SaaSRequest
+from fides.api.schemas.saas.strategy_configuration import StrategyConfiguration
+from fides.api.util.collection_util import Row
+
+
+class SupportedDataType(Enum):
+    """Supported data types for polling async DSR result requests."""
+
+    # Structured data types that can be parsed into rows
+    json = "json"  # Parsed into List[Row] from JSON response
+    csv = "csv"  # Parsed into List[Row] from CSV response
+    # Binary/non-parseable data stored as raw bytes
+    attachment = "attachment"  # Binary files (.zip, .pdf, .xml, etc.) stored as bytes
+
+
+class PollingResultType(Enum):
+    """Types of results from async polling operations."""
+
+    rows = "rows"  # Structured data parsed into List[Row]
+    attachment = "attachment"  # Binary file data stored as bytes
+
+
+class PollingResult(BaseModel):
+    """
+    Flexible result container for async polling operations.
+    Handles both structured data and file attachments.
+    """
+
+    data: Union[List[Row], bytes]
+    result_type: PollingResultType
+    metadata: Dict[str, Any] = Field(default_factory=dict)
+
+
+class PollingStatusRequest(SaaSRequest):
+    """
+    Extended SaaSRequest for checking async job status.
+    Uses request_override for custom status checking logic or standard fields for simple cases.
+    """
+
+    status_path: Optional[str] = None
+    status_completed_value: Optional[Union[str, bool, int]] = None
+
+    @model_validator(mode="after")
+    def validate_status_fields(self) -> "PollingStatusRequest":
+        """Ensure required fields are present unless using an override."""
+        if self.request_override:
+            return self
+
+        if not self.status_path:
+            raise ValueError("status_path is required when request_override is not set")
+        if self.status_completed_value is None:
+            raise ValueError(
+                "status_completed_value is required when request_override is not set"
+            )
+        return self
+
+
+class PollingResultRequest(SaaSRequest):
+    """
+    Extended SaaSRequest for retrieving async job results.
+    Uses request_override for custom result retrieval or standard HTTP request for simple cases.
+    Data type is automatically inferred from response.
+    """
+
+    result_path: Optional[str] = None
+
+
+class AsyncPollingConfiguration(StrategyConfiguration):
+    """
+    Simplified configuration for polling async DSR requests.
+    The main read request serves as the initial request.
+    """
+
+    status_request: PollingStatusRequest
+    # result_request is optional for delete/update operations
+    result_request: Optional[PollingResultRequest] = None

fides/api/schemas/saas/saas_config.py

@@ -2,7 +2,9 @@ from typing import Any, Dict, List, Optional, Set, Union
 
 from fideslang.models import FidesCollectionKey, FidesDatasetReference
 from fideslang.validation import FidesKey
-from pydantic import BaseModel, ConfigDict, field_validator, model_validator
+from pydantic import BaseModel, ConfigDict
+from pydantic import Field as PydanticField
+from pydantic import field_validator, model_validator
 
 from fides.api.common_exceptions import ValidationError
 from fides.api.graph.config import (
@@ -115,6 +117,10 @@ class SaaSRequest(BaseModel):
     skip_missing_param_values: Optional[bool] = (
         False  # Skip instead of raising an exception if placeholders can't be populated in body
     )
+    correlation_id_path: Optional[str] = PydanticField(
+        default=None,
+        description="The path to the correlation ID in the response. For use with async polling.",
+    )
     model_config = ConfigDict(
         from_attributes=True, use_enum_values=True, extra="forbid"
     )
@@ -213,7 +219,7 @@ class SaaSRequest(BaseModel):
 class ReadSaaSRequest(SaaSRequest):
     """
     An extension of the base SaaSRequest that allows the inclusion of an output template
-    that is used to format each collection result.
+    that is used to format each collection result, and correlation_id_path for async polling.
     """
 
     output: Optional[str] = None
@@ -230,7 +236,8 @@ class ReadSaaSRequest(SaaSRequest):
                 raise ValueError(
                     "A read request must specify a method if a path is provided and no request_override is specified"
                 )
-        else:
+
+        if self.request_override:
             allowed_fields = {
                 "request_override",
                 "param_values",

fides/api/schemas/saas/strategy_configuration.py

@@ -178,15 +178,3 @@ class OAuth2ClientCredentialsConfiguration(OAuth2BaseConfiguration):
     """
 
     refresh_request: Optional[SaaSRequest] = Field(exclude=True)
-
-
-class PollingAsyncDSRConfiguration(StrategyConfiguration):
-    """
-    Configuration for polling async DSR requests.
-    """
-
-    status_request: SaaSRequest
-    status_path: str
-    status_completed_value: Optional[str] = None
-    result_request: SaaSRequest
-    result_path: str

fides/api/service/async_dsr/handlers/polling_attachment_handler.py

@@ -0,0 +1,155 @@
+"""Handler for storing and managing attachments from async polling operations."""
+
+from io import BytesIO
+from typing import List, Union
+
+from loguru import logger
+from sqlalchemy.orm import Session
+
+from fides.api.common_exceptions import PrivacyRequestError
+from fides.api.models.attachment import (
+    Attachment,
+    AttachmentReference,
+    AttachmentReferenceType,
+    AttachmentType,
+)
+from fides.api.models.privacy_request.request_task import RequestTask
+from fides.api.models.storage import get_active_default_storage_config
+from fides.api.util.collection_util import Row
+
+
+class PollingAttachmentHandler:
+    """Utility class for handling attachment storage and metadata in polling operations."""
+
+    @staticmethod
+    def store_attachment(
+        session: Session,
+        request_task: RequestTask,
+        attachment_data: bytes,
+        filename: str,
+    ) -> str:
+        """
+        Store polling attachment data and return attachment ID.
+
+        This utility function handles the storage of attachment data
+        from polling results and creates the necessary database records.
+
+        Args:
+            session: Database session
+            request_task: The request task associated with this attachment
+            attachment_data: The binary attachment data to store
+            filename: The filename for the attachment
+
+        Returns:
+            str: The ID of the created attachment
+
+        Raises:
+            PrivacyRequestError: If storage configuration is not found or storage fails
+        """
+        try:
+            # Get active storage config
+            storage_config = get_active_default_storage_config(session)
+            if not storage_config:
+                raise PrivacyRequestError("No active storage configuration found")
+
+            # Create attachment record and upload to storage
+            attachment = Attachment.create_and_upload(
+                db=session,
+                data={
+                    "file_name": filename,
+                    "attachment_type": AttachmentType.include_with_access_package,
+                    "storage_key": storage_config.key,
+                },
+                attachment_file=BytesIO(attachment_data),
+            )
+
+            # Create attachment references
+            AttachmentReference.create(
+                db=session,
+                data={
+                    "attachment_id": attachment.id,
+                    "reference_id": request_task.id,
+                    "reference_type": AttachmentReferenceType.request_task,
+                },
+            )
+
+            AttachmentReference.create(
+                db=session,
+                data={
+                    "attachment_id": attachment.id,
+                    "reference_id": request_task.privacy_request.id,
+                    "reference_type": AttachmentReferenceType.privacy_request,
+                },
+            )
+
+            logger.info(
+                f"Successfully stored polling attachment {attachment.id} for request_task {request_task.id}"
+            )
+            return attachment.id
+
+        except Exception as e:
+            logger.error(f"Failed to store polling attachment: {e}")
+            raise PrivacyRequestError(f"Failed to store polling attachment: {e}")
+
+    @staticmethod
+    def ensure_attachment_bytes(data: Union[List[Row], bytes]) -> bytes:
+        """
+        Ensure attachment polling results provide bytes content.
+
+        Args:
+            data: The data that should be bytes
+
+        Returns:
+            bytes: The validated bytes data
+
+        Raises:
+            PrivacyRequestError: If data is not bytes
+        """
+        if isinstance(data, bytes):
+            return data
+        raise PrivacyRequestError("Expected bytes data for attachment polling result")
+
+    @staticmethod
+    def add_metadata_to_rows(db: Session, attachment_id: str, rows: List[Row]) -> None:
+        """
+        Add attachment metadata to rows collection (like manual tasks do).
+
+        Args:
+            db: Database session
+            attachment_id: The ID of the attachment to add metadata for
+            rows: The list of rows to add the attachment metadata to
+        """
+        attachment_record = (
+            db.query(Attachment).filter(Attachment.id == attachment_id).first()
+        )
+
+        if attachment_record:
+            try:
+                size, url = attachment_record.retrieve_attachment()
+                attachment_info = {
+                    "file_name": attachment_record.file_name,
+                    "download_url": str(url) if url else None,
+                    "file_size": size,
+                }
+            except Exception as exc:
+                logger.warning(
+                    f"Could not retrieve attachment content for {attachment_record.file_name}: {exc}"
+                )
+                attachment_info = {
+                    "file_name": attachment_record.file_name,
+                    "download_url": None,
+                    "file_size": None,
+                }
+
+            # Add attachment to the polling results
+            attachments_item = None
+            for item in rows:
+                if isinstance(item, dict) and "retrieved_attachments" in item:
+                    attachments_item = item
+                    break
+
+            if attachments_item is None:
+                attachments_item = {"retrieved_attachments": []}
+                rows.append(attachments_item)
+
+            attachments_item["retrieved_attachments"].append(attachment_info)

fides/api/service/async_dsr/handlers/polling_request_handler.py

@@ -0,0 +1,88 @@
+"""
+Pure HTTP utility for executing polling requests.
+
+This module contains low-level HTTP request execution for async DSR polling,
+with no business logic or orchestration dependencies.
+"""
+
+from typing import Any, Dict, Optional
+
+from requests import Response
+
+from fides.api.common_exceptions import PrivacyRequestError
+from fides.api.schemas.saas.async_polling_configuration import (
+    PollingResultRequest,
+    PollingStatusRequest,
+)
+from fides.api.service.connectors.saas.authenticated_client import AuthenticatedClient
+from fides.api.util.saas_util import map_param_values
+
+
+class PollingRequestHandler:
+    """
+    Pure HTTP utility for executing polling requests.
+
+    Handles status checks and result retrieval with no business logic dependencies.
+    """
+
+    def __init__(
+        self,
+        status_request: PollingStatusRequest,
+        result_request: Optional[PollingResultRequest] = None,
+    ):
+        self.status_request = status_request
+        self.result_request = result_request
+
+    def get_status_response(
+        self,
+        client: AuthenticatedClient,
+        param_values: Dict[str, Any],
+    ) -> Response:
+        """Execute HTTP status request and return raw response."""
+        if not self.status_request:
+            raise PrivacyRequestError(
+                "status_request is not configured in the async polling configuration"
+            )
+
+        prepared_status_request = map_param_values(
+            action="status",
+            context="polling request",
+            current_request=self.status_request,
+            param_values=param_values,
+        )
+
+        response: Response = client.send(prepared_status_request)
+
+        if not response.ok:
+            raise PrivacyRequestError(
+                f"Status request failed with status code {response.status_code}: {response.text}"
+            )
+
+        return response
+
+    def get_result_response(
+        self,
+        client: AuthenticatedClient,
+        param_values: Dict[str, Any],
+    ) -> Response:
+        """Execute HTTP result request and return raw response."""
+        if not self.result_request:
+            raise PrivacyRequestError(
+                "result_request is not configured in the async polling configuration"
+            )
+
+        prepared_result_request = map_param_values(
+            action="result",
+            context="polling request",
+            current_request=self.result_request,
+            param_values=param_values,
+        )
+
+        response: Response = client.send(prepared_result_request)
+
+        if not response.ok:
+            raise PrivacyRequestError(
+                f"Result request failed with status code {response.status_code}: {response.text}"
+            )
+
+        return response