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

fides/api/schemas/manual_tasks/manual_task_config.py

@@ -0,0 +1,311 @@
+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

@@ -38,7 +38,7 @@ class ManualTaskLogStatus(str, Enum):
 
     created = "created"
     updated = "updated"
-    in_processing = "in_processing"
+    in_progress = "in_progress"
     complete = "complete"
     error = "error"
     retrying = "retrying"

fides/api/schemas/manual_tasks/manual_task_status.py

@@ -32,7 +32,7 @@ class StatusType(str, EnumType):
             list[StatusType]: List of valid transitions
         """
         if current_status == cls.pending:
-            return [cls.in_progress, cls.failed]
+            return [cls.in_progress, cls.failed, cls.completed]
         if current_status == cls.in_progress:
             return [cls.completed, cls.failed]
         if current_status == cls.completed:

fides/api/schemas/privacy_request.py

@@ -77,6 +77,7 @@ class PrivacyRequestSource(str, EnumType):
     - Consent Webhook: Request created as a side-effect of a consent webhook request (bidirectional consent)
     - Fides.js: Request created as a side-effect of a privacy preference update from Fides.js
     - Dataset Test: Standalone dataset test
+    - Janus SDK: Request created from the Mobile SDK
     """
 
     privacy_center = "Privacy Center"
@@ -84,6 +85,7 @@ class PrivacyRequestSource(str, EnumType):
     consent_webhook = "Consent Webhook"
     fides_js = "Fides.js"
     dataset_test = "Dataset Test"
+    janus_sdk = "Janus SDK"
 
 
 class PrivacyRequestCreate(FidesSchema):

fides/api/util/cache.py

