ethyca-fides 2.64.5rc4__py2.py3-none-any.whl → 2.64.6b1__py2.py3-none-any.whl

fides/api/schemas/manual_tasks/manual_task_config.py

@@ -1,311 +0,0 @@
-from datetime import datetime
-from enum import Enum
-from typing import TYPE_CHECKING, Annotated, Literal, Optional, Union
-
-from pydantic import ConfigDict, Field, ValidationInfo, field_validator, model_validator
-
-from fides.api.schemas.base_class import FidesSchema
-
-if TYPE_CHECKING:  # pragma: no cover
-    from fides.api.models.manual_tasks.manual_task import ManualTask  # pragma: no cover
-
-
-class ManualTaskConfigurationType(str, Enum):
-    """Enum for manual task configuration types."""
-
-    access_privacy_request = "access_privacy_request"
-    erasure_privacy_request = "erasure_privacy_request"
-    # Add more configuration types as needed
-
-
-class ManualTaskFieldType(str, Enum):
-    """Enum for manual task field types."""
-
-    text = "text"  # Key-value pairs
-    checkbox = "checkbox"  # Boolean value
-    attachment = "attachment"  # File upload
-    # Add more field types as needed
-
-
-class ManualTaskFieldMetadata(FidesSchema):
-    """Base schema for manual task field metadata."""
-
-    model_config = ConfigDict(extra="allow")
-
-    label: Annotated[str, Field(description="Display label for the field")]
-    required: Annotated[
-        bool, Field(default=False, description="Whether the field is required")
-    ]
-    help_text: Annotated[
-        Optional[str],
-        Field(default=None, description="Help text to display with the field"),
-    ]
-    data_uses: Annotated[
-        Optional[list[str]],
-        Field(
-            default=None,
-            description="List of data uses associated with this field",
-        ),
-    ]
-
-
-class ManualTaskTextFieldMetadata(ManualTaskFieldMetadata):
-    """Schema text field metadata."""
-
-    placeholder: Annotated[
-        Optional[str], Field(default=None, description="Placeholder text for the field")
-    ]
-    default_value: Annotated[
-        Optional[str], Field(default=None, description="Default value for the field")
-    ]
-    max_length: Annotated[
-        Optional[int], Field(default=None, description="Maximum length for text fields")
-    ]
-    min_length: Annotated[
-        Optional[int], Field(default=None, description="Minimum length for text fields")
-    ]
-    pattern: Annotated[
-        Optional[str],
-        Field(
-            default=None,
-            description=(
-                "Regex pattern for validation, for example if the field is an email address, "
-                r"you could use: ^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$"
-            ),
-        ),
-    ]
-
-    @field_validator("min_length", "max_length")
-    @classmethod
-    def validate_lengths(cls, v: Optional[int], info: ValidationInfo) -> Optional[int]:
-        """Validate that min_length is not greater than max_length."""
-        if v is None:
-            return v
-
-        if info.field_name == "min_length":
-            max_length = info.data.get("max_length")
-            if max_length is not None and v > max_length:
-                raise ValueError("min_length cannot be greater than max_length")
-        elif info.field_name == "max_length":
-            min_length = info.data.get("min_length")
-            if min_length is not None and v < min_length:
-                raise ValueError("min_length cannot be greater than max_length")
-
-        return v
-
-
-class ManualTaskCheckboxFieldMetadata(ManualTaskFieldMetadata):
-    """Schema for checkbox field metadata."""
-
-    default_value: Annotated[
-        Optional[bool],
-        Field(default=False, description="Default value for the checkbox"),
-    ]
-    label_true: Annotated[
-        Optional[str], Field(default=None, description="Label for checked state")
-    ]
-    label_false: Annotated[
-        Optional[str], Field(default=None, description="Label for unchecked state")
-    ]
-
-
-class ManualTaskAttachmentFieldMetadata(ManualTaskFieldMetadata):
-    """Schema for attachment field metadata."""
-
-    file_types: Annotated[
-        list[str], Field(description="Allowed file types for upload fields")
-    ]
-    max_file_size: Annotated[
-        int, Field(description="Maximum file size in bytes for upload fields")
-    ]
-    multiple: Annotated[
-        bool, Field(default=False, description="Whether multiple files can be uploaded")
-    ]
-    max_files: Annotated[
-        Optional[int],
-        Field(
-            default=None,
-            description="Maximum number of files allowed when multiple is true",
-        ),
-    ]
-    require_attachment_id: Annotated[
-        bool,
-        Field(
-            default=True,
-            description="Whether an attachment ID is required for this field",
-        ),
-    ]
-    attachment_ids: Annotated[
-        Optional[list[str]],
-        Field(
-            default=None,
-            description="List of attachment IDs associated with this field",
-        ),
-    ]
-
-    @model_validator(mode="after")
-    def validate_multiple_max_files(self) -> "ManualTaskAttachmentFieldMetadata":
-        """Validate that max_files is set when multiple is True."""
-        if self.multiple and self.max_files is None:
-            raise ValueError("max_files must be set when multiple is True")
-        return self
-
-
-class ManualTaskFieldBase(FidesSchema):
-    """Base schema for all field definitions."""
-
-    model_config = ConfigDict(extra="allow")
-
-    field_key: Annotated[
-        str, Field(description="Unique key for the field", min_length=1)
-    ]
-    field_type: Annotated[ManualTaskFieldType, Field(description="Type of the field")]
-    field_metadata: Annotated[
-        ManualTaskFieldMetadata, Field(description="Field metadata and configuration")
-    ]
-
-    @classmethod
-    def get_field_model_for_type(
-        cls, field_type: Union[str, ManualTaskFieldType]
-    ) -> type["ManualTaskFieldBase"]:
-        """Get the appropriate field model class for a given field type.
-
-        Args:
-            field_type: The field type as a string or ManualTaskFieldType enum value
-
-        Returns:
-            The appropriate field model class
-
-        Raises:
-            ValueError: If the field type is not recognized
-        """
-        # Handle non-string/non-enum types
-        if not isinstance(field_type, (str, ManualTaskFieldType)):
-            raise ValueError(
-                f"Invalid field type: expected string or ManualTaskFieldType, got {type(field_type).__name__}"
-            )
-
-        # Convert string to enum if needed
-        if isinstance(field_type, str):
-            try:
-                field_type = ManualTaskFieldType(field_type)
-            except ValueError:
-                raise ValueError(
-                    f"Invalid field type: '{field_type}' is not a valid ManualTaskFieldType"
-                )
-
-        # Map field types to their model classes
-        field_type_to_model = {
-            ManualTaskFieldType.text: ManualTaskTextField,
-            ManualTaskFieldType.checkbox: ManualTaskCheckboxField,
-            ManualTaskFieldType.attachment: ManualTaskAttachmentField,
-        }
-
-        model_class = field_type_to_model.get(field_type)
-        if not model_class:
-            raise ValueError(f"No model class found for field type: {field_type}")
-
-        return model_class
-
-
-class ManualTaskTextField(ManualTaskFieldBase):
-    """Schema for text field definition."""
-
-    field_type: Annotated[
-        Literal[ManualTaskFieldType.text], Field(description="Type of the field")
-    ]
-    field_metadata: Annotated[
-        ManualTaskTextFieldMetadata,
-        Field(description="Field metadata and configuration"),
-    ]
-
-
-class ManualTaskCheckboxField(ManualTaskFieldBase):
-    """Schema for checkbox field definition."""
-
-    field_type: Annotated[
-        Literal[ManualTaskFieldType.checkbox], Field(description="Type of the field")
-    ]
-    field_metadata: Annotated[
-        ManualTaskCheckboxFieldMetadata,
-        Field(description="Field metadata and configuration"),
-    ]
-
-
-class ManualTaskAttachmentField(ManualTaskFieldBase):
-    """Schema for attachment field definition."""
-
-    field_type: Annotated[
-        Literal[ManualTaskFieldType.attachment], Field(description="Type of the field")
-    ]
-    field_metadata: Annotated[
-        ManualTaskAttachmentFieldMetadata,
-        Field(description="Field metadata and configuration"),
-    ]
-
-
-# Type alias for all field types
-ManualTaskField = ManualTaskFieldBase
-
-
-class ManualTaskConfigCreate(FidesSchema):
-    """Schema for creating a manual task configuration."""
-
-    model_config = ConfigDict(extra="forbid")
-
-    task_id: Annotated[
-        str, Field(description="ID of the task this configuration belongs to")
-    ]
-    config_type: Annotated[
-        ManualTaskConfigurationType, Field(description="Type of configuration")
-    ]
-    fields: Annotated[
-        list[ManualTaskFieldBase], Field(description="List of field definitions")
-    ]
-
-
-class ManualTaskConfigResponse(FidesSchema):
-    """Schema for manual task configuration response."""
-
-    model_config = ConfigDict(extra="forbid")
-
-    id: Annotated[str, Field(description="Configuration ID")]
-    task_id: Annotated[str, Field(description="Task ID")]
-    config_type: Annotated[
-        ManualTaskConfigurationType, Field(description="Type of configuration")
-    ]
-    version: Annotated[int, Field(description="Version of the configuration")]
-    is_current: Annotated[
-        bool, Field(description="Whether this is the current version")
-    ]
-    fields: Annotated[
-        list[ManualTaskFieldBase], Field(description="List of field definitions")
-    ]
-    created_at: Annotated[datetime, Field(description="Creation timestamp")]
-    updated_at: Annotated[datetime, Field(description="Last update timestamp")]
-
-
-class ManualTaskConfigUpdate(FidesSchema):
-    """Schema for updating a manual task configuration."""
-
-    model_config = ConfigDict(extra="forbid", arbitrary_types_allowed=True)
-
-    task_id: Annotated[str, Field(description="ID of the task")]
-    config_type: Annotated[
-        ManualTaskConfigurationType, Field(description="Type of configuration")
-    ]
-    fields: Annotated[
-        list[ManualTaskFieldBase], Field(description="List of field definitions")
-    ]
-
-
-class ManualTaskConfigFieldResponse(FidesSchema):
-    """Schema for manual task configuration field response."""
-
-    model_config = ConfigDict(extra="forbid")
-
-    field_key: Annotated[str, Field(description="Unique key for the field")]
-    field_type: Annotated[ManualTaskFieldType, Field(description="Type of the field")]
-    field_metadata: Annotated[
-        ManualTaskFieldMetadata, Field(description="Field metadata and configuration")
-    ]

