ethyca-fides 2.70.3rc0__py2.py3-none-any.whl → 2.70.4b0__py2.py3-none-any.whl

fides/api/models/manual_task/conditional_dependency.py

@@ -1,13 +1,14 @@
-from enum import Enum
-from typing import TYPE_CHECKING, Optional, Union
+from typing import TYPE_CHECKING, Any, Optional, Union
 
-from sqlalchemy import Column, ForeignKey, Index, Integer, String
-from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy import Column, ForeignKey, Index, String
 from sqlalchemy.ext.declarative import declared_attr
 from sqlalchemy.orm import Session, relationship
 
-from fides.api.db.base_class import Base, FidesBase
-from fides.api.db.util import EnumColumn
+from fides.api.db.base_class import FidesBase
+from fides.api.models.conditional_dependency.conditional_dependency_base import (
+    ConditionalDependencyBase,
+    ConditionalDependencyType,
+)
 from fides.api.task.conditional_dependencies.schemas import (
     ConditionGroup,
     ConditionLeaf,
@@ -17,42 +18,16 @@ if TYPE_CHECKING:
     from fides.api.models.manual_task.manual_task import ManualTask
 
 
-class ManualTaskConditionalDependencyType(str, Enum):
-    """Enum for manual task conditional dependency types.
-
-    This enum defines the two types of nodes in a conditional dependency tree:
-
-    - leaf: A terminal node that represents a single condition (e.g., "user.age >= 18")
-    - group: A non-terminal node that groups multiple conditions with logical operators (AND/OR)
-
-    Examples:
-        leaf: Used for simple field comparisons like:
-            - "user.name exists"
-            - "user.age >= 18"
-            - "billing.subscription.status == 'active'"
-
-        group: Used to combine multiple conditions with logical operators:
-            - AND group: "user.age >= 18 AND user.active == true"
-            - OR group: "user.role == 'admin' OR user.verified == true"
-            - Nested groups: "(user.age >= 18 AND (user.role == 'admin' OR user.verified == true))"
-    """
-
-    leaf = "leaf"
-    group = "group"
-
-
-class ManualTaskConditionalDependency(Base):
-    """Model for storing conditional dependencies."""
+class ManualTaskConditionalDependency(ConditionalDependencyBase):
+    """Manual task conditional dependencies - single type hierarchy."""
 
     @declared_attr
     def __tablename__(cls) -> str:
-        """Overriding base class method to set the table name."""
         return "manual_task_conditional_dependency"
 
     # We need to redefine it here so that self-referential relationships
     # can properly reference the `id` column instead of the built-in Python function.
     id = Column(String(255), primary_key=True, default=FidesBase.generate_uuid)
-
     # Foreign key relationships
     manual_task_id = Column(
         String, ForeignKey("manual_task.id", ondelete="CASCADE"), nullable=False
@@ -63,18 +38,6 @@ class ManualTaskConditionalDependency(Base):
         nullable=True,
     )
 
-    # Condition metadata
-    condition_type = Column(
-        EnumColumn(ManualTaskConditionalDependencyType), nullable=False
-    )  # leaf or group
-    field_address = Column(String, nullable=True)  # For leaf conditions
-    operator = Column(String, nullable=True)  # For leaf conditions
-    value = Column(JSONB, nullable=True)  # For leaf conditions
-    logical_operator = Column(String, nullable=True)  # 'and' or 'or' for groups
-
-    # Ordering
-    sort_order = Column(Integer, nullable=False, default=0)
-
     __table_args__ = (
         Index("ix_manual_task_conditional_dependency_manual_task_id", "manual_task_id"),
         Index("ix_manual_task_conditional_dependency_parent_id", "parent_id"),
@@ -97,38 +60,20 @@ class ManualTaskConditionalDependency(Base):
         foreign_keys=[parent_id],
     )
 
-    def to_condition_leaf(self) -> ConditionLeaf:
-        """Convert to ConditionLeaf if this is a leaf condition"""
-        if self.condition_type != "leaf":
-            raise ValueError("Cannot convert group condition to leaf")
-
-        return ConditionLeaf(
-            field_address=self.field_address, operator=self.operator, value=self.value
-        )
-
-    def to_condition_group(self) -> ConditionGroup:
-        """Convert to ConditionGroup if this is a group condition"""
-        if self.condition_type != "group":
-            raise ValueError("Cannot convert leaf condition to group")
-
-        # Recursively build children
-        child_conditions = []
-        children_list = [child for child in self.children]  # type: ignore[attr-defined]
-        for child in sorted(children_list, key=lambda x: x.sort_order):
-            if child.condition_type == "leaf":
-                child_conditions.append(child.to_condition_leaf())
-            else:
-                child_conditions.append(child.to_condition_group())
-
-        return ConditionGroup(
-            logical_operator=self.logical_operator, conditions=child_conditions
-        )
-
     @classmethod
     def get_root_condition(
-        cls, db: Session, manual_task_id: str
+        cls, db: Session, *args: Any, **kwargs: Any
     ) -> Optional[Union[ConditionLeaf, ConditionGroup]]:
-        """Get the root condition for a config"""
+        """Get the root condition for a manual task
+
+        Args:
+            db: Database session
+            manual_task_id: ID of the manual task (first positional arg)
+        """
+        if not args:
+            raise ValueError("manual_task_id is required as first positional argument")
+
+        manual_task_id = args[0]
         root = (
             db.query(cls)
             .filter(cls.manual_task_id == manual_task_id, cls.parent_id.is_(None))
@@ -138,7 +83,6 @@ class ManualTaskConditionalDependency(Base):
         if not root:
             return None
 
-        if root.condition_type == "leaf":
+        if root.condition_type == ConditionalDependencyType.leaf:
             return root.to_condition_leaf()
-
         return root.to_condition_group()

fides/api/models/policy.py

@@ -177,6 +177,30 @@ class Policy(Base):
             for category in node.get_data_categories()
         )
 
+    def to_safe_dict(self) -> Dict[str, Any]:
+        """
+        Returns a dictionary representation of the Policy, excluding sensitive information.
+        """
+        return {
+            "id": self.id,
+            "name": self.name,
+            "key": self.key,
+            "drp_action": self.drp_action.value if self.drp_action else None,  # type: ignore[attr-defined]
+            "execution_timeframe": self.execution_timeframe,
+            "client_id": self.client_id,
+            "rules": [
+                {
+                    "id": rule.id,
+                    "name": rule.name,
+                    "key": rule.key,
+                    "action_type": rule.action_type.value,
+                    "masking_strategy": rule.masking_strategy,
+                    "storage_destination_id": rule.storage_destination_id,
+                }
+                for rule in self.rules  # type: ignore[attr-defined]
+            ],
+        }
+
 
 def _get_ref_from_taxonomy(
     fides_key: FidesKey,

fides/api/models/privacy_notice.py

@@ -41,7 +41,7 @@ class UserConsentPreference(Enum):
     tcf = "tcf"  # Overall preference set for TCF where there are numerous preferences under the single notice
 
 
-class ConsentMechanism(Enum):
+class ConsentMechanism(str, Enum):
     """
     Enum is not formalized in the DB because it may be subject to frequent change
     """

fides/api/models/privacy_request/privacy_request.py

@@ -261,6 +261,12 @@ class PrivacyRequest(
         foreign_keys=[reviewed_by],
     )
 
+    submitter = relationship(
+        FidesUser,
+        backref=backref("submitted_privacy_requests", passive_deletes=True),
+        foreign_keys=[submitted_by],
+    )
+
     pre_approval_webhook_replies = relationship(
         PreApprovalWebhookReply,
         back_populates="privacy_request",
@@ -355,6 +361,64 @@ class PrivacyRequest(
 
         return super().create(db=db, data=data, check_name=check_name)
 
+    def to_safe_dict(self) -> Dict[str, Any]:
+        """
+        Return a dict representation of the PrivacyRequest, excluding any fields
+        that may contain sensitive information.
+        """
+        return {
+            "id": self.id,
+            "external_id": self.external_id,
+            "status": self.status.value,
+            "requested_at": (
+                self.requested_at.isoformat() if self.requested_at else None
+            ),
+            "started_processing_at": (
+                self.started_processing_at.isoformat()
+                if self.started_processing_at
+                else None
+            ),
+            "finished_processing_at": (
+                self.finished_processing_at.isoformat()
+                if self.finished_processing_at
+                else None
+            ),
+            "reviewed_at": self.reviewed_at.isoformat() if self.reviewed_at else None,
+            "reviewed_by": self.reviewed_by,
+            "finalized_at": (
+                self.finalized_at.isoformat() if self.finalized_at else None
+            ),
+            "finalized_by": self.finalized_by,
+            "submitted_by": self.submitted_by,
+            "custom_privacy_request_fields_approved_by": (
+                self.custom_privacy_request_fields_approved_by
+            ),
+            "identity_verified_at": (
+                self.identity_verified_at.isoformat()
+                if self.identity_verified_at
+                else None
+            ),
+            "custom_privacy_request_fields_approved_at": (
+                self.custom_privacy_request_fields_approved_at.isoformat()
+                if self.custom_privacy_request_fields_approved_at
+                else None
+            ),
+            "client_id": self.client_id,
+            "origin": self.origin,
+            "policy_id": self.policy_id,
+            "policy": self.policy.to_safe_dict() if self.policy else None,
+            "property_id": self.property_id,
+            "cancel_reason": self.cancel_reason,
+            "canceled_at": self.canceled_at.isoformat() if self.canceled_at else None,
+            "consent_preferences": self.consent_preferences,
+            "source": self.source.value if self.source else None,
+            "paused_at": self.paused_at.isoformat() if self.paused_at else None,
+            "due_date": self.due_date.isoformat() if self.due_date else None,
+            "days_left": self.days_left,
+            "custom_fields": self.get_persisted_custom_privacy_request_fields() if self.custom_fields else None,  # type: ignore[attr-defined]
+            "location": self.location,
+        }
+
     def clear_cached_values(self) -> None:
         """
         Clears all cached values associated with this privacy request from Redis.
@@ -903,6 +967,8 @@ class PrivacyRequest(
             callback_type=CallbackType.pre_approval,
             identity=self.get_cached_identity_data(),
             policy_action=policy_action,
+            privacy_request=self.to_safe_dict(),
+            timestamp=datetime.utcnow(),
         )
         headers = {
             "reply-to-approve": f"/privacy-request/{self.id}/pre-approve/eligible",
@@ -943,6 +1009,8 @@ class PrivacyRequest(
             callback_type=webhook.prefix,
             identity=self.get_cached_identity_data(),
             policy_action=policy_action,
+            privacy_request=self.to_safe_dict(),
+            timestamp=datetime.utcnow(),
         )
 
         headers = {}

fides/api/models/privacy_request/webhook.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import json
 from datetime import datetime
 from enum import Enum as EnumType
-from typing import Optional
+from typing import Any, Dict, Optional
 
 from pydantic import BaseModel, ConfigDict
 
@@ -51,6 +51,8 @@ class SecondPartyRequestFormat(BaseModel):
     identity: Identity
     policy_action: Optional[ActionType] = None
     model_config = ConfigDict(use_enum_values=True)
+    privacy_request: Dict[str, Any]
+    timestamp: datetime
 
 
 def generate_request_callback_resume_jwe(webhook: PolicyPreWebhook) -> str:

fides/api/oauth/roles.py

@@ -26,6 +26,7 @@ from fides.common.api.scope_registry import (
     PRIVACY_EXPERIENCE_READ,
     PRIVACY_NOTICE_READ,
     PRIVACY_REQUEST_CALLBACK_RESUME,
+    PRIVACY_REQUEST_CREATE,
     PRIVACY_REQUEST_DELETE,
     PRIVACY_REQUEST_EMAIL_INTEGRATIONS_SEND,
     PRIVACY_REQUEST_MANUAL_STEPS_RESPOND,
@@ -88,6 +89,7 @@ approver_scopes = [
     PRIVACY_REQUEST_UPLOAD_DATA,
     PRIVACY_REQUEST_VIEW_DATA,
     PRIVACY_REQUEST_DELETE,
+    PRIVACY_REQUEST_CREATE,  # allows approvers to create new privacy requests
     USER_READ,  # allows approver to view user management table and update their own password
     PRIVACY_REQUEST_MANUAL_STEPS_REVIEW,  # allows approvers to see all manual steps
 ]

fides/api/schemas/privacy_request.py

@@ -14,7 +14,7 @@ from fides.api.schemas.base_class import FidesSchema
 from fides.api.schemas.policy import ActionType, CurrentStep
 from fides.api.schemas.policy import PolicyResponse as PolicySchema
 from fides.api.schemas.redis_cache import CustomPrivacyRequestField, Identity
-from fides.api.schemas.user import PrivacyRequestReviewer
+from fides.api.schemas.user import PrivacyRequestUser
 from fides.api.util.collection_util import Row
 from fides.api.util.encryption.aes_gcm_encryption_scheme import verify_encryption_key
 from fides.api.util.enums import ColumnSort
@@ -316,7 +316,9 @@ class PrivacyRequestResponse(FidesSchema):
     started_processing_at: Optional[datetime] = None
     reviewed_at: Optional[datetime] = None
     reviewed_by: Optional[str] = None
-    reviewer: Optional[PrivacyRequestReviewer] = None
+    submitted_by: Optional[str] = None
+    reviewer: Optional[PrivacyRequestUser] = None
+    submitter: Optional[PrivacyRequestUser] = None
     finished_processing_at: Optional[datetime] = None
     identity_verified_at: Optional[datetime] = None
     paused_at: Optional[datetime] = None

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/privacy_request/dsr_package/dsr_report_builder.py

@@ -26,7 +26,7 @@ from fides.api.service.storage.util import (
     is_attachment_field,
     process_attachment_naming,
     process_attachments_contextually,
-    resolve_directory_from_context,
+    resolve_path_from_context,
 )
 from fides.api.util.storage_util import StorageJSONEncoder, format_size
 from fides.config import CONFIG
@@ -226,7 +226,7 @@ class DSRReportBuilder:
             file_size = format_attachment_size(attachment.get("file_size"))
 
             # Determine the actual directory for this attachment based on its context
-            actual_directory = resolve_directory_from_context(attachment, directory)
+            actual_directory = resolve_path_from_context(attachment, directory)
 
             # Generate attachment URL using shared utility with actual storage path
             download_url = attachment.get("download_url")

fides/api/service/storage/streaming/smart_open_streaming_storage.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 import csv
 import json
 import time
+from copy import deepcopy
 from datetime import datetime
 from io import BytesIO, StringIO
 from itertools import chain
@@ -36,13 +37,11 @@ from fides.api.service.storage.streaming.schemas import (
 )
 from fides.api.service.storage.streaming.smart_open_client import SmartOpenStorageClient
 from fides.api.service.storage.util import (
-    convert_processed_attachments_to_attachment_processing_info,
     determine_dataset_name_from_path,
-    extract_storage_key_from_attachment,
     get_unique_filename,
     process_attachments_contextually,
     resolve_attachment_storage_path,
-    resolve_base_path_from_context,
+    resolve_path_from_context,
 )
 
 DEFAULT_ATTACHMENT_NAME = "attachment"
@@ -169,7 +168,9 @@ class SmartOpenStreamingStorage:
         """
         try:
             # Extract storage key using shared utility
-            storage_key = extract_storage_key_from_attachment(attachment)
+            storage_key = (
+                attachment.get("download_url") or attachment.get("file_name") or ""
+            )
             if not storage_key:
                 return None
 
@@ -182,7 +183,7 @@ class SmartOpenStreamingStorage:
             )
 
             # Resolve base path using shared utility
-            base_path = resolve_base_path_from_context(attachment)
+            base_path = resolve_path_from_context(attachment)
 
             # Create AttachmentProcessingInfo
             processing_info = AttachmentProcessingInfo(
@@ -281,7 +282,11 @@ class SmartOpenStreamingStorage:
             ) from e
 
     def _collect_and_validate_attachments(
-        self, data: dict
+        self,
+        data: dict,
+        used_filenames_data: set[str],
+        used_filenames_attachments: set[str],
+        processed_attachments: dict[tuple[str, str], str],
     ) -> list[AttachmentProcessingInfo]:
         """Collect and validate attachments using the same contextual approach as DSR report builder.
 
@@ -294,26 +299,30 @@ class SmartOpenStreamingStorage:
         Returns:
             List of validated AttachmentProcessingInfo objects
         """
-        # Initialize tracking structures (similar to DSR report builder)
-        used_filenames_data: set[str] = set()
-        used_filenames_attachments: set[str] = set()
-        processed_attachments: dict[tuple[str, str], str] = {}
+        validated_attachments = []
 
         # Use the shared contextual processing function
         # Note: This method should only be used when DSR report builder is not available
         # For HTML format, use _collect_and_validate_attachments_from_dsr_builder instead
         processed_attachments_list = process_attachments_contextually(
-            data,
-            used_filenames_data,
-            used_filenames_attachments,
-            processed_attachments,
-            enable_streaming=True,  # Always use streaming mode for storage
+            data=data,
+            used_filenames_data=used_filenames_data,
+            used_filenames_attachments=used_filenames_attachments,
+            processed_attachments=processed_attachments,
+            enable_streaming=True,
         )
 
-        # Convert to AttachmentProcessingInfo objects using shared utility
-        return convert_processed_attachments_to_attachment_processing_info(
-            processed_attachments_list, self._validate_attachment
-        )
+        for processed_attachment in processed_attachments_list:
+            # Add context information to the attachment data
+            attachment_with_context = deepcopy(processed_attachment["attachment"])
+            attachment_with_context["_context"] = processed_attachment["context"]
+
+            # Validate and convert to AttachmentProcessingInfo
+            validated = self._validate_attachment(attachment_with_context)
+            if validated:
+                validated_attachments.append(validated)
+
+        return validated_attachments
 
     def _collect_and_validate_attachments_from_dsr_builder(
         self, data: dict, dsr_builder: "DSRReportBuilder"
@@ -342,17 +351,11 @@ class SmartOpenStreamingStorage:
             else:
                 used_filenames_data.update(filenames)
 
-        processed_attachments_list = process_attachments_contextually(
+        return self._collect_and_validate_attachments(
             data,
             used_filenames_data,
             used_filenames_attachments,
             dsr_builder.processed_attachments,
-            enable_streaming=True,  # Always use streaming mode for storage
-        )
-
-        # Convert to AttachmentProcessingInfo objects using shared utility
-        return convert_processed_attachments_to_attachment_processing_info(
-            processed_attachments_list, self._validate_attachment
         )
 
     @retry_cloud_storage_operation(
@@ -374,7 +377,7 @@ class SmartOpenStreamingStorage:
         """Upload data to cloud storage using smart-open streaming for memory efficiency.
 
         This function leverages smart-open's streaming capabilities while maintaining
-        our DSR-specific business logic for package splitting and attachment processing.
+        our DSR-specific business logic for package and attachment processing.
         All data is streamed directly from source to destination without local storage.
 
         Args:
@@ -627,7 +630,12 @@ class SmartOpenStreamingStorage:
             resp_format: Response format (csv, json)
         """
         # Collect and validate all attachments using shared contextual processing
-        all_attachments = self._collect_and_validate_attachments(data)
+        all_attachments = self._collect_and_validate_attachments(
+            data=data,
+            used_filenames_data=set(),
+            used_filenames_attachments=set(),
+            processed_attachments={},
+        )
 
         if not all_attachments:
             # No attachments, just upload the data

fides/api/service/storage/util.py

@@ -544,31 +544,9 @@ def _process_attachment_list(
     return processed_attachments_list
 
 
-def extract_storage_key_from_attachment(attachment: dict[str, Any]) -> str:
-    """
-    Extract storage key from attachment data with fallback logic.
-
-    This function provides a consistent way to extract storage keys from
-    attachment dictionaries across different components.
-
-    Args:
-        attachment: The attachment dictionary
-
-    Returns:
-        The storage key (URL or filename) for the attachment
-    """
-    if original_url := attachment.get("original_download_url"):
-        return original_url
-
-    if download_url := attachment.get("download_url"):
-        return download_url
-
-    file_name = attachment.get("file_name")
-    return file_name if file_name is not None else ""
-
-
-def resolve_base_path_from_context(
-    attachment: dict[str, Any], default_base_path: str = "attachments"
+def resolve_path_from_context(
+    attachment: dict[str, Any],
+    default_path: str = "attachments",
 ) -> str:
     """
     Resolve the base path for an attachment based on its context.
@@ -578,93 +556,24 @@ def resolve_base_path_from_context(
 
     Args:
         attachment: The attachment dictionary
-        default_base_path: Default base path if no context is found
+        default_path: Default path if no context is found
 
     Returns:
-        The resolved base path for the attachment
+        The resolved path for the attachment
     """
     if not attachment.get("_context"):
-        return default_base_path
+        return default_path
 
     context = attachment["_context"]
     context_type = context.get("type")
 
-    if context_type == "direct":
-        return f"data/{context['dataset']}/{context['collection']}/attachments"
-    if context_type == "nested":
-        return f"data/{context['dataset']}/{context['collection']}/attachments"
+    if context_type in ["direct", "nested"]:
+        dataset = context.get("dataset", "")
+        collection = context.get("collection", "")
+        return f"data/{dataset}/{collection}/attachments"
     if context_type == "top_level":
         return "attachments"
-    # Handle old context format
     if context.get("key") and context.get("item_id"):
         return f"{context['key']}/{context['item_id']}/attachments"
-    # Fallback for unknown context types
-    return "unknown/unknown/attachments"
-
-
-def resolve_directory_from_context(
-    attachment: dict[str, Any], default_directory: str = "attachments"
-) -> str:
-    """
-    Resolve the directory path for an attachment based on its context.
-
-    This function provides consistent directory resolution logic for DSR report builder.
-
-    Args:
-        attachment: The attachment dictionary
-        default_directory: Default directory if no context is found
-
-    Returns:
-        The resolved directory path for the attachment
-    """
-    if not attachment.get("_context"):
-        return default_directory
-
-    context = attachment["_context"]
-    context_type = context.get("type")
-
-    if context_type == "direct":
-        return f"data/{context['dataset']}/{context['collection']}"
-    if context_type == "nested":
-        return f"data/{context['dataset']}/{context['collection']}"
-    if context_type == "top_level":
-        return "attachments"
-    if context.get("key") and context.get("item_id"):
-        return f"{context['key']}/{context['item_id']}"
-
-    return default_directory
-
-
-def convert_processed_attachments_to_attachment_processing_info(
-    processed_attachments_list: list[dict[str, Any]], validate_attachment_func: Callable
-) -> list[Any]:
-    """
-    Convert processed attachments list to AttachmentProcessingInfo objects.
-
-    This is a shared utility function to avoid duplication between different
-    attachment collection methods.
-
-    Args:
-        processed_attachments_list: List of processed attachment dictionaries
-        validate_attachment_func: Function to validate individual attachments
-                                 Signature: validate_attachment_func(attachment_with_context) -> AttachmentProcessingInfo | None
-
-    Returns:
-        List of validated AttachmentProcessingInfo objects
-    """
-    validated_attachments = []
-
-    for processed_attachment in processed_attachments_list:
-        attachment_data = processed_attachment["attachment"]
-
-        # Add context information to the attachment data
-        attachment_with_context = attachment_data.copy()
-        attachment_with_context["_context"] = processed_attachment["context"]
-
-        # Validate and convert to AttachmentProcessingInfo
-        if validate_attachment_func is not None:
-            validated = validate_attachment_func(attachment_with_context)
-            if validated:
-                validated_attachments.append(validated)
 
-    return validated_attachments
+    return default_path

fides/api/task/manual/manual_task_utils.py

@@ -9,14 +9,13 @@ from fides.api.graph.config import (
     GraphDataset,
     ScalarField,
 )
-from fides.api.models.connectionconfig import ConnectionConfig
 
 # Import application models
-from fides.api.models.manual_task import (
-    ManualTask,
-    ManualTaskConditionalDependencyType,
-    ManualTaskConfigurationType,
+from fides.api.models.conditional_dependency.conditional_dependency_base import (
+    ConditionalDependencyType,
 )
+from fides.api.models.connectionconfig import ConnectionConfig
+from fides.api.models.manual_task import ManualTask, ManualTaskConfigurationType
 from fides.api.task.manual.manual_task_address import ManualTaskAddress
 
 PRIVACY_REQUEST_CONFIG_TYPES = {
@@ -135,7 +134,7 @@ def create_collection_for_connection_key(
     conditional_field_addresses: set[str] = {
         dependency.field_address
         for dependency in manual_task.conditional_dependencies
-        if dependency.condition_type == ManualTaskConditionalDependencyType.leaf
+        if dependency.condition_type == ConditionalDependencyType.leaf
         and dependency.field_address is not None
     }