ethyca-fides 2.64.1b2__py2.py3-none-any.whl → 2.64.1rc0__py2.py3-none-any.whl

fides/api/models/manual_tasks/manual_task_log.py

@@ -13,9 +13,6 @@ 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):
@@ -29,29 +26,19 @@ class ManualTaskLog(Base):
     task_id = Column(
         String, ForeignKey("manual_task.id", ondelete="CASCADE"), nullable=False
     )
-    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,
-    )
+    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=False)
     details = Column(JSONB, nullable=True)
 
-    # Relationships
-    task = relationship(
-        "ManualTask", back_populates="logs", foreign_keys=[task_id], viewonly=True
-    )
+    # Relationships - using string references to avoid circular imports
+    task = relationship("ManualTask", back_populates="logs", foreign_keys=[task_id])
     config = relationship(
-        "ManualTaskConfig",
-        back_populates="logs",
-        foreign_keys=[config_id],
-        viewonly=True,
+        "ManualTaskConfig", back_populates="logs", foreign_keys=[config_id]
     )
-    instance = relationship("ManualTaskInstance", back_populates="logs", viewonly=True)
+    # TODO: Add instance relationship when it is implemented
+    # instance = relationship("ManualTaskInstance", back_populates="logs")
 
     @classmethod
     def create_log(

fides/api/schemas/manual_tasks/manual_task_schemas.py

@@ -5,15 +5,6 @@ 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):
@@ -32,13 +23,6 @@ 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."""
 
@@ -62,32 +46,6 @@ 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, Protocol
+from typing import Optional
 
 from sqlalchemy.orm import Session
 
@@ -23,133 +23,61 @@ class StatusType(str, EnumType):
 
     @classmethod
     def get_valid_transitions(cls, current_status: "StatusType") -> list["StatusType"]:
-        """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)
-        ```
-    """
+        """Get valid transitions from 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
+        Args:
+            current_status: The current status
 
-    # 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
-    )
+        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 []
 
 
 class StatusTransitionMixin:
     """Mixin for handling status transitions.
 
     This mixin provides methods for managing status transitions and completion tracking.
-    It implements the StatusTransitionProtocol and can be used by any model that needs status management.
+    It can be used by any model that needs status management.
     """
 
-    # Type annotations to match the Protocol
+    # These should be overridden by the implementing class
     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."""
+        """Get valid transitions from the current status.
+
+        Returns:
+            list[StatusType]: List of valid transitions
+        """
         return StatusType.get_valid_transitions(self.status)
 
     def _validate_status_transition(self, new_status: StatusType) -> None:
-        """Validate that a status transition is allowed."""
+        """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
         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(
@@ -160,7 +88,13 @@ 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."""
+        """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
+        """
         self._validate_status_transition(new_status)
 
         if new_status == StatusType.completed:
@@ -176,7 +110,12 @@ class StatusTransitionMixin:
         db.commit()
 
     def mark_completed(self, db: Session, user_id: str) -> None:
-        """Mark as completed."""
+        """Mark as completed.
+
+        Args:
+            db: Database session
+            user_id: user ID who completed the task
+        """
         self.update_status(db, StatusType.completed, user_id)
 
     def mark_failed(self, db: Session) -> None:

fides/common/api/v1/urn_registry.py

@@ -155,10 +155,6 @@ 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,14 +15,6 @@ 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
@@ -59,8 +51,8 @@ class ManualTaskConfigService:
         """
         try:
             ManualTaskConfigurationType(config_type)
-        except ManualTaskConfigError:
-            raise ManualTaskConfigError(f"Invalid config type: {config_type}")
+        except ValueError:
+            raise ValueError(f"Invalid config type: {config_type}")
 
         # Set all existing versions to non-current
         if is_current:
@@ -104,11 +96,7 @@ class ManualTaskConfigService:
         modified_keys = set(fields_to_remove or [])
 
         if field_updates:
-            try:
-                validate_fields(field_updates, is_submission=False)
-            except ValueError as e:
-                raise ManualTaskConfigError(f"Invalid field updates: {e}") from e
-
+            validate_fields(field_updates, is_submission=False)
             fields_to_create = [
                 {
                     "task_id": config.task_id,
@@ -179,7 +167,7 @@ class ManualTaskConfigService:
         )
 
         if not config:
-            raise ManualTaskConfigError(
+            raise ValueError(
                 f"No current config found for task {task.id} and type {config_type}"
             )
         return config
@@ -367,7 +355,7 @@ class ManualTaskConfigService:
         """
         config = self.db.query(ManualTaskConfig).filter_by(id=config_id).first()
         if not config:
-            raise ManualTaskConfigError(f"Config with ID {config_id} not found")
+            raise ValueError(f"Config with ID {config_id} not found")
 
         log_data = self._create_log_data(
             task.id,

fides/service/manual_tasks/manual_task_service.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Any, Optional, cast
+from typing import Any, Optional, cast
 
 from loguru import logger
 from sqlalchemy import select
@@ -15,31 +15,13 @@ from fides.api.schemas.manual_tasks.manual_task_schemas import (
 from fides.service.manual_tasks.manual_task_config_service import (
     ManualTaskConfigService,
 )
-from fides.service.manual_tasks.manual_task_instance_service import (
-    ManualTaskInstanceService,
-)
 from fides.service.manual_tasks.utils import with_task_logging
 
-if TYPE_CHECKING:
-    from fides.api.models.manual_tasks.manual_task_instance import (
-        ManualTaskInstance,
-        ManualTaskSubmission,
-    )
-
-
-class ManualTaskError(Exception):
-    """Exception raised when a manual task error occurs."""
-
-    def __init__(self, message: str):
-        self.message = message
-        super().__init__(self.message)
-
 
 class ManualTaskService:
     def __init__(self, db: Session):
         self.db = db
         self.config_service = ManualTaskConfigService(db)
-        self.instance_service = ManualTaskInstanceService(db)
 
     def get_task(
         self,
@@ -64,7 +46,7 @@ class ManualTaskService:
         """
         if not any([task_id, parent_entity_id, parent_entity_type, task_type]):
             logger.debug("No filters provided to get_task")
-            raise ManualTaskError("No filters provided to get_task")
+            raise ValueError("No filters provided to get_task")
 
         # Build filter conditions and a human-readable description
         filters = []
@@ -90,7 +72,7 @@ class ManualTaskService:
         task = self.db.execute(stmt).scalar_one_or_none()
         if task is None:
             logger.debug(f"No task found with filters: {filter_desc}")
-            raise ManualTaskError(f"No task found with filters: {filter_desc}")
+            raise ValueError(f"No task found with filters: {filter_desc}")
         return task
 
     @with_task_logging("Provided user IDs verified")
@@ -109,7 +91,7 @@ class ManualTaskService:
             None
         """
         if len(non_existent_user_ids) > 0:
-            raise ManualTaskError(
+            raise ValueError(
                 f"User(s) {sorted(list(non_existent_user_ids))} do not exist"
             )
 
@@ -146,11 +128,11 @@ class ManualTaskService:
             error_key: Key to use for error details
 
         Raises:
-            ManualTaskError: If no successful operations and users don't exist
+            ValueError: If no successful operations and users don't exist
         """
         try:
             self._non_existent_users(non_existent_users, task_id=task_id)
-        except ManualTaskError as e:
+        except ValueError as e:
             details[error_key] = sorted(non_existent_users)
             if success_count == 0:
                 raise e
@@ -190,7 +172,7 @@ class ManualTaskService:
             tuple: (processed_users, log_data)
         """
         if not (user_ids := list(set(user_ids))):
-            raise ManualTaskError(f"User ID is required for {operation_type}ment")
+            raise ValueError(f"User ID is required for {operation_type}ment")
 
         existing_users = set(
             u.id
@@ -206,7 +188,7 @@ class ManualTaskService:
         if non_existing := list(set(user_ids) - existing_users):
             try:
                 self._non_existent_users(non_existing, task_id=task_id)
-            except ManualTaskError as e:
+            except ValueError as e:
                 details[f"user_ids_not_{operation_type}ed"] = sorted(non_existing)
                 if not processed_users:
                     raise e
@@ -299,8 +281,8 @@ class ManualTaskService:
             config: The config to delete
             task_id: The task ID
         Raises:
-            ManualTaskConfigError: If there are active instances using this configuration
-            ManualTaskError: If the task does not exist
+            ValueError: If there are active instances using this configuration
+            ValueError: If the task does not exist
 
         Returns:
             dict[str, Any]: The log details - intercepted by the `with_task_logging` decorator.
@@ -310,41 +292,3 @@ class ManualTaskService:
         # Delete the configuration
         config_id = config.id
         self.config_service.delete_config(task, config_id)
-
-    def create_instance(
-        self, task_id: str, config_id: str, entity_id: str, entity_type: str
-    ) -> "ManualTaskInstance":
-        """Create a new instance for a task.
-
-        Args:
-            task_id: The task ID
-            config_id: The config ID
-            entity_id: The entity ID
-            entity_type: The entity type
-
-        Returns:
-            ManualTaskInstance: The new instance
-        """
-        self.get_task(task_id=task_id)
-        instance = self.instance_service.create_instance(
-            task_id, config_id, entity_id, entity_type
-        )
-        return cast("ManualTaskInstance", instance)
-
-    def create_submission(
-        self, instance_id: str, field_id: str, data: dict[str, Any]
-    ) -> "ManualTaskSubmission":
-        """Create a new submission for a task.
-
-        Args:
-            instance_id: The instance ID
-            field_id: The field ID
-            data: The data for the submission
-
-        Returns:
-            ManualTaskSubmission: The new submission
-        """
-        submission = self.instance_service.create_submission(
-            instance_id, field_id, data
-        )
-        return cast("ManualTaskSubmission", submission)

fides/ui-build/static/admin/404.html

@@ -1 +1 @@
-<!DOCTYPE html><html lang="en"><head><meta charSet="utf-8"/><meta name="viewport" content="width=device-width"/><meta name="next-head-count" content="2"/><link data-next-font="" rel="preconnect" href="/" crossorigin="anonymous"/><link rel="preload" href="/_next/static/css/c693338e3bc8dcc6.css" as="style"/><link rel="stylesheet" href="/_next/static/css/c693338e3bc8dcc6.css" data-n-g=""/><noscript data-n-css=""></noscript><script defer="" nomodule="" src="/_next/static/chunks/polyfills-42372ed130431b0a.js"></script><script src="/_next/static/chunks/webpack-0a61b5bd21a41fe6.js" defer=""></script><script src="/_next/static/chunks/framework-c92fc3344e6fd165.js" defer=""></script><script src="/_next/static/chunks/main-090643377c8254e6.js" defer=""></script><script src="/_next/static/chunks/pages/_app-8ec6e466f3373ac0.js" defer=""></script><script src="/_next/static/chunks/pages/404-ac2f0844e5c4b4cd.js" defer=""></script><script src="/_next/static/xYqpgK9yFhQK_wL_F_kAF/_buildManifest.js" defer=""></script><script src="/_next/static/xYqpgK9yFhQK_wL_F_kAF/_ssgManifest.js" defer=""></script><style>.data-ant-cssinjs-cache-path{content:"";}</style></head><body><div id="__next"><div style="height:100%;display:flex"></div></div><script id="__NEXT_DATA__" type="application/json">{"props":{"pageProps":{}},"page":"/404","query":{},"buildId":"xYqpgK9yFhQK_wL_F_kAF","nextExport":true,"autoExport":true,"isFallback":false,"scriptLoader":[]}</script></body></html>
+<!DOCTYPE html><html lang="en"><head><meta charSet="utf-8"/><meta name="viewport" content="width=device-width"/><meta name="next-head-count" content="2"/><link data-next-font="" rel="preconnect" href="/" crossorigin="anonymous"/><link rel="preload" href="/_next/static/css/c693338e3bc8dcc6.css" as="style"/><link rel="stylesheet" href="/_next/static/css/c693338e3bc8dcc6.css" data-n-g=""/><noscript data-n-css=""></noscript><script defer="" nomodule="" src="/_next/static/chunks/polyfills-42372ed130431b0a.js"></script><script src="/_next/static/chunks/webpack-0a61b5bd21a41fe6.js" defer=""></script><script src="/_next/static/chunks/framework-c92fc3344e6fd165.js" defer=""></script><script src="/_next/static/chunks/main-090643377c8254e6.js" defer=""></script><script src="/_next/static/chunks/pages/_app-8ec6e466f3373ac0.js" defer=""></script><script src="/_next/static/chunks/pages/404-ac2f0844e5c4b4cd.js" defer=""></script><script src="/_next/static/hCJxUAFBWobWrps6RkP0K/_buildManifest.js" defer=""></script><script src="/_next/static/hCJxUAFBWobWrps6RkP0K/_ssgManifest.js" defer=""></script><style>.data-ant-cssinjs-cache-path{content:"";}</style></head><body><div id="__next"><div style="height:100%;display:flex"></div></div><script id="__NEXT_DATA__" type="application/json">{"props":{"pageProps":{}},"page":"/404","query":{},"buildId":"hCJxUAFBWobWrps6RkP0K","nextExport":true,"autoExport":true,"isFallback":false,"scriptLoader":[]}</script></body></html>