ethyca-fides 2.69.1rc0__py2.py3-none-any.whl → 2.76.0rc2__py2.py3-none-any.whl

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/connector_template.py

@@ -4,6 +4,7 @@ from fideslang.models import Dataset
 from pydantic import BaseModel, field_validator
 
 from fides.api.models.datasetconfig import validate_masking_strategy_override
+from fides.api.schemas.base_class import FidesSchema
 from fides.api.schemas.enums.connection_category import ConnectionCategory
 from fides.api.schemas.enums.integration_feature import IntegrationFeature
 from fides.api.schemas.policy import ActionType
@@ -50,3 +51,16 @@ class ConnectorTemplate(BaseModel):
                 "Hard-coded fides_key detected in the dataset, replace all instances of it with <instance_fides_key>"
             )
         return dataset
+
+
+class ConnectorTemplateListResponse(FidesSchema):
+    """
+    Response schema for listing connector templates.
+    Provides summary information about available connector templates.
+    """
+
+    type: str
+    name: str
+    supported_actions: List[ActionType]
+    category: Optional[ConnectionCategory] = None
+    custom: bool

fides/api/schemas/saas/saas_config.py

@@ -1,9 +1,10 @@
-from enum import Enum
 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 (
@@ -69,7 +70,7 @@ class Strategy(BaseModel):
     """General shape for swappable strategies (ex: auth, processors, pagination, etc.)"""
 
     strategy: str
-    configuration: Dict[str, Any]
+    configuration: Optional[Dict[str, Any]] = None
 
 
 class ClientConfig(BaseModel):
@@ -90,20 +91,6 @@ class QueryParam(BaseModel):
     value: Union[int, str]
 
 
-class AsyncStrategy(Enum):
-    """Async strategies: supports callback for now, but could be
-    extended to polling as well in the future"""
-
-    callback = "callback"
-
-
-class AsyncConfig(BaseModel):
-    """Async config only has strategy for now, but could be
-    extended with other configuration options when we add polling"""
-
-    strategy: AsyncStrategy
-
-
 class SaaSRequest(BaseModel):
     """
     A single request with static or dynamic path, headers, query, and body params.
@@ -126,10 +113,14 @@ class SaaSRequest(BaseModel):
     grouped_inputs: Optional[List[str]] = []
     ignore_errors: Optional[Union[bool, List[int]]] = False
     rate_limit_config: Optional[RateLimitConfig] = None
-    async_config: Optional[AsyncConfig] = None
+    async_config: Optional[Strategy] = None
     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"
     )
@@ -228,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
@@ -245,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/system.py

@@ -2,6 +2,7 @@ from datetime import datetime
 from typing import Any, Dict, List, Optional, Sequence
 
 from fideslang.models import PrivacyDeclaration, System
+from fideslang.validation import FidesKey
 from pydantic import ConfigDict, Field
 from pydantic.main import BaseModel
 
@@ -61,3 +62,10 @@ class SystemHistoryResponse(BaseModel):
     after: Dict[str, Any]
     created_at: datetime
     model_config = ConfigDict(from_attributes=True)
+
+
+class AssignStewardRequest(BaseModel):
+    """Request schema for assigning a data steward to one or more systems."""
+
+    data_steward: str
+    system_keys: List[FidesKey]

fides/api/schemas/taxonomy_extensions.py

@@ -23,6 +23,10 @@ class DataUse(BaseDataUse):
 
 class DataCategory(BaseDataCategory):
     active: bool = active_field
+    tagging_instructions: Optional[str] = Field(
+        default=None,
+        description="Instructions for LLM-based data classification tagging.",
+    )
 
 
 class DataSubject(BaseDataSubject):
@@ -44,6 +48,10 @@ class DataUseCreateOrUpdate(TaxonomyCreateOrUpdateBase):
 
 class DataCategoryCreateOrUpdate(TaxonomyCreateOrUpdateBase):
     parent_key: Optional[FidesKey] = None
+    tagging_instructions: Optional[str] = Field(
+        default=None,
+        description="Instructions for LLM-based data classification tagging.",
+    )
 
 
 class DataSubjectCreateOrUpdate(TaxonomyCreateOrUpdateBase):

fides/api/schemas/user.py

@@ -10,8 +10,8 @@ from fides.api.schemas.base_class import FidesSchema
 from fides.api.schemas.oauth import AccessToken
 
 
-class PrivacyRequestReviewer(FidesSchema):
-    """Data we can expose via the PrivacyRequest.reviewer relation"""
+class PrivacyRequestUser(FidesSchema):
+    """Data we can expose via PrivacyRequest user relations (reviewer, submitter, etc.)"""
 
     id: str
     username: 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