ethyca-fides 2.63.3b0__py2.py3-none-any.whl → 2.64.0rc0__py2.py3-none-any.whl

fides/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-06-12T18:57:31-0300",
+ "date": "2025-06-18T15:26:50-0400",
  "dirty": false,
  "error": null,
- "full-revisionid": "14baaf4b4e688a68ff32098124e78e6bab89dcb5",
- "version": "2.63.3b0"
+ "full-revisionid": "ea6b775604ef2201b14072255d81f566db14914d",
+ "version": "2.64.0rc0"
 }
 '''  # END VERSION_JSON
 

fides/api/alembic/migrations/versions/ba414a58ba90_create_manual_task_config_tables.py

@@ -0,0 +1,121 @@
+"""create manual task config tables
+
+Revision ID: ba414a58ba90
+Revises: 29e56fa1fdb3
+Create Date: 2025-06-09 19:56:18.254209
+
+"""
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.dialects.postgresql import JSONB
+
+# revision identifiers, used by Alembic.
+revision = "ba414a58ba90"
+down_revision = "29e56fa1fdb3"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # Create manual_task_config table
+    op.create_table(
+        "manual_task_config",
+        sa.Column("id", sa.String(), nullable=False),
+        sa.Column(
+            "created_at",
+            sa.DateTime(timezone=True),
+            nullable=False,
+            server_default=sa.text("now()"),
+        ),
+        sa.Column(
+            "updated_at",
+            sa.DateTime(timezone=True),
+            nullable=False,
+            server_default=sa.text("now()"),
+        ),
+        sa.Column("task_id", sa.String(), nullable=False),
+        sa.Column("config_type", sa.String(), nullable=False),
+        sa.Column("version", sa.Integer(), nullable=False, server_default="1"),
+        sa.Column("is_current", sa.Boolean(), nullable=False, server_default="true"),
+        sa.ForeignKeyConstraint(["task_id"], ["manual_task.id"], ondelete="CASCADE"),
+        sa.PrimaryKeyConstraint("id"),
+    )
+
+    # Create manual_task_config_field table
+    op.create_table(
+        "manual_task_config_field",
+        sa.Column("id", sa.String(), nullable=False),
+        sa.Column(
+            "created_at",
+            sa.DateTime(timezone=True),
+            nullable=False,
+            server_default=sa.text("now()"),
+        ),
+        sa.Column(
+            "updated_at",
+            sa.DateTime(timezone=True),
+            nullable=False,
+            server_default=sa.text("now()"),
+        ),
+        sa.Column("task_id", sa.String(), nullable=False),
+        sa.Column("config_id", sa.String(), nullable=False),
+        sa.Column("field_key", sa.String(), nullable=False),
+        sa.Column("field_type", sa.String(), nullable=False),
+        sa.Column("field_metadata", JSONB, nullable=False, server_default="{}"),
+        sa.ForeignKeyConstraint(["task_id"], ["manual_task.id"], ondelete="CASCADE"),
+        sa.ForeignKeyConstraint(
+            ["config_id"], ["manual_task_config.id"], ondelete="CASCADE"
+        ),
+        sa.PrimaryKeyConstraint("id"),
+        sa.UniqueConstraint(
+            "config_id", "field_key", name="unique_field_key_per_config"
+        ),
+    )
+
+    # Add foreign key constraint to manual_task_log table
+    op.create_foreign_key(
+        "fk_manual_task_log_config_id",
+        "manual_task_log",
+        "manual_task_config",
+        ["config_id"],
+        ["id"],
+        ondelete="SET NULL",
+    )
+
+    # Create indexes
+    op.create_index("ix_manual_task_config_task_id", "manual_task_config", ["task_id"])
+    op.create_index(
+        "ix_manual_task_config_config_type", "manual_task_config", ["config_type"]
+    )
+    op.create_index(
+        "ix_manual_task_config_field_task_id", "manual_task_config_field", ["task_id"]
+    )
+    op.create_index(
+        "ix_manual_task_config_field_config_id",
+        "manual_task_config_field",
+        ["config_id"],
+    )
+    op.create_index(
+        "ix_manual_task_config_field_field_key",
+        "manual_task_config_field",
+        ["field_key"],
+    )
+
+
+def downgrade():
+    # Drop indexes
+    op.drop_index("ix_manual_task_config_field_field_key")
+    op.drop_index("ix_manual_task_config_field_config_id")
+    op.drop_index("ix_manual_task_config_field_task_id")
+    op.drop_index("ix_manual_task_config_config_type")
+    op.drop_index("ix_manual_task_config_task_id")
+
+    # Drop foreign key constraint from manual_task_log
+    op.drop_constraint(
+        "fk_manual_task_log_config_id", "manual_task_log", type_="foreignkey"
+    )
+
+    # Drop tables
+    op.drop_table("manual_task_config_field")
+    op.drop_table("manual_task_config")

fides/api/db/base.py

@@ -32,6 +32,10 @@ from fides.api.models.fides_user_respondent_email_verification import (
 from fides.api.models.identity_salt import IdentitySalt
 from fides.api.models.location_regulation_selections import LocationRegulationSelections
 from fides.api.models.manual_tasks.manual_task import ManualTask, ManualTaskReference
+from fides.api.models.manual_tasks.manual_task_config import (
+    ManualTaskConfig,
+    ManualTaskConfigField,
+)
 from fides.api.models.manual_tasks.manual_task_log import ManualTaskLog
 from fides.api.models.manual_webhook import AccessManualWebhook
 from fides.api.models.messaging import MessagingConfig

fides/api/models/attachment.py

@@ -51,6 +51,7 @@ class AttachmentReferenceType(str, EnumType):
     erasure_manual_webhook = "erasure_manual_webhook"
     privacy_request = "privacy_request"
     comment = "comment"
+    manual_task_submission = "manual_task_submission"
 
 
 class AttachmentReference(Base):

fides/api/models/manual_tasks/__init__.py

@@ -1,8 +1,14 @@
 from fides.api.models.manual_tasks.manual_task import ManualTask, ManualTaskReference
+from fides.api.models.manual_tasks.manual_task_config import (
+    ManualTaskConfig,
+    ManualTaskConfigField,
+)
 from fides.api.models.manual_tasks.manual_task_log import ManualTaskLog
 
 __all__ = [
     "ManualTask",
+    "ManualTaskConfig",
+    "ManualTaskConfigField",
     "ManualTaskReference",
     "ManualTaskLog",
 ]

fides/api/models/manual_tasks/manual_task.py

@@ -1,4 +1,4 @@
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from sqlalchemy import Column, DateTime, ForeignKey, String
 from sqlalchemy.ext.declarative import declared_attr
@@ -14,6 +14,11 @@ from fides.api.schemas.manual_tasks.manual_task_schemas import (
     ManualTaskType,
 )
 
+if TYPE_CHECKING:  # pragma: no cover
+    from fides.api.models.manual_tasks.manual_task_config import (  # pragma: no cover
+        ManualTaskConfig,
+    )
+
 
 class ManualTask(Base):
     """Model for storing manual tasks.
@@ -59,6 +64,11 @@ class ManualTask(Base):
         viewonly=True,
         order_by="ManualTaskLog.created_at",
     )
+    configs = relationship(
+        "ManualTaskConfig",
+        back_populates="task",
+        cascade="all, delete-orphan",
+    )
 
     # Properties
     @property

fides/api/models/manual_tasks/manual_task_config.py

@@ -0,0 +1,136 @@
+from typing import TYPE_CHECKING, Any, Optional
+
+from sqlalchemy import Boolean, Column, ForeignKey, Integer, String
+from sqlalchemy.dialects.postgresql import JSONB
+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.util import EnumColumn
+from fides.api.models.manual_tasks.manual_task_log import ManualTaskLog
+from fides.api.schemas.manual_tasks.manual_task_config import (
+    ManualTaskConfigurationType,
+    ManualTaskFieldMetadata,
+    ManualTaskFieldType,
+)
+from fides.api.schemas.manual_tasks.manual_task_schemas import ManualTaskLogStatus
+
+if TYPE_CHECKING:  # pragma: no cover
+    from fides.api.models.manual_tasks.manual_task import ManualTask  # pragma: no cover
+
+
+class ManualTaskConfig(Base):
+    """Model for storing manual task configurations.
+    A single configuration may have many fields of different types.
+    """
+
+    @declared_attr
+    def __tablename__(cls) -> str:
+        return "manual_task_config"
+
+    task_id = Column(String, ForeignKey("manual_task.id"), nullable=False)
+    config_type = Column(EnumColumn(ManualTaskConfigurationType), nullable=False)
+    version = Column(Integer, nullable=False, default=1)
+    is_current = Column(Boolean, nullable=False, default=True)
+
+    # Relationships
+    task = relationship("ManualTask", back_populates="configs")
+    field_definitions = relationship(
+        "ManualTaskConfigField",
+        back_populates="config",
+        cascade="all, delete-orphan",
+        uselist=True,
+    )
+    logs = relationship(
+        "ManualTaskLog",
+        back_populates="config",
+        primaryjoin="ManualTaskConfig.id == ManualTaskLog.config_id",
+        viewonly=True,
+    )
+
+    @classmethod
+    def create(
+        cls, db: Session, *, data: dict[str, Any], check_name: bool = True
+    ) -> "ManualTaskConfig":
+        """Create a new manual task configuration."""
+        # Validate config_type
+        try:
+            ManualTaskConfigurationType(data["config_type"])
+        except ValueError:
+            raise ValueError(f"Invalid config type: {data['config_type']}")
+
+        config = super().create(db=db, data=data, check_name=check_name)
+
+        # Log the config creation as a task-level log
+        ManualTaskLog.create_log(
+            db=db,
+            task_id=data["task_id"],
+            config_id=config.id,
+            status=ManualTaskLogStatus.created,
+            message=f"Created manual task configuration for {data['config_type']}",
+            details={
+                "config_type": data["config_type"],
+            },
+        )
+        return config
+
+    def get_field(self, field_key: str) -> Optional["ManualTaskConfigField"]:
+        """Get a field by its key."""
+        for field in self.field_definitions:
+            if field.field_key == field_key:
+                return field
+        return None
+
+
+class ManualTaskConfigField(Base):
+    """Model for storing fields associated with each config."""
+
+    @declared_attr
+    def __tablename__(cls) -> str:
+        return "manual_task_config_field"
+
+    task_id = Column(String, ForeignKey("manual_task.id"), nullable=False)
+    config_id = Column(String, ForeignKey("manual_task_config.id"), nullable=False)
+    field_key = Column(String, nullable=False)
+    field_type = Column(
+        EnumColumn(ManualTaskFieldType), nullable=False
+    )  # Using ManualTaskFieldType
+    field_metadata = Column(JSONB, nullable=False, default={})
+
+    # Relationships
+    config = relationship("ManualTaskConfig", back_populates="field_definitions")
+
+    @property
+    def field_metadata_model(self) -> ManualTaskFieldMetadata:
+        """Get the field metadata as a Pydantic model."""
+        return ManualTaskFieldMetadata.model_validate(self.field_metadata)
+
+    @classmethod
+    def create(
+        cls, db: Session, *, data: dict[str, Any], check_name: bool = True
+    ) -> "ManualTaskConfigField":
+        """Create a new manual task config field."""
+        # Get the config to access its task_id and check if it exists
+        try:
+            config = (
+                db.query(ManualTaskConfig)
+                .filter(ManualTaskConfig.id == data["config_id"])
+                .first()
+            )
+            if not config:
+                raise ValueError(f"Config with id {data['config_id']} not found")
+        except Exception as e:
+            raise ValueError(f"Config with id {data['config_id']} not found: {e}")
+
+        # Create the field and let SQLAlchemy complex type validation handled in service.
+        field = super().create(db=db, data=data, check_name=check_name)
+
+        # Create a log entry
+        ManualTaskLog.create_log(
+            db=db,
+            task_id=config.task_id,
+            config_id=data["config_id"],
+            status=ManualTaskLogStatus.created,
+            message=f"Created manual task config field for {data['field_key']}",
+        )
+        return field

fides/api/models/manual_tasks/manual_task_log.py

@@ -8,8 +8,11 @@ from sqlalchemy.orm import Session, relationship
 from fides.api.db.base_class import Base
 from fides.api.schemas.manual_tasks.manual_task_schemas import ManualTaskLogStatus
 
-if TYPE_CHECKING:
-    from fides.api.models.manual_tasks.manual_task import ManualTask
+if TYPE_CHECKING:  # pragma: no cover
+    from fides.api.models.manual_tasks.manual_task import ManualTask  # pragma: no cover
+    from fides.api.models.manual_tasks.manual_task_config import (
+        ManualTaskConfig,  # pragma: no cover
+    )
 
 
 class ManualTaskLog(Base):
@@ -23,28 +26,29 @@ class ManualTaskLog(Base):
     task_id = Column(
         String, ForeignKey("manual_task.id", ondelete="CASCADE"), nullable=False
     )
-    # TODO: Add foreign key constraints when config and instance are implemented
-    config_id = Column(String, nullable=True)
+    config_id = Column(String, ForeignKey("manual_task_config.id"), nullable=True)
     instance_id = Column(String, nullable=True)
     status = Column(String, nullable=False)
-    message = Column(String, nullable=True)
+    message = Column(String, nullable=False)
     details = Column(JSONB, nullable=True)
 
     # Relationships - using string references to avoid circular imports
     task = relationship("ManualTask", back_populates="logs", foreign_keys=[task_id])
-    # TODO: Add config and instance relationships when they are implemented
-    # config = relationship("ManualTaskConfig", back_populates="logs")
+    config = relationship(
+        "ManualTaskConfig", back_populates="logs", foreign_keys=[config_id]
+    )
+    # TODO: Add instance relationship when it is implemented
     # instance = relationship("ManualTaskInstance", back_populates="logs")
 
     @classmethod
     def create_log(
         cls,
         db: Session,
-        status: ManualTaskLogStatus,
         task_id: str,
+        status: ManualTaskLogStatus,
+        message: str,
         config_id: Optional[str] = None,
         instance_id: Optional[str] = None,
-        message: Optional[str] = None,
         details: Optional[dict[str, Any]] = None,
     ) -> "ManualTaskLog":
         """Create a new task log entry.