@@ -174,6 +174,7 @@ def _determine_redis_db_index(
        - If *not* running under xdist, always use DB 1.
 
     2. Non-test mode: return the value already present in `CONFIG.redis.db_index`
+    (or CONFIG.redis.read_only_db_index` if read_only is True)
     """
 
     # 1. Test mode logic
@@ -261,18 +262,20 @@ def get_read_only_cache() -> FidesopsRedis:
             ssl_ca_certs=CONFIG.redis.read_only_ssl_ca_certs,
             ssl_cert_reqs=CONFIG.redis.read_only_ssl_cert_reqs,
         )
-        logger.debug("New read-only Redis connection created.")
 
     try:
+        # Test the connection by attempting to ping the Redis server
         connected = _read_only_connection.ping()
-        logger.debug("Read-only Redis connection succeeded.")
-    except ConnectionErrorFromRedis:
+        logger.debug("Read-only Redis connection established successfully.")
+    except Exception as e:
+        logger.error(f"Failed to connect to read-only Redis: {e}")
         connected = False
 
     if not connected:
         logger.error(
             "Unable to establish read-only Redis connection. Returning writeable cache connection instead."
         )
+        # If we can't connect to the read-only cache, fall back to the regular cache
         return get_cache()
 
     return _read_only_connection

fides/config/redis_settings.py

@@ -77,35 +77,99 @@ class RedisSettings(FidesSettings):
         default="",
         description="The network address for the read-only Redis cache.",
     )
-    read_only_port: int = Field(
-        default=6379,
-        description="The port at which the read-only Redis cache will be accessible.",
+    # Read-only Redis settings with automatic fallback behavior
+    # Field validators will populate these fields with the corresponding writer settings if not provided
+    # The order here is important, these must be defined after the writer settings
+    read_only_port: int = Field(  # type: ignore[assignment]
+        default=None,
+        description="The port at which the read-only Redis cache will be accessible. If not provided, the `port` setting will be used.",
     )
-    read_only_user: str = Field(
-        default="",
-        description="The user with which to login to the read-only Redis cache.",
+    read_only_user: str = Field(  # type: ignore[assignment]
+        default=None,
+        description="The user with which to login to the read-only Redis cache. If not provided, the `user` setting will be used.",
     )
-    read_only_password: str = Field(
-        default="",
-        description="The password with which to login to the read-only Redis cache.",
+    read_only_password: str = Field(  # type: ignore[assignment]
+        default=None,
+        description="The password with which to login to the read-only Redis cache. If not provided, the `password` setting will be used.",
     )
-    read_only_db_index: int = Field(
-        default=0,
-        description="The application will use this index in the read-only Redis cache to cache data.",
+    read_only_db_index: int = Field(  # type: ignore[assignment]
+        default=None,
+        description="The application will use this index in the read-only Redis cache to cache data. If not provided, the `db_index` setting will be used.",
     )
-    read_only_ssl: bool = Field(
-        default=False,
-        description="Whether the application's connections to the read-only cache should be encrypted using TLS.",
+    read_only_ssl: bool = Field(  # type: ignore[assignment]
+        default=None,
+        description="Whether the application's connections to the read-only cache should be encrypted using TLS. If not provided, the `ssl` setting will be used.",
     )
     read_only_ssl_cert_reqs: Optional[str] = Field(
-        default="required",
-        description="If using TLS encryption, set this to 'required' if you wish to enforce the read-only Redis cache to provide a certificate. Note that not all cache providers support this without setting ssl_ca_certs (e.g. AWS Elasticache).",
+        default=None,
+        description="If using TLS encryption, set this to 'required' if you wish to enforce the read-only Redis cache to provide a certificate. Note that not all cache providers support this without setting ssl_ca_certs (e.g. AWS Elasticache). If not provided, the `ssl_cert_reqs` setting will be used.",
     )
-    read_only_ssl_ca_certs: str = Field(
-        default="",
-        description="If using TLS encryption rooted with a custom Certificate Authority, set this to the path of the CA certificate.",
+    read_only_ssl_ca_certs: str = Field(  # type: ignore[assignment]
+        default=None,
+        description="If using TLS encryption rooted with a custom Certificate Authority, set this to the path of the CA certificate. If not provided, the `ssl_ca_certs` setting will be used.",
     )
 
+    # Field validators for automatic fallback behavior
+    @field_validator("read_only_port", mode="before")
+    @classmethod
+    def resolve_read_only_port(cls, v: Optional[int], info: ValidationInfo) -> int:
+        """Resolves the read-only port setting by falling back to the `port` value if no `read_only_port` is specified."""
+        if v is None:
+            return info.data["port"]
+        return v
+
+    @field_validator("read_only_user", mode="before")
+    @classmethod
+    def resolve_read_only_user(cls, v: Optional[str], info: ValidationInfo) -> str:
+        """Resolves the read-only user setting by falling back to the `user` value if no `read_only_user` is specified."""
+        if v is None:
+            return info.data["user"]
+        return v
+
+    @field_validator("read_only_password", mode="before")
+    @classmethod
+    def resolve_read_only_password(cls, v: Optional[str], info: ValidationInfo) -> str:
+        """Resolves the read-only password setting by falling back to the `password` value if no `read_only_password` is specified."""
+        if v is None:
+            return info.data["password"]
+        return v
+
+    @field_validator("read_only_db_index", mode="before")
+    @classmethod
+    def resolve_read_only_db_index(cls, v: Optional[int], info: ValidationInfo) -> int:
+        """Resolves the read-only db_index setting by falling back to the `db_index` value if no `read_only_db_index` is specified."""
+        if v is None:
+            return info.data["db_index"]
+        return v
+
+    @field_validator("read_only_ssl", mode="before")
+    @classmethod
+    def resolve_read_only_ssl(cls, v: Optional[bool], info: ValidationInfo) -> bool:
+        """Resolves the read-only ssl setting by falling back to the `ssl` value if no `read_only_ssl` is specified."""
+        if v is None:
+            return info.data["ssl"]
+        return v
+
+    @field_validator("read_only_ssl_cert_reqs", mode="before")
+    @classmethod
+    def resolve_read_only_ssl_cert_reqs(
+        cls, v: Optional[str], info: ValidationInfo
+    ) -> Optional[str]:
+        """Resolves the read-only ssl_cert_reqs setting by falling back to the `ssl_cert_reqs` value if no `read_only_ssl_cert_reqs` is specified."""
+        if v is None:
+            return info.data["ssl_cert_reqs"]
+        return v
+
+    @field_validator("read_only_ssl_ca_certs", mode="before")
+    @classmethod
+    def resolve_read_only_ssl_ca_certs(
+        cls, v: Optional[str], info: ValidationInfo
+    ) -> str:
+        """Resolves the read-only ssl_ca_certs setting by falling back to the `ssl_ca_certs` value if no `read_only_ssl_ca_certs` is specified."""
+        if v is None:
+            return info.data["ssl_ca_certs"]
+        return v
+
     # This relies on other values to get built so must be last
     connection_url: Optional[str] = Field(
         default=None,
@@ -130,49 +194,48 @@ class RedisSettings(FidesSettings):
             # If the whole URL is provided via the config, preference that
             return v
 
+        # Determine which set of settings to use based on field name
         is_read_only = info.field_name == "read_only_connection_url"
 
-        connection_protocol = "redis"
-        params_str = ""
-        use_tls = (
-            info.data.get("read_only_ssl")
-            if is_read_only
-            else info.data.get("ssl", False)
-        )
-
-        # These vars are intentionally fetched with `or ""` as the default to account
-        # for the edge case where `None` is explicitly set in `values` by Pydantic because
-        # it is not overridden by the config file or an env var
+        # Extract settings - fallbacks already resolved by field validators for read-only fields
         user = (
-            info.data.get("read_only_user", "")
-            if is_read_only
-            else info.data.get("user", "")
+            info.data["read_only_user"] if is_read_only else info.data.get("user", "")
         )
         password = (
-            info.data.get("read_only_password", "")
+            info.data["read_only_password"]
             if is_read_only
             else info.data.get("password", "")
         )
+
         db_index = (
-            info.data.get("read_only_db_index", "")
+            info.data["read_only_db_index"]
             if is_read_only
             else info.data.get("db_index", "")
         )
+        use_tls = (
+            info.data["read_only_ssl"] if is_read_only else info.data.get("ssl", False)
+        )
+
+        connection_protocol = "redis"
+        params_str = ""
+
         if use_tls:
             # If using TLS update the connection URL format
             connection_protocol = "rediss"
-            cert_reqs = (
+
+            ssl_cert_reqs = (
                 info.data.get("read_only_ssl_cert_reqs", "none")
                 if is_read_only
                 else info.data.get("ssl_cert_reqs", "none")
             )
-            params = {"ssl_cert_reqs": quote_plus(cert_reqs)}
-
             ssl_ca_certs = (
-                info.data.get("read_only_ssl_ca_certs", "")
+                info.data["read_only_ssl_ca_certs"]
                 if is_read_only
                 else info.data.get("ssl_ca_certs", "")
             )
+
+            # Build SSL parameters
+            params = {"ssl_cert_reqs": quote_plus(ssl_cert_reqs or "none")}
             if ssl_ca_certs:
                 params["ssl_ca_certs"] = quote(ssl_ca_certs, safe="/")
             params_str = "?" + urlencode(params, quote_via=quote, safe="/")
@@ -183,17 +246,15 @@ class RedisSettings(FidesSettings):
         if password or user:
             auth_prefix = f"{quote_plus(user)}:{quote_plus(password)}@"
 
+        # For host, we don't have a fallback - read replica should be a different host
         host = (
             info.data.get("read_only_host", "")
             if is_read_only
             else info.data.get("host", "")
         )
         port = (
-            info.data.get("read_only_port", "")
-            if is_read_only
-            else info.data.get("port", "")
+            info.data["read_only_port"] if is_read_only else info.data.get("port", "")
         )
-
         # Only include database index in URL if it's not the default (0)
         db_path = f"{db_index}" if db_index != 0 else ""