ethyca-fides 2.68.1b1__py2.py3-none-any.whl → 2.68.1b3__py2.py3-none-any.whl

fides/api/db/base.py

@@ -76,6 +76,12 @@ from fides.api.models.storage import StorageConfig
 from fides.api.models.system_compass_sync import SystemCompassSync
 from fides.api.models.system_history import SystemHistory
 from fides.api.models.system_manager import SystemManager
+from fides.api.models.taxonomy import (
+    Taxonomy,
+    TaxonomyAllowedUsage,
+    TaxonomyElement,
+    TaxonomyUsage,
+)
 from fides.api.models.tcf_publisher_restrictions import (
     TCFConfiguration,
     TCFPublisherRestriction,

fides/api/models/detection_discovery/core.py

@@ -432,11 +432,17 @@ class StagedResourceAncestor(Base):
 
                     # Execute batch when it reaches the desired size
                     if len(current_batch) >= batch_size:
+                        logger.debug(
+                            f"Inserting batch of {len(current_batch)} staged resource ancestor links"
+                        )
                         db.execute(stmt_text, current_batch)
                         current_batch = []
 
         # Execute any remaining items in the final batch
         if current_batch:
+            logger.debug(
+                f"Inserting batch of {len(current_batch)} staged resource ancestor links"
+            )
             db.execute(stmt_text, current_batch)
 
 

fides/api/models/privacy_request/request_task.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from enum import Enum as EnumType
 from typing import TYPE_CHECKING, List, Optional, Tuple
 
 from loguru import logger
@@ -15,6 +16,7 @@ from sqlalchemy_utils.types.encrypted.encrypted_type import (
 )
 
 from fides.api.db.base_class import Base, JSONTypeOverride  # type: ignore[attr-defined]
+from fides.api.db.util import EnumColumn
 from fides.api.graph.config import (
     ROOT_COLLECTION_ADDRESS,
     TERMINATOR_ADDRESS,
@@ -67,6 +69,24 @@ class TraversalDetails(FidesSchema):
         )
 
 
+class AsyncTaskType(EnumType):
+    """
+    Enum for asynchronous RequestTask types
+
+    These tasks differ from our regular tasks in that they are not finished on the same process that they are created,
+    but rather are put into a pause state and then triggered to completion by a different process
+
+    manual: A task that is manually triggered by the user
+    polling: A task that is triggered by a polling mechanism
+    callback: A task that is triggered by a callback from an external system
+
+    """
+
+    manual = "manual"
+    polling = "polling"
+    callback = "callback"
+
+
 # TODO: At some point we will refactor this model to store all task types in a common table that links to tables with specific task attributes.
 class RequestTask(WorkerTask, Base):
     """
@@ -145,6 +165,11 @@ class RequestTask(WorkerTask, Base):
 
     # For async tasks awaiting callback
     callback_succeeded = Column(Boolean)
+    # to recognize Polling async task
+    async_type = Column(
+        EnumColumn(AsyncTaskType, native_enum=True),
+        nullable=True,
+    )
 
     # Stores a serialized collection that can be transformed back into a Collection to help
     # execute the current task

fides/api/models/taxonomy.py

@@ -0,0 +1,275 @@
+# pylint: disable=protected-access
+from __future__ import annotations
+
+from enum import Enum
+from typing import Any, Dict, List, Optional, Type
+
+from sqlalchemy import (
+    BOOLEAN,
+    Column,
+    ForeignKey,
+    ForeignKeyConstraint,
+    String,
+    Text,
+    UniqueConstraint,
+)
+from sqlalchemy.ext.associationproxy import association_proxy
+from sqlalchemy.ext.declarative import declared_attr
+from sqlalchemy.orm import RelationshipProperty, Session, relationship
+
+from fides.api.common_exceptions import ValidationError
+from fides.api.db.base_class import Base
+from fides.api.models.sql_models import FidesBase  # type: ignore[attr-defined]
+
+LEGACY_TAXONOMIES = {"data_categories", "data_uses", "data_subjects"}
+
+
+class TargetType(str, Enum):
+    """Enumeration of target types that taxonomies can apply to."""
+
+    SYSTEM = "system"
+    PRIVACY_DECLARATION = "privacy_declaration"
+    TAXONOMY = "taxonomy"  # For taxonomy-to-taxonomy relationships
+
+
+class Taxonomy(Base, FidesBase):
+    """The SQL model for taxonomy resources.
+
+    This is a generic taxonomy model that can be used to create any taxonomy.
+    For now we seed the database with the legacy taxonomies (data_category, data use, data subject)
+    so that these legacy taxonomy types can be used for allowed usage relationships.
+    """
+
+    # Overriding the id definition from Base so we don't treat this as the primary key
+    id = Column(
+        String(255),
+        nullable=False,
+        index=False,
+        unique=True,
+        default=FidesBase.generate_uuid,
+    )
+
+    # The fides_key is inherited from FidesBase and acts as the primary key
+
+    # This is private to encourage the use of applies_to (see comment below)
+    _allowed_usages: RelationshipProperty[List[TaxonomyAllowedUsage]] = relationship(
+        "TaxonomyAllowedUsage",
+        back_populates="source_taxonomy",
+        cascade="all, delete-orphan",
+        lazy="selectin",
+    )
+
+    # Association proxy to simplify access to target_type values
+    # This allows getting a list of strings while the actual storage
+    # is handled through the TaxonomyAllowedUsage model
+    # Updates should be done through the create/update methods
+    applies_to: List[str] = association_proxy(
+        "_allowed_usages",
+        "target_type",
+        # Allow setting via strings, the relationship backref will set FK
+        creator=lambda target_type: TaxonomyAllowedUsage(target_type=target_type),
+    )
+
+    @classmethod
+    def create(
+        cls: Type["Taxonomy"],
+        db: Session,
+        *,
+        data: Dict[str, Any],
+        check_name: bool = True,
+    ) -> "Taxonomy":
+        """Create a new Taxonomy with proper handling of applies_to."""
+        # Disallow creating taxonomies that represent legacy types
+        fides_key = data.get("fides_key")
+        if fides_key in LEGACY_TAXONOMIES:
+            raise ValidationError(
+                f"Cannot create taxonomy '{fides_key}'. This is a taxonomy managed by the system."
+            )
+        applies_to = data.pop("applies_to", [])
+
+        # Create the taxonomy
+        taxonomy: Taxonomy = super().create(db=db, data=data, check_name=check_name)
+
+        # Reconcile allowed usages if applies_to was provided
+        if applies_to:
+            taxonomy._reconcile_allowed_usages(db, applies_to)
+
+        return cls.persist_obj(db, taxonomy)
+
+    def update(self, db: Session, *, data: Dict[str, Any]) -> "Taxonomy":
+        """Update a Taxonomy with proper handling of applies_to."""
+        applies_to = data.pop("applies_to", None)
+
+        # Update the base fields
+        super().update(db=db, data=data)
+
+        # If applies_to was provided, reconcile allowed usages
+        if applies_to is not None:
+            self._reconcile_allowed_usages(db, applies_to)
+
+        return self
+
+    def save(self, db: Session) -> "Taxonomy":
+        """Override save to reconcile any direct `applies_to` edits before persisting.
+
+        This allows callers to mutate `applies_to` via the association proxy and then call save.
+        """
+        # Ensure no duplicate target types and reconcile relationship objects to the current values
+        self._reconcile_allowed_usages(db, list(self.applies_to))
+        return super().save(db)  # type: ignore[return-value]
+
+    def _reconcile_allowed_usages(self, db: Session, applies_to: List[str]) -> None:
+        """Ensure `_allowed_usages` matches the provided `applies_to` list.
+
+        - Deletes usages not in the provided list
+        - Creates usages missing from the relationship
+        - Deduplicates by target_type
+        """
+        existing_usages = {usage.target_type: usage for usage in self._allowed_usages}
+        desired_types = set(applies_to)
+
+        # Delete usages that should no longer exist
+        for target_type in set(existing_usages.keys()) - desired_types:
+            # Remove from relationship; delete-orphan cascade will handle DB delete
+            self._allowed_usages.remove(existing_usages[target_type])
+
+        # Add missing usages
+        for target_type in desired_types - set(existing_usages.keys()):
+            self._allowed_usages.append(TaxonomyAllowedUsage(target_type=target_type))
+
+        # Deduplicate any accidental duplicates in-memory
+        seen: set[str] = set()
+        for usage in list(self._allowed_usages):
+            if usage.target_type in seen:
+                # Remove duplicate from relationship; delete-orphan will handle DB
+                self._allowed_usages.remove(usage)
+            else:
+                seen.add(usage.target_type)
+
+
+class TaxonomyAllowedUsage(Base):
+    """
+    The SQL model for taxonomy allowed usage.
+    Defines what types of targets a taxonomy can be applied to.
+
+    target_type can be either:
+    - A generic type: "system", "privacy_declaration", "taxonomy"
+    - A taxonomy key: "data_categories", "data_uses", etc.
+    """
+
+    @declared_attr
+    def __tablename__(self) -> str:
+        return "taxonomy_allowed_usage"
+
+    id = Column(
+        String(255),
+        nullable=False,
+        index=False,
+        unique=True,
+        default=FidesBase.generate_uuid,
+    )
+
+    source_taxonomy: RelationshipProperty[Taxonomy] = relationship(
+        "Taxonomy",
+        back_populates="_allowed_usages",
+    )
+
+    source_taxonomy_key: Column[str] = Column(
+        String,
+        ForeignKey("taxonomy.fides_key", ondelete="CASCADE"),
+        primary_key=True,
+    )
+    target_type: Column[str] = Column(
+        String, primary_key=True
+    )  # Can be "system", "dataset", OR a taxonomy key like "data_categories"
+
+
+class TaxonomyElement(Base, FidesBase):
+    """
+    The SQL model for taxonomy elements.
+
+    This is a generic taxonomy element model that can be used to create any taxonomy element.
+
+    As of now the legacy taxonomy elements still exist in their own tables (ctl_data_categories, ctl_data_uses, ctl_data_subjects),
+    but we can migrate them to this model in the future if needed.
+    """
+
+    @declared_attr
+    def __tablename__(self) -> str:
+        return "taxonomy_element"
+
+    id = Column(
+        String(255),
+        nullable=False,
+        index=False,
+        unique=True,
+        default=FidesBase.generate_uuid,
+    )
+
+    # Which taxonomy this element belongs to
+    taxonomy_type = Column(
+        String,
+        ForeignKey("taxonomy.fides_key", ondelete="CASCADE"),
+        nullable=False,
+        index=True,
+    )
+
+    parent_key = Column(
+        Text, ForeignKey("taxonomy_element.fides_key", ondelete="RESTRICT"), index=True
+    )
+    active = Column(BOOLEAN, default=True, nullable=False, index=True)
+
+    children: RelationshipProperty[List[TaxonomyElement]] = relationship(
+        "TaxonomyElement",
+        back_populates="parent",
+        cascade="save-update, merge, refresh-expire",  # intentionally do not cascade deletes
+        passive_deletes="all",
+    )
+
+    parent: RelationshipProperty[Optional[TaxonomyElement]] = relationship(
+        "TaxonomyElement",
+        back_populates="children",
+        remote_side="TaxonomyElement.fides_key",
+    )
+
+
+class TaxonomyUsage(Base):
+    """
+    The SQL model for taxonomy usage.
+    Tracks the application of taxonomy elements to other taxonomy elements.
+
+    Example: Applying a "high" tag (from sensitivity taxonomy) to "user.contact.email" (from data_categories taxonomy).
+    """
+
+    @declared_attr
+    def __tablename__(self) -> str:
+        return "taxonomy_usage"
+
+    # The taxonomy element being applied (e.g., risk)
+    source_element_key = Column(String, nullable=False, index=True)
+
+    # The taxonomy element it's being applied to (e.g., a data category)
+    target_element_key = Column(String, nullable=False, index=True)
+
+    # Denormalized taxonomy types for validation and performance
+    source_taxonomy = Column(String, nullable=False, index=True)
+    target_taxonomy = Column(String, nullable=False, index=True)
+
+    __table_args__ = (
+        # Validate that this type of usage is allowed
+        ForeignKeyConstraint(
+            ["source_taxonomy", "target_taxonomy"],
+            [
+                "taxonomy_allowed_usage.source_taxonomy_key",
+                "taxonomy_allowed_usage.target_type",
+            ],
+            ondelete="RESTRICT",
+            name="fk_taxonomy_usage_allowed",
+        ),
+        # Prevent duplicate applications
+        UniqueConstraint(
+            "source_element_key",
+            "target_element_key",
+            name="uq_taxonomy_usage",
+        ),
+    )

fides/api/schemas/privacy_center_config.py

@@ -1,3 +1,4 @@
+from abc import ABC
 from typing import Any, Dict, List, Literal, Optional, Union
 
 from pydantic import ConfigDict, Field, field_validator, model_validator
@@ -12,22 +13,10 @@ class CustomIdentity(FidesSchema):
     label: str
 
 
-class LocationIdentityField(FidesSchema):
-    """Location field configuration that extends the useful parts of CustomPrivacyRequestField"""
-
-    label: str
-    required: Optional[bool] = True
-    default_value: Optional[str] = None
-    query_param_key: Optional[str] = None
-    ip_geolocation_hint: Optional[bool] = False
-    # Note: We intentionally omit 'hidden' field as it doesn't make sense for location identity input
-
-
 class IdentityInputs(FidesSchema):
     name: Optional[RequiredType] = None
     email: Optional[RequiredType] = None
     phone: Optional[RequiredType] = None
-    location: Optional[Union[RequiredType, LocationIdentityField]] = None
     model_config = ConfigDict(extra="allow")
 
     def __init__(self, **data: Any):
@@ -42,13 +31,12 @@ class IdentityInputs(FidesSchema):
                         f'Custom identity "{field}" must be an instance of CustomIdentity '
                         '(e.g. {"label": "Field label"})'
                     )
-            elif field == "location" and isinstance(value, dict):
-                # Handle location field as LocationIdentityField
-                data[field] = LocationIdentityField(**value)
         super().__init__(**data)
 
 
-class CustomPrivacyRequestField(FidesSchema):
+class BaseCustomPrivacyRequestField(FidesSchema, ABC):
+    """Abstract base class for all custom privacy request fields"""
+
     label: str
     required: Optional[bool] = True
     default_value: Optional[str] = None
@@ -69,6 +57,41 @@ class CustomPrivacyRequestField(FidesSchema):
         return values
 
 
+class CustomPrivacyRequestField(BaseCustomPrivacyRequestField):
+    """Regular custom privacy request field supporting text, select, and multiselect types"""
+
+    field_type: Optional[Literal["text", "select", "multiselect"]] = None
+    options: Optional[List[str]] = None
+
+
+class LocationCustomPrivacyRequestField(BaseCustomPrivacyRequestField):
+    """Location field that doesn't support options and includes IP geolocation hint"""
+
+    field_type: Literal["location"] = "location"
+    ip_geolocation_hint: Optional[bool] = False
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_location_field(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        # Ensure options is not provided for location fields
+        if "options" in values:
+            raise ValueError(
+                "LocationCustomPrivacyRequestField does not support options"
+            )
+
+        # This field cannot be hidden
+        if values.get("hidden"):
+            raise ValueError("Custom location fields cannot be hidden")
+
+        return values
+
+
+# Create a simple union type - Pydantic will use the field_type to determine which model to use
+CustomPrivacyRequestFieldUnion = Union[
+    LocationCustomPrivacyRequestField, CustomPrivacyRequestField
+]
+
+
 class PrivacyRequestOption(FidesSchema):
     locations: Optional[Union[List[PrivacyNoticeRegion], Literal["fallback"]]] = None
     policy_key: Optional[str] = None
@@ -79,7 +102,9 @@ class PrivacyRequestOption(FidesSchema):
     confirm_button_text: Optional[str] = Field(alias="confirmButtonText", default=None)
     cancel_button_text: Optional[str] = Field(alias="cancelButtonText", default=None)
     identity_inputs: Optional[IdentityInputs] = None
-    custom_privacy_request_fields: Optional[Dict[str, CustomPrivacyRequestField]] = None
+    custom_privacy_request_fields: Optional[
+        Dict[str, CustomPrivacyRequestFieldUnion]
+    ] = None
 
 
 class ConsentConfigButton(FidesSchema):
@@ -89,7 +114,9 @@ class ConsentConfigButton(FidesSchema):
     cancel_button_text: Optional[str] = Field(alias="cancelButtonText", default=None)
     icon_path: str
     identity_inputs: IdentityInputs
-    custom_privacy_request_fields: Optional[Dict[str, CustomPrivacyRequestField]] = None
+    custom_privacy_request_fields: Optional[
+        Dict[str, CustomPrivacyRequestFieldUnion]
+    ] = None
     title: str
     modal_title: Optional[str] = Field(alias="modalTitle", default=None)
 
@@ -174,7 +201,9 @@ class PartialPrivacyRequestOption(FidesSchema):
     policy_key: str
     title: str
     identity_inputs: Optional[IdentityInputs] = None
-    custom_privacy_request_fields: Optional[Dict[str, CustomPrivacyRequestField]] = None
+    custom_privacy_request_fields: Optional[
+        Dict[str, CustomPrivacyRequestFieldUnion]
+    ] = None
 
 
 class PartialPrivacyCenterConfig(FidesSchema):

fides/api/schemas/storage/storage.py

@@ -37,6 +37,7 @@ class StorageDetails(Enum):
     NAMING = "naming"
     MAX_RETRIES = "max_retries"
     AUTH_METHOD = "auth_method"
+    ENABLE_STREAMING = "enable_streaming"
     model_config = ConfigDict(extra="forbid")
 
 
@@ -58,6 +59,7 @@ class StorageDetailsS3(FileBasedStorageDetails):
     auth_method: AWSAuthMethod
     bucket: str
     max_retries: Optional[int] = 0
+    enable_streaming: Optional[bool] = False
     model_config = ConfigDict(use_enum_values=True)
 
 

fides/api/service/async_dsr/async_dsr_service.py

@@ -0,0 +1,75 @@
+from loguru import logger
+from sqlalchemy.orm import Session
+
+from fides.api.common_exceptions import PrivacyRequestError
+from fides.api.models.connectionconfig import ConnectionConfig
+from fides.api.models.datasetconfig import DatasetConfig
+from fides.api.models.privacy_request import PrivacyRequest, RequestTask
+from fides.api.schemas.privacy_request import PrivacyRequestStatus
+from fides.api.task.task_resources import TaskResources
+
+
+def requeue_polling_request(
+    db: Session,
+    async_task: RequestTask,
+) -> None:
+    """Re-queue a Privacy request that polls async tasks for a given privacy request"""
+    # Check that the privacy request is approved or in processing
+    privacy_request: PrivacyRequest = async_task.privacy_request
+
+    if privacy_request.status not in [
+        PrivacyRequestStatus.approved,
+        PrivacyRequestStatus.in_processing,
+    ]:
+        raise PrivacyRequestError(
+            f"Cannot re-queue privacy request {privacy_request.id} with status {privacy_request.status.value}"
+        )
+
+    logger.info(
+        "Polling starting for {} task {} {}",
+        async_task.action_type,
+        async_task.collection_address,
+        async_task.id,
+    )
+
+    connection_config = get_connection_config_from_task(db, async_task)
+
+    with TaskResources(
+        privacy_request,
+        privacy_request.policy,
+        [connection_config],
+        async_task,
+        db,
+    ) as resources:
+        # graph_task: GraphTask = create_graph_task(db, async_task, resources)
+        # Currently, upstream tasks and "input keys" (which are built by data dependencies)
+        # are the same, but they may not be the same in the future.
+        # upstream_tasks = async_task.upstream_tasks_objects(db)
+        # upstream_access_data: List[List[Row]] = _build_upstream_access_data(
+        #    graph_task.execution_node.input_keys, upstream_tasks
+        # )
+        # TODO: Implement the polling strategy
+        logger.info(f"found resources: {resources}")
+        return None
+
+
+def get_connection_config_from_task(
+    db: Session, request_task: RequestTask
+) -> ConnectionConfig:
+    dataset_config = DatasetConfig.filter(
+        db=db,
+        conditions=(DatasetConfig.fides_key == request_task.dataset_name),
+    ).first()
+    if not dataset_config:
+        raise PrivacyRequestError(
+            f"DatasetConfig with fides_key {request_task.dataset_name} not found."
+        )
+    connection_config = ConnectionConfig.get(
+        db=db, object_id=dataset_config.connection_config_id
+    )
+    if not connection_config:
+        raise PrivacyRequestError(
+            f"ConnectionConfig with id {dataset_config.connection_config_id} not found."
+        )
+
+    return connection_config

fides/api/service/connectors/saas_connector.py

@@ -11,7 +11,7 @@ from sqlalchemy.orm import Session
 from starlette.status import HTTP_204_NO_CONTENT
 
 from fides.api.common_exceptions import (
-    AwaitingAsyncTaskCallback,
+    AwaitingAsyncTask,
     FidesopsException,
     PostProcessingException,
     SkippingConsentPropagation,
@@ -229,7 +229,6 @@ class SaaSConnector(BaseConnector[AuthenticatedClient], Contextualizable):
         query_config: SaaSQueryConfig = self.query_config(node)
 
         # generate initial set of requests if read request is defined, otherwise raise an exception
-
         # An endpoint can be defined with multiple 'read' requests if the data for a single
         # collection can be accessed in multiple ways for example:
         #
@@ -336,8 +335,8 @@ class SaaSConnector(BaseConnector[AuthenticatedClient], Contextualizable):
         if awaiting_async_callback:
             # 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.
-            # Raising an AwaitingAsyncTaskCallback to put this task in an awaiting_processing state
-            raise AwaitingAsyncTaskCallback()
+            # Raising an AwaitingAsyncTask to put this task in an awaiting_processing state
+            raise AwaitingAsyncTask()
 
         return rows
 
@@ -641,8 +640,8 @@ class SaaSConnector(BaseConnector[AuthenticatedClient], Contextualizable):
         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 AwaitingAsyncTaskCallback to put this task in an awaiting_processing state.
-            raise AwaitingAsyncTaskCallback()
+            # and we raise an AwaitingAsyncTask to put this task in an awaiting_processing state.
+            raise AwaitingAsyncTask()
         return rows_updated
 
     @staticmethod

fides/api/service/deps.py

@@ -8,6 +8,7 @@ from fides.service.dataset.dataset_config_service import DatasetConfigService
 from fides.service.dataset.dataset_service import DatasetService
 from fides.service.messaging.messaging_service import MessagingService
 from fides.service.privacy_request.privacy_request_service import PrivacyRequestService
+from fides.service.taxonomy.taxonomy_service import TaxonomyService
 from fides.service.user.user_service import UserService
 
 
@@ -41,3 +42,7 @@ def get_user_service(
     config_proxy: ConfigProxy = Depends(get_config_proxy),
 ) -> UserService:
     return UserService(db, config, config_proxy)
+
+
+def get_taxonomy_service(db: Session = Depends(get_db)) -> TaxonomyService:
+    return TaxonomyService(db)

fides/api/service/privacy_request/dsr_package/dsr_report_builder.py

@@ -5,13 +5,12 @@ import zipfile
 from collections import defaultdict
 from io import BytesIO
 from pathlib import Path
-from typing import Any, Optional
+from typing import TYPE_CHECKING, Any, Optional
 
 import jinja2
 from jinja2 import Environment, FileSystemLoader
 from loguru import logger
 
-from fides.api.models.privacy_request import PrivacyRequest
 from fides.api.schemas.policy import ActionType
 from fides.api.util.storage_util import StorageJSONEncoder, format_size
 
@@ -21,6 +20,9 @@ TEXT_COLOR = "#4A5568"
 HEADER_COLOR = "#FAFAFA"
 BORDER_COLOR = "#E2E8F0"
 
+if TYPE_CHECKING:
+    from fides.api.models.privacy_request import PrivacyRequest  # pragma: no cover
+
 
 # pylint: disable=too-many-instance-attributes
 class DsrReportBuilder:
@@ -42,7 +44,7 @@ class DsrReportBuilder:
 
     def __init__(
         self,
-        privacy_request: PrivacyRequest,
+        privacy_request: "PrivacyRequest",
         dsr_data: dict[str, Any],
     ):
         """
@@ -387,7 +389,7 @@ class DsrReportBuilder:
         return self.baos
 
 
-def _map_privacy_request(privacy_request: PrivacyRequest) -> dict[str, Any]:
+def _map_privacy_request(privacy_request: "PrivacyRequest") -> dict[str, Any]:
     """Creates a map with a subset of values from the privacy request"""
     request_data: dict[str, Any] = {}
     request_data["id"] = privacy_request.id