fides/api/schemas/manual_tasks/manual_task_schemas.py

@@ -1,79 +0,0 @@
-from datetime import datetime
-from enum import Enum
-from typing import Annotated, Any, Optional
-
-from pydantic import ConfigDict, Field
-
-from fides.api.schemas.base_class import FidesSchema
-
-
-class ManualTaskType(str, Enum):
-    """Enum for manual task types."""
-
-    privacy_request = "privacy_request"
-    # Add more task types as needed
-
-
-class ManualTaskParentEntityType(str, Enum):
-    """Enum for manual task parent entity types."""
-
-    connection_config = (
-        "connection_config"  # used for access and erasure privacy requests
-    )
-    # Add more parent entity types as needed
-
-
-class ManualTaskReferenceType(str, Enum):
-    """Enum for manual task reference types."""
-
-    privacy_request = "privacy_request"
-    connection_config = "connection_config"
-    manual_task_config = "manual_task_config"
-    assigned_user = "assigned_user"  # Reference to the user assigned to the task
-    # Add more reference types as needed
-
-
-class ManualTaskLogStatus(str, Enum):
-    """Enum for manual task log status."""
-
-    created = "created"
-    updated = "updated"
-    in_progress = "in_progress"
-    complete = "complete"
-    error = "error"
-    retrying = "retrying"
-    paused = "paused"
-    awaiting_input = "awaiting_input"
-
-
-class ManualTaskLogCreate(FidesSchema):
-    """Schema for creating a manual task log entry."""
-
-    model_config = ConfigDict(extra="forbid")
-
-    task_id: Annotated[str, Field(..., description="ID of the task")]
-    status: Annotated[ManualTaskLogStatus, Field(..., description="Log status")]
-    message: Annotated[Optional[str], Field(None, description="Log message")]
-    details: Annotated[
-        Optional[dict[str, Any]], Field(None, description="Additional details")
-    ]
-    config_id: Annotated[Optional[str], Field(None, description="Configuration ID")]
-    instance_id: Annotated[Optional[str], Field(None, description="Instance ID")]
-
-
-class ManualTaskLogResponse(FidesSchema):
-    """Schema for manual task log response."""
-
-    model_config = ConfigDict(extra="forbid")
-
-    id: Annotated[str, Field(..., description="Log ID")]
-    task_id: Annotated[str, Field(..., description="Task ID")]
-    status: Annotated[ManualTaskLogStatus, Field(..., description="Log status")]
-    message: Annotated[Optional[str], Field(None, description="Log message")]
-    details: Annotated[
-        Optional[dict[str, Any]], Field(None, description="Additional details")
-    ]
-    config_id: Annotated[Optional[str], Field(None, description="Configuration ID")]
-    instance_id: Annotated[Optional[str], Field(None, description="Instance ID")]
-    created_at: Annotated[datetime, Field(..., description="Creation timestamp")]
-    updated_at: Annotated[datetime, Field(..., description="Last update timestamp")]

fides/api/schemas/manual_tasks/manual_task_status.py

@@ -1,151 +0,0 @@
-from datetime import datetime, timezone
-from enum import Enum as EnumType
-from typing import Optional
-
-from sqlalchemy.orm import Session
-
-
-class StatusTransitionNotAllowed(Exception):
-    """Exception raised when a status transition is not allowed."""
-
-    def __init__(self, message: str):
-        self.message = message
-        super().__init__(self.message)
-
-
-class StatusType(str, EnumType):
-    """Enum for manual task status."""
-
-    pending = "pending"
-    in_progress = "in_progress"
-    completed = "completed"
-    failed = "failed"
-
-    @classmethod
-    def get_valid_transitions(cls, current_status: "StatusType") -> list["StatusType"]:
-        """Get valid transitions from the current status.
-
-        Args:
-            current_status: The current status
-
-        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 can be used by any model that needs status management.
-    """
-
-    # 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.
-
-        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.
-
-        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(
-                f"Invalid status transition from {self.status} to {new_status}. "
-                f"Valid transitions are: {valid_transitions}"
-            )
-
-    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
-        """
-        self._validate_status_transition(new_status)
-
-        if new_status == StatusType.completed:
-            self.completed_at = datetime.now(timezone.utc)
-            self.completed_by_id = user_id
-        elif new_status == StatusType.pending:
-            # Reset completion fields if going back to pending
-            self.completed_at = None
-            self.completed_by_id = None
-
-        self.status = new_status
-        db.add(self)
-        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
-        """
-        self.update_status(db, StatusType.completed, user_id)
-
-    def mark_failed(self, db: Session) -> None:
-        """Mark as failed."""
-        self.update_status(db, StatusType.failed)
-
-    def start_progress(self, db: Session) -> None:
-        """Mark as in progress."""
-        self.update_status(db, StatusType.in_progress)
-
-    def reset_to_pending(self, db: Session) -> None:
-        """Reset to pending status."""
-        self.update_status(db, StatusType.pending)
-
-    @property
-    def is_completed(self) -> bool:
-        """Check if completed."""
-        return self.status == StatusType.completed
-
-    @property
-    def is_failed(self) -> bool:
-        """Check if failed."""
-        return self.status == StatusType.failed
-
-    @property
-    def is_in_progress(self) -> bool:
-        """Check if in progress."""
-        return self.status == StatusType.in_progress
-
-    @property
-    def is_pending(self) -> bool:
-        """Check if pending."""
-        return self.status == StatusType.pending