ethyca-fides 2.64.1rc0__py2.py3-none-any.whl → 2.64.2b0__py2.py3-none-any.whl

fides/api/models/manual_tasks/manual_task_log.py

@@ -1,11 +1,12 @@
 from typing import TYPE_CHECKING, Any, Optional
 
-from sqlalchemy import Column, ForeignKey, String
+from sqlalchemy import Column, DateTime, ForeignKey, Index, String
 from sqlalchemy.dialects.postgresql import JSONB
 from sqlalchemy.ext.declarative import declared_attr
 from sqlalchemy.orm import Session, relationship
+from sqlalchemy.sql import func
 
-from fides.api.db.base_class import Base
+from fides.api.db.base_class import Base, FidesBase
 from fides.api.schemas.manual_tasks.manual_task_schemas import ManualTaskLogStatus
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -13,6 +14,9 @@ if TYPE_CHECKING:  # pragma: no cover
     from fides.api.models.manual_tasks.manual_task_config import (
         ManualTaskConfig,  # pragma: no cover
     )
+    from fides.api.models.manual_tasks.manual_task_instance import (  # pragma: no cover
+        ManualTaskInstance,
+    )
 
 
 class ManualTaskLog(Base):
@@ -23,22 +27,56 @@ class ManualTaskLog(Base):
         """Overriding base class method to set the table name."""
         return "manual_task_log"
 
+    # redefined here because there's a minor, unintended discrepancy between
+    # this `id` field and that of the `Base` class, which explicitly sets `index=True`.
+    # TODO: we likely should _not_ be setting `index=True` on the `id`
+    # attribute of the `Base` class, as `primary_key=True` already specifies a
+    # primary key constraint, which will implicitly create an index for the field.
+    id = Column(String(255), primary_key=True, default=FidesBase.generate_uuid)
+    created_at = Column(
+        DateTime(timezone=True), server_default=func.now(), nullable=False
+    )
+    updated_at = Column(
+        DateTime(timezone=True),
+        server_default=func.now(),
+        onupdate=func.now(),
+        nullable=False,
+    )
+
     task_id = Column(
         String, ForeignKey("manual_task.id", ondelete="CASCADE"), nullable=False
     )
-    config_id = Column(String, ForeignKey("manual_task_config.id"), nullable=True)
-    instance_id = Column(String, nullable=True)
+    config_id = Column(
+        String, ForeignKey("manual_task_config.id", ondelete="CASCADE"), nullable=True
+    )
+    instance_id = Column(
+        String,
+        ForeignKey("manual_task_instance.id", ondelete="CASCADE"),
+        nullable=True,
+    )
     status = Column(String, nullable=False)
-    message = Column(String, nullable=False)
+    message = Column(String, nullable=True)
     details = Column(JSONB, nullable=True)
 
-    # Relationships - using string references to avoid circular imports
-    task = relationship("ManualTask", back_populates="logs", foreign_keys=[task_id])
+    __table_args__ = (
+        Index("ix_manual_task_log_config_id", "config_id"),
+        Index("ix_manual_task_log_created_at", "created_at"),
+        Index("ix_manual_task_log_instance_id", "instance_id"),
+        Index("ix_manual_task_log_status", "status"),
+        Index("ix_manual_task_log_task_id", "task_id"),
+    )
+
+    # Relationships
+    task = relationship(
+        "ManualTask", back_populates="logs", foreign_keys=[task_id], viewonly=True
+    )
     config = relationship(
-        "ManualTaskConfig", back_populates="logs", foreign_keys=[config_id]
+        "ManualTaskConfig",
+        back_populates="logs",
+        foreign_keys=[config_id],
+        viewonly=True,
     )
-    # TODO: Add instance relationship when it is implemented
-    # instance = relationship("ManualTaskInstance", back_populates="logs")
+    instance = relationship("ManualTaskInstance", back_populates="logs", viewonly=True)
 
     @classmethod
     def create_log(

fides/api/models/tcf_publisher_restrictions.py

@@ -10,7 +10,7 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.ext.declarative import declared_attr
 from sqlalchemy.orm import Session, relationship
 
-from fides.api.db.base_class import Base
+from fides.api.db.base_class import Base, FidesBase
 
 if TYPE_CHECKING:
     from fides.api.models.privacy_experience import PrivacyExperienceConfig
@@ -83,7 +83,13 @@ class TCFConfiguration(Base):
     def __tablename__(self) -> str:
         return "tcf_configuration"
 
-    name = Column(String, nullable=False, index=True, unique=True)
+    # redefined here because there's a minor, unintended discrepancy between
+    # this `id` field and that of the `Base` class, which explicitly sets `index=True`.
+    # TODO: we likely should _not_ be setting `index=True` on the `id`
+    # attribute of the `Base` class, as `primary_key=True` already specifies a
+    # primary key constraint, which will implicitly create an index for the field.
+    id = Column(String(255), primary_key=True, default=FidesBase.generate_uuid)
+    name = Column(String, nullable=False, unique=True)
 
     privacy_experience_configs = relationship(
         "PrivacyExperienceConfig",
@@ -103,11 +109,17 @@ class TCFPublisherRestriction(Base):
     def __tablename__(self) -> str:
         return "tcf_publisher_restriction"
 
+    # redefined here because there's a minor, unintended discrepancy between
+    # this `id` field and that of the `Base` class, which explicitly sets `index=True`.
+    # TODO: we likely should _not_ be setting `index=True` on the `id`
+    # attribute of the `Base` class, as `primary_key=True` already specifies a
+    # primary key constraint, which will implicitly create an index for the field.
+    id = Column(String(255), primary_key=True, default=FidesBase.generate_uuid)
+
     tcf_configuration_id = Column(
         String(255),
         ForeignKey("tcf_configuration.id", ondelete="CASCADE"),
         nullable=False,
-        index=True,
     )
     purpose_id = Column(Integer, nullable=False)
     restriction_type = Column(EnumColumn(TCFRestrictionType), nullable=False)
@@ -121,7 +133,7 @@ class TCFPublisherRestriction(Base):
     # can be inferred from the presence of the end_vendor_id.
     range_entries = Column(
         ARRAY(JSONB),
-        nullable=True,
+        nullable=False,
         server_default="{}",
         default=list,
     )

fides/api/schemas/manual_tasks/manual_task_schemas.py

@@ -5,6 +5,15 @@ from typing import Annotated, Any, Optional
 from pydantic import ConfigDict, Field
 
 from fides.api.schemas.base_class import FidesSchema
+from fides.api.schemas.manual_tasks.manual_task_status import StatusType
+
+
+class ManualTaskExecutionTiming(str, Enum):
+    """Enum for when a manual task should be executed in the privacy request DAG."""
+
+    pre_execution = "pre_execution"  # Execute before the main DAG
+    post_execution = "post_execution"  # Execute after the main DAG
+    parallel = "parallel"  # Execute in parallel with the main DAG
 
 
 class ManualTaskType(str, Enum):
@@ -23,6 +32,13 @@ class ManualTaskParentEntityType(str, Enum):
     # Add more parent entity types as needed
 
 
+class ManualTaskEntityType(str, Enum):
+    """Enum for manual task entity types."""
+
+    privacy_request = "privacy_request"
+    # Add more entity types as needed
+
+
 class ManualTaskReferenceType(str, Enum):
     """Enum for manual task reference types."""
 
@@ -46,6 +62,32 @@ class ManualTaskLogStatus(str, Enum):
     awaiting_input = "awaiting_input"
 
 
+class ManualTaskResponse(FidesSchema):
+    """Schema for manual task response."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    id: Annotated[str, Field(..., description="Task ID")]
+    parent_entity_id: Annotated[str, Field(..., description="Parent entity ID")]
+    parent_entity_type: Annotated[
+        ManualTaskParentEntityType, Field(..., description="Parent entity type")
+    ]
+    status: Annotated[StatusType, Field(..., description="Task status")]
+    created_at: Annotated[datetime, Field(..., description="Creation timestamp")]
+    updated_at: Annotated[datetime, Field(..., description="Last update timestamp")]
+
+
+class ManualTaskCreate(FidesSchema):
+    """Schema for creating a manual task."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    parent_entity_id: Annotated[str, Field(..., description="Parent entity ID")]
+    parent_entity_type: Annotated[
+        ManualTaskParentEntityType, Field(..., description="Parent entity type")
+    ]
+
+
 class ManualTaskLogCreate(FidesSchema):
     """Schema for creating a manual task log entry."""
 

fides/api/schemas/manual_tasks/manual_task_status.py

@@ -1,6 +1,6 @@
 from datetime import datetime, timezone
 from enum import Enum as EnumType
-from typing import Optional
+from typing import Optional, Protocol
 
 from sqlalchemy.orm import Session
 
@@ -23,61 +23,133 @@ class StatusType(str, EnumType):
 
     @classmethod
     def get_valid_transitions(cls, current_status: "StatusType") -> list["StatusType"]:
-        """Get valid transitions from the current status.
+        """Get valid transitions from the current status."""
+        transitions = {
+            cls.pending: [cls.in_progress, cls.failed, cls.completed],
+            cls.in_progress: [cls.completed, cls.failed],
+            cls.completed: [],
+            cls.failed: [cls.pending, cls.in_progress],
+        }
+        return transitions.get(current_status, [])
+
+
+class StatusTransitionProtocol(Protocol):
+    """Protocol for objects that support status transitions.
+
+    This protocol defines the interface that any object supporting status transitions
+    must implement. It includes both the required attributes and methods.
+
+    Example:
+        ```python
+        # Any class that implements this protocol can be used interchangeably
+        def process_status_update(obj: StatusTransitionProtocol, db: Session) -> None:
+            if obj.is_pending:
+                obj.start_progress(db)
+            elif obj.is_in_progress:
+                obj.mark_completed(db, user_id="user123")
+
+        # This works with ManualTaskInstance or any other class implementing the protocol
+        instance = ManualTaskInstance(...)
+        process_status_update(instance, db)
+        ```
+    """
 
-        Args:
-            current_status: The current status
+    # Required attributes - using runtime types that work with SQLAlchemy
+    status: StatusType
+    completed_at: Optional[datetime]  # Can be None when resetting to pending
+    completed_by_id: Optional[str]  # Can be None when resetting to pending
 
-        Returns:
-            list[StatusType]: List of valid transitions
-        """
-        if current_status == cls.pending:
-            return [cls.in_progress, cls.failed, cls.completed]
-        if current_status == cls.in_progress:
-            return [cls.completed, cls.failed]
-        if current_status == cls.completed:
-            return []
-        if current_status == cls.failed:
-            return [cls.pending, cls.in_progress]
-        return []
+    # Required methods
+    # pylint does not understand the Protocol abstract syntax and will complain about the ellipsis
+    def update_status(
+        self, db: Session, new_status: StatusType, user_id: Optional[str] = None
+    ) -> None:
+        """Update the status with validation and completion handling."""
+        ...  # pylint: disable=unnecessary-ellipsis
+
+    def mark_completed(self, db: Session, user_id: str) -> None:
+        """Mark as completed."""
+        ...  # pylint: disable=unnecessary-ellipsis
+
+    def mark_failed(self, db: Session) -> None:
+        """Mark as failed."""
+        ...  # pylint: disable=unnecessary-ellipsis
+
+    def start_progress(self, db: Session) -> None:
+        """Mark as in progress."""
+        ...  # pylint: disable=unnecessary-ellipsis
+
+    def reset_to_pending(self, db: Session) -> None:
+        """Reset to pending status."""
+        ...  # pylint: disable=unnecessary-ellipsis
+
+    @property
+    def is_completed(self) -> bool:
+        """Check if completed."""
+        ...  # pylint: disable=unnecessary-ellipsis
+
+    @property
+    def is_failed(self) -> bool:
+        """Check if failed."""
+        ...  # pylint: disable=unnecessary-ellipsis
+
+    @property
+    def is_in_progress(self) -> bool:
+        """Check if in progress."""
+        ...  # pylint: disable=unnecessary-ellipsis
+
+    @property
+    def is_pending(self) -> bool:
+        """Check if pending."""
+        ...  # pylint: disable=unnecessary-ellipsis
+
+
+def validate_status_transition_object(obj: StatusTransitionProtocol) -> bool:
+    """Validate that an object properly implements the StatusTransitionProtocol.
+
+    This function demonstrates how the Protocol can be used for runtime validation
+    and type checking.
+    """
+    required_attrs = ["status", "completed_at", "completed_by_id"]
+    required_methods = [
+        "update_status",
+        "mark_completed",
+        "mark_failed",
+        "start_progress",
+        "reset_to_pending",
+    ]
+    required_properties = ["is_completed", "is_failed", "is_in_progress", "is_pending"]
+
+    # Check all required elements
+    all_required = required_attrs + required_methods + required_properties
+    return all(hasattr(obj, attr) for attr in all_required) and all(
+        callable(getattr(obj, method)) for method in required_methods
+    )
 
 
 class StatusTransitionMixin:
     """Mixin for handling status transitions.
 
     This mixin provides methods for managing status transitions and completion tracking.
-    It can be used by any model that needs status management.
+    It implements the StatusTransitionProtocol and can be used by any model that needs status management.
     """
 
-    # These should be overridden by the implementing class
+    # Type annotations to match the Protocol
     status: StatusType
     completed_at: Optional[datetime]
     completed_by_id: Optional[str]
 
     def _get_valid_transitions(self) -> list[StatusType]:
-        """Get valid transitions from the current status.
-
-        Returns:
-            list[StatusType]: List of valid transitions
-        """
+        """Get valid transitions from the current status."""
         return StatusType.get_valid_transitions(self.status)
 
     def _validate_status_transition(self, new_status: StatusType) -> None:
-        """Validate that a status transition is allowed.
-
-        Args:
-            new_status: The new status to transition to
-
-        Raises:
-            StatusTransitionNotAllowed: If the transition is not allowed
-        """
-        # Don't allow transitions to the same status
+        """Validate that a status transition is allowed."""
         if new_status == self.status:
             raise StatusTransitionNotAllowed(
                 f"Invalid status transition: already in status {new_status}"
             )
 
-        # Get valid transitions for current status
         valid_transitions = self._get_valid_transitions()
         if new_status not in valid_transitions:
             raise StatusTransitionNotAllowed(
@@ -88,13 +160,7 @@ class StatusTransitionMixin:
     def update_status(
         self, db: Session, new_status: StatusType, user_id: Optional[str] = None
     ) -> None:
-        """Update the status with validation and completion handling.
-
-        Args:
-            db: Database session
-            new_status: New status to set
-            user_id: Optional user ID who is making the change
-        """
+        """Update the status with validation and completion handling."""
         self._validate_status_transition(new_status)
 
         if new_status == StatusType.completed:
@@ -110,12 +176,7 @@ class StatusTransitionMixin:
         db.commit()
 
     def mark_completed(self, db: Session, user_id: str) -> None:
-        """Mark as completed.
-
-        Args:
-            db: Database session
-            user_id: user ID who completed the task
-        """
+        """Mark as completed."""
         self.update_status(db, StatusType.completed, user_id)
 
     def mark_failed(self, db: Session) -> None:

fides/common/api/v1/urn_registry.py

@@ -155,6 +155,10 @@ AUTHORIZE = "/connection/{connection_key}/authorize"
 ACCESS_MANUAL_WEBHOOKS = "/access_manual_webhook"
 ACCESS_MANUAL_WEBHOOK = CONNECTION_BY_KEY + "/access_manual_webhook"
 
+# Manual Tasks
+MANUAL_TASKS = "/manual-tasks"
+MANUAL_TASK = CONNECTION_BY_KEY + "/manual-task"
+
 # Collection URLs
 DATASETS = "/dataset"
 DATASET_CONFIG = "/datasetconfig"

fides/service/manual_tasks/manual_task_config_service.py

@@ -15,6 +15,14 @@ from fides.api.schemas.manual_tasks.manual_task_config import (
 from fides.service.manual_tasks.utils import validate_fields, with_task_logging
 
 
+class ManualTaskConfigError(Exception):
+    """Exception raised when a manual task config error occurs."""
+
+    def __init__(self, message: str):
+        self.message = message
+        super().__init__(self.message)
+
+
 class ManualTaskConfigService:
     def __init__(self, db: Session):
         self.db = db
@@ -51,8 +59,8 @@ class ManualTaskConfigService:
         """
         try:
             ManualTaskConfigurationType(config_type)
-        except ValueError:
-            raise ValueError(f"Invalid config type: {config_type}")
+        except ManualTaskConfigError:
+            raise ManualTaskConfigError(f"Invalid config type: {config_type}")
 
         # Set all existing versions to non-current
         if is_current:
@@ -96,7 +104,11 @@ class ManualTaskConfigService:
         modified_keys = set(fields_to_remove or [])
 
         if field_updates:
-            validate_fields(field_updates, is_submission=False)
+            try:
+                validate_fields(field_updates, is_submission=False)
+            except ValueError as e:
+                raise ManualTaskConfigError(f"Invalid field updates: {e}") from e
+
             fields_to_create = [
                 {
                     "task_id": config.task_id,
@@ -167,7 +179,7 @@ class ManualTaskConfigService:
         )
 
         if not config:
-            raise ValueError(
+            raise ManualTaskConfigError(
                 f"No current config found for task {task.id} and type {config_type}"
             )
         return config
@@ -355,7 +367,7 @@ class ManualTaskConfigService:
         """
         config = self.db.query(ManualTaskConfig).filter_by(id=config_id).first()
         if not config:
-            raise ValueError(f"Config with ID {config_id} not found")
+            raise ManualTaskConfigError(f"Config with ID {config_id} not found")
 
         log_data = self._create_log_data(
             task.id,