ethyca-fides 2.69.3b0__py2.py3-none-any.whl → 2.69.3b2__py2.py3-none-any.whl

fides/api/main.py

@@ -45,6 +45,7 @@ from fides.api.service.privacy_request.email_batch_service import (
     initiate_scheduled_batch_email_send,
 )
 from fides.api.service.privacy_request.request_service import (
+    initiate_async_tasks_status_polling,
     initiate_interrupted_task_requeue_poll,
     initiate_poll_for_exited_privacy_request_tasks,
     initiate_scheduled_dsr_data_removal,
@@ -102,6 +103,7 @@ async def lifespan(wrapped_app: FastAPI) -> AsyncGenerator[None, None]:
     initiate_poll_for_exited_privacy_request_tasks()
     initiate_scheduled_dsr_data_removal()
     initiate_interrupted_task_requeue_poll()
+    initiate_async_tasks_status_polling()
     initiate_bcrypt_migration_task()
     initiate_post_upgrade_index_creation()
 

fides/api/models/asset.py

@@ -29,9 +29,12 @@ class ConsentStatus(str, Enum):
     Consent status of the asset
     """
 
+    cmp_error = "cmp_error"
+    pre_consent = "pre_consent"
     with_consent = "with_consent"
     without_consent = "without_consent"
     exempt = "exempt"
+    not_applicable = "not_applicable"
     unknown = "unknown"
 
 

fides/api/models/detection_discovery/web_monitor.py

@@ -0,0 +1,61 @@
+from typing import Any, Optional
+
+from sqlalchemy import Boolean, Column, String, insert, select
+from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.ext.declarative import declared_attr
+
+from fides.api.db.base_class import Base
+
+
+class WebMonitorGroupJob(Base):
+    """SQL model for storing data returned from a web monitor group job"""
+
+    @declared_attr
+    def __tablename__(self) -> str:
+        return "web_monitor_group_job"
+
+    # The id for the web monitor group on the web monitor service
+    group_id = Column(String, nullable=False, unique=True)
+
+    # The raw experiences data obtained for that group from the web monitor service
+    raw_experiences_data = Column(JSONB, nullable=True)
+    # The processed experiences data, used to calculate an StagedResource's consent status
+    processed_experiences_data = Column(JSONB, nullable=True)
+
+    # Whether this data is from a test_website monitor rather than a real one
+    is_test_run = Column(Boolean, nullable=False, default=False)
+
+    @classmethod
+    async def create_async(
+        cls,
+        async_session: AsyncSession,
+        *,
+        group_id: str,
+        is_test_run: Optional[bool] = False,
+        raw_experiences_data: Optional[dict[str, Any]] = None,
+        processed_experiences_data: Optional[dict[str, Any]] = None,
+    ) -> "WebMonitorGroupJob":
+        """Create a new WebMonitorGroupJob"""
+        values = {
+            "group_id": group_id,
+            "is_test_run": is_test_run,
+            "raw_experiences_data": raw_experiences_data,
+            "processed_experiences_data": processed_experiences_data,
+        }
+        stmt = insert(cls.__table__).values(**values).returning(*cls.__table__.columns)
+        result = await async_session.execute(stmt)
+        row = result.first()
+        return cls(**dict(row))
+
+    @classmethod
+    async def get_by_group_id_async(
+        cls, async_session: AsyncSession, group_id: str
+    ) -> Optional["WebMonitorGroupJob"]:
+        """Get a WebMonitorGroupJob by group_id"""
+        stmt = select(*cls.__table__.columns).where(
+            cls.__table__.c.group_id == group_id
+        )
+        result = await async_session.execute(stmt)
+        row = result.first()
+        return cls(**dict(row)) if row else None

fides/api/models/event_audit.py

@@ -0,0 +1,68 @@
+"""EventAudit model and related enums for comprehensive audit logging."""
+
+from enum import Enum as EnumType
+
+from sqlalchemy import Column, String, Text
+from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy.ext.declarative import declared_attr
+
+from fides.api.db.base_class import Base
+from fides.api.db.util import EnumColumn
+
+
+class EventAuditType(str, EnumType):
+    """Hierarchical event types for audit logging - variable depth as needed."""
+
+    # System
+    system_updated = "system.updated"
+
+    # System group
+    system_group_created = "system_group.created"
+    system_group_updated = "system_group.updated"
+    system_group_deleted = "system_group.deleted"
+
+    # Taxonomy
+    taxonomy_created = "taxonomy.created"
+    taxonomy_updated = "taxonomy.updated"
+    taxonomy_deleted = "taxonomy.deleted"
+    taxonomy_usage_updated = "taxonomy.usage.updated"
+    taxonomy_usage_deleted = "taxonomy.usage.deleted"
+    taxonomy_element_created = "taxonomy.element.created"
+    taxonomy_element_updated = "taxonomy.element.updated"
+    taxonomy_element_deleted = "taxonomy.element.deleted"
+
+
+class EventAuditStatus(str, EnumType):
+    """Status enum for event audit logging."""
+
+    succeeded = "succeeded"
+    failed = "failed"
+
+
+class EventAudit(Base):
+    """Audit log for significant business events across the Fides platform."""
+
+    @declared_attr
+    def __tablename__(cls) -> str:
+        return "event_audit"
+
+    # Uses EventAuditType values but left as String to avoid future migrations
+    event_type = Column(String, index=True, nullable=False)
+    user_id = Column(String, nullable=True, index=True)
+
+    # Resource information
+    resource_type = Column(String, nullable=True, index=True)
+    resource_identifier = Column(String, nullable=True, index=True)
+
+    # User-friendly description of event
+    description = Column(Text, nullable=True)
+
+    # Structured data about event
+    event_details = Column(JSONB, nullable=True)
+
+    # Status of the event
+    status = Column(
+        EnumColumn(EventAuditStatus),
+        index=True,
+        nullable=False,
+    )

fides/api/models/messaging.py

@@ -1,10 +1,11 @@
 from __future__ import annotations
 
+from datetime import datetime
 from typing import Dict, Optional, Type, Union
 
 from loguru import logger
 from pydantic import ValidationError
-from sqlalchemy import Column, Enum, String
+from sqlalchemy import Boolean, Column, DateTime, Enum, String
 from sqlalchemy.dialects.postgresql import JSONB
 from sqlalchemy.ext.mutable import MutableDict
 from sqlalchemy.orm import Session
@@ -18,17 +19,18 @@ from fides.api.db.base_class import Base, JSONTypeOverride
 from fides.api.schemas.messaging.messaging import (
     EMAIL_MESSAGING_SERVICES,
     SMS_MESSAGING_SERVICES,
-    SUPPORTED_MESSAGING_SERVICE_SECRETS,
+    MessagingConnectionTestStatus,
     MessagingMethod,
+    MessagingServiceType,
+)
+from fides.api.schemas.messaging.shared_schemas import (
+    SUPPORTED_MESSAGING_SERVICE_SECRETS,
     MessagingServiceSecretsAWS_SES,
     MessagingServiceSecretsMailchimpTransactional,
     MessagingServiceSecretsMailgun,
     MessagingServiceSecretsTwilioEmail,
     MessagingServiceSecretsTwilioSMS,
-    MessagingServiceType,
-)
-from fides.api.schemas.messaging.messaging_secrets_docs_only import (
-    possible_messaging_secrets,
+    PossibleMessagingSecrets,
 )
 from fides.api.util.logger import Pii
 from fides.config import CONFIG
@@ -48,7 +50,7 @@ def get_messaging_method(
 
 def get_schema_for_secrets(
     service_type: MessagingServiceType,
-    secrets: possible_messaging_secrets,
+    secrets: PossibleMessagingSecrets,
 ) -> SUPPORTED_MESSAGING_SERVICE_SECRETS:
     """
     Returns the secrets that pertain to `service_type` represented as a Pydantic schema
@@ -87,6 +89,8 @@ class MessagingConfig(Base):
         Enum(MessagingServiceType), index=True, unique=True, nullable=False
     )
     details = Column(MutableDict.as_mutable(JSONB), nullable=True)
+    last_test_timestamp = Column(DateTime(timezone=True))
+    last_test_succeeded = Column(Boolean)
     secrets = Column(
         MutableDict.as_mutable(
             StringEncryptedType(
@@ -136,7 +140,7 @@ class MessagingConfig(Base):
         self,
         *,
         db: Session,
-        messaging_secrets: possible_messaging_secrets,
+        messaging_secrets: PossibleMessagingSecrets,
     ) -> None:
         """Creates or updates secrets associated with a config id"""
 
@@ -185,6 +189,18 @@ class MessagingConfig(Base):
                 f"Unknown notification_service_type {active_default_messaging_type} configured"
             )
 
+    def update_test_status(
+        self, test_status: MessagingConnectionTestStatus, db: Session
+    ) -> None:
+        """
+        Updates last_test_timestamp and last_test_succeeded after an attempt to send a test message.
+        """
+        self.last_test_timestamp = datetime.now()
+        self.last_test_succeeded = (
+            test_status == MessagingConnectionTestStatus.succeeded
+        )
+        self.save(db)
+
 
 def default_messaging_config_name(service_type: str) -> str:
     """
@@ -192,7 +208,7 @@ def default_messaging_config_name(service_type: str) -> str:
 
     Returns a name to be used in a default messaging config for the given type.
     """
-    return f"Default Messaging Config [{service_type}]"
+    return MessagingServiceType(service_type).human_readable
 
 
 def default_messaging_config_key(service_type: str) -> str:
@@ -201,4 +217,8 @@ def default_messaging_config_key(service_type: str) -> str:
 
     Returns a key to be used in a default messaging config for the given type.
     """
-    return f"default_messaging_config_{service_type.lower()}"
+    # Historically, when a key was not supplied, the service type string itself
+    # was used as the key (e.g. "mailgun").  Reverting to that behaviour keeps
+    # backward-compatibility with existing tests and API consumers that may rely
+    # on this convention.
+    return service_type.lower()

fides/api/models/sql_models.py

@@ -461,6 +461,14 @@ class System(Base, FidesBase):
         "Asset", back_populates="system", lazy="selectin", uselist=True, viewonly=True
     )
 
+    system_groups = relationship(
+        "SystemGroup",
+        secondary="system_group_member",
+        back_populates="systems",
+        lazy="selectin",
+        viewonly=True,
+    )
+
     @classmethod
     def get_data_uses(
         cls: Type[System], systems: List[System], include_parents: bool = True

fides/api/models/system_group.py

@@ -0,0 +1,85 @@
+from enum import Enum
+
+from citext import CIText
+from sqlalchemy import ARRAY, Column
+from sqlalchemy import Enum as EnumColumn
+from sqlalchemy import ForeignKey, String, UniqueConstraint
+from sqlalchemy.ext.declarative import declared_attr
+from sqlalchemy.orm import relationship
+
+from fides.api.db.base_class import Base
+from fides.api.models.fides_user import FidesUser
+from fides.api.models.sql_models import System  # type: ignore[attr-defined]
+
+
+class CustomTaxonomyColor(str, Enum):
+    WHITE = "taxonomy_white"
+    RED = "taxonomy_red"
+    ORANGE = "taxonomy_orange"
+    YELLOW = "taxonomy_yellow"
+    GREEN = "taxonomy_green"
+    BLUE = "taxonomy_blue"
+    PURPLE = "taxonomy_purple"
+    SANDSTONE = "sandstone"
+    MINOS = "minos"
+
+
+class SystemGroup(Base):
+    @declared_attr
+    def __tablename__(self) -> str:
+        return "system_group"
+
+    fides_key = Column(
+        String,
+        ForeignKey("taxonomy_element.fides_key", ondelete="CASCADE"),
+        nullable=False,
+        unique=True,
+        index=True,
+    )
+    label_color = Column(
+        EnumColumn(CustomTaxonomyColor, values_callable=lambda x: [i.value for i in x]),
+        nullable=True,
+    )
+    data_steward_username = Column(
+        CIText,
+        ForeignKey(FidesUser.username, ondelete="SET NULL"),
+        index=True,
+        nullable=True,
+    )
+    data_uses = Column(
+        ARRAY(String),
+        nullable=False,
+        server_default="{}",
+        default=list,
+    )  # a list of `fides_key`s of `DataUse` records
+    data_steward = relationship(
+        "FidesUser", foreign_keys=[data_steward_username], lazy="selectin"
+    )
+
+    systems = relationship(
+        System,
+        secondary="system_group_member",
+        back_populates="system_groups",
+        viewonly=True,
+    )
+
+
+class SystemGroupMember(Base):
+    @declared_attr
+    def __tablename__(self) -> str:
+        return "system_group_member"
+
+    system_group_id = Column(
+        String(255), ForeignKey("system_group.id", ondelete="CASCADE"), index=True
+    )
+    system_id = Column(
+        String(255), ForeignKey("ctl_systems.id", ondelete="CASCADE"), index=True
+    )
+
+    __table_args__ = (
+        UniqueConstraint(
+            "system_group_id",
+            "system_id",
+            name="uq_system_group_member_group_system",
+        ),
+    )

fides/api/models/taxonomy.py

@@ -85,10 +85,17 @@ class Taxonomy(Base, FidesBase):
             raise ValidationError(
                 f"Cannot create taxonomy '{fides_key}'. This is a taxonomy managed by the system."
             )
-        applies_to = data.pop("applies_to", [])
+        applies_to = data.get("applies_to", [])
+
+        # Create a copy of data without applies_to to avoid modifying the input
+        data_without_applies_to = {
+            key: value for key, value in data.items() if key != "applies_to"
+        }
 
         # Create the taxonomy
-        taxonomy: Taxonomy = super().create(db=db, data=data, check_name=check_name)
+        taxonomy: Taxonomy = super().create(
+            db=db, data=data_without_applies_to, check_name=check_name
+        )
 
         # Reconcile allowed usages if applies_to was provided
         if applies_to:
@@ -98,10 +105,15 @@ class Taxonomy(Base, FidesBase):
 
     def update(self, db: Session, *, data: Dict[str, Any]) -> "Taxonomy":
         """Update a Taxonomy with proper handling of applies_to."""
-        applies_to = data.pop("applies_to", None)
+        applies_to = data.get("applies_to", None)
+
+        # Create a copy of data without applies_to to avoid modifying the input
+        data_without_applies_to = {
+            key: value for key, value in data.items() if key != "applies_to"
+        }
 
         # Update the base fields
-        super().update(db=db, data=data)
+        super().update(db=db, data=data_without_applies_to)
 
         # If applies_to was provided, reconcile allowed usages
         if applies_to is not None:

fides/api/schemas/application_config.py

@@ -53,8 +53,11 @@ class NotificationApplicationConfig(FidesSchema):
 
     @field_validator("notification_service_type", mode="before")
     @classmethod
-    def validate_notification_service_type(cls, value: str) -> Optional[str]:
+    def validate_notification_service_type(cls, value: Optional[str]) -> Optional[str]:
         """Ensure the provided type is a valid value."""
+        if value is None:
+            return None  # Allow None values for disabling messaging
+
         value = value.lower()  # force lowercase for safety
         try:
             MessagingServiceType[value]

fides/api/schemas/messaging/messaging.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from datetime import datetime
 from enum import Enum
 from typing import Any, Dict, List, Optional, Tuple, Type, Union
 
@@ -7,15 +8,14 @@ from fideslang.default_taxonomy import DEFAULT_TAXONOMY
 from fideslang.validation import FidesKey
 from pydantic import BaseModel, ConfigDict, Field, model_validator
 
-from fides.api.custom_types import PhoneNumber, SafeStr
+from fides.api.custom_types import SafeStr
 from fides.api.schemas import Msg
 from fides.api.schemas.api import BulkResponse, BulkUpdateFailed
-from fides.api.schemas.connection_configuration.connection_secrets_base_aws import (
-    BaseAWSSchema,
-)
+from fides.api.schemas.messaging.shared_schemas import PossibleMessagingSecrets
 from fides.api.schemas.privacy_preference import MinimalPrivacyPreferenceHistorySchema
 from fides.api.schemas.privacy_request import Consent
 from fides.api.schemas.property import MinimalProperty
+from fides.api.schemas.redis_cache import IdentityBase
 
 
 class MessagingMethod(Enum):
@@ -44,6 +44,25 @@ class MessagingServiceType(Enum):
                 return member
         return None
 
+    @property
+    def human_readable(self) -> str:
+        """
+        Human-readable mapping for MessagingServiceType
+        """
+        readable_mapping: Dict[str, str] = {
+            MessagingServiceType.mailgun.value: "Mailgun",
+            MessagingServiceType.twilio_text.value: "Twilio SMS",
+            MessagingServiceType.twilio_email.value: "Twilio Email",
+            MessagingServiceType.mailchimp_transactional.value: "Mailchimp Transactional",
+            MessagingServiceType.aws_ses.value: "AWS SES",
+        }
+        try:
+            return readable_mapping[self.value]
+        except KeyError:
+            raise NotImplementedError(
+                "Add new MessagingServiceType to human_readable mapping"
+            )
+
 
 EMAIL_MESSAGING_SERVICES: Tuple[str, ...] = (
     MessagingServiceType.mailgun.value,
@@ -85,6 +104,12 @@ CONFIGURABLE_MESSAGING_ACTION_TYPES: Tuple[str, ...] = (
 )
 
 
+class MessagingTestBodyParams(BaseModel):
+    """Body params required for testing messaging service"""
+
+    to_identity: IdentityBase
+
+
 class ErrorNotificationBodyParams(BaseModel):
     """Body params required for privacy request error notifications."""
 
@@ -339,56 +364,6 @@ class MessagingServiceSecrets(Enum):
     AWS_ASSUME_ROLE_ARN = "aws_assume_role_arn"
 
 
-class MessagingServiceSecretsMailchimpTransactional(BaseModel):
-    """The secrets required to connect to Mailchimp Transactional."""
-
-    mailchimp_transactional_api_key: str
-    model_config = ConfigDict(extra="forbid")
-
-
-class MessagingServiceSecretsMailgun(BaseModel):
-    """The secrets required to connect to Mailgun."""
-
-    mailgun_api_key: str
-    model_config = ConfigDict(extra="forbid")
-
-
-class MessagingServiceSecretsTwilioSMS(BaseModel):
-    """The secrets required to connect to Twilio SMS."""
-
-    twilio_account_sid: str
-    twilio_auth_token: str
-    twilio_messaging_service_sid: Optional[str] = None
-    twilio_sender_phone_number: Optional[PhoneNumber] = None
-    model_config = ConfigDict(extra="forbid")
-
-    @model_validator(mode="before")
-    @classmethod
-    def validate_fields(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        sender_phone = values.get("twilio_sender_phone_number")
-        if not values.get("twilio_messaging_service_sid") and not sender_phone:
-            raise ValueError(
-                "Either the twilio_messaging_service_sid or the twilio_sender_phone_number should be supplied."
-            )
-        return values
-
-
-class MessagingServiceSecretsTwilioEmail(BaseModel):
-    """The secrets required to connect to twilio email."""
-
-    twilio_api_key: str
-    model_config = ConfigDict(extra="forbid")
-
-
-class MessagingServiceSecretsAWS_SES(BaseAWSSchema):
-    """
-    The secrets required to connect to AWS SES.
-    Inherits basic AWS authentication schema.
-    """
-
-    model_config = ConfigDict(extra="forbid")
-
-
 class MessagingConfigBase(BaseModel):
     """Base model shared by messaging config related models"""
 
@@ -453,8 +428,9 @@ class MessagingConfigRequestBase(MessagingConfigBase):
 class MessagingConfigRequest(MessagingConfigRequestBase):
     """Messaging Config Request Schema"""
 
-    name: str
+    name: Optional[str] = None
     key: Optional[FidesKey] = None
+    secrets: Optional[PossibleMessagingSecrets] = None
 
 
 class MessagingConfigResponse(MessagingConfigBase):
@@ -462,16 +438,8 @@ class MessagingConfigResponse(MessagingConfigBase):
 
     name: str
     key: FidesKey
-    model_config = ConfigDict(from_attributes=True, use_enum_values=True)
-
-
-SUPPORTED_MESSAGING_SERVICE_SECRETS = Union[
-    MessagingServiceSecretsMailgun,
-    MessagingServiceSecretsTwilioSMS,
-    MessagingServiceSecretsTwilioEmail,
-    MessagingServiceSecretsMailchimpTransactional,
-    MessagingServiceSecretsAWS_SES,
-]
+    last_test_timestamp: Optional[datetime] = None
+    last_test_succeeded: Optional[bool] = None
 
 
 class MessagingConnectionTestStatus(Enum):
@@ -479,7 +447,6 @@ class MessagingConnectionTestStatus(Enum):
 
     succeeded = "succeeded"
     failed = "failed"
-    skipped = "skipped"
 
 
 class TestMessagingStatusMessage(Msg):

fides/api/schemas/messaging/messaging_secrets_docs_only.py

@@ -1,7 +1,7 @@
 from typing import Union
 
 from fides.api.schemas.base_class import NoValidationSchema
-from fides.api.schemas.messaging.messaging import (
+from fides.api.schemas.messaging.shared_schemas import (
     MessagingServiceSecretsAWS_SES,
     MessagingServiceSecretsMailchimpTransactional,
     MessagingServiceSecretsMailgun,

fides/api/schemas/messaging/shared_schemas.py

@@ -0,0 +1,102 @@
+from typing import Any, Dict, Optional, Union
+
+from pydantic import BaseModel, ConfigDict, model_validator
+
+from fides.api.custom_types import PhoneNumber
+from fides.api.schemas.base_class import NoValidationSchema
+from fides.api.schemas.connection_configuration.connection_secrets_base_aws import (
+    BaseAWSSchema,
+)
+
+
+class MessagingServiceSecretsMailgun(BaseModel):
+    """The secrets required to connect to Mailgun."""
+
+    mailgun_api_key: str
+    model_config = ConfigDict(extra="forbid")
+
+
+class MessagingServiceSecretsTwilioSMS(BaseModel):
+    """The secrets required to connect to Twilio SMS."""
+
+    twilio_account_sid: str
+    twilio_auth_token: str
+    twilio_messaging_service_sid: Optional[str] = None
+    twilio_sender_phone_number: Optional[PhoneNumber] = None
+    model_config = ConfigDict(extra="forbid")
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_fields(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        sender_phone = values.get("twilio_sender_phone_number")
+        if not values.get("twilio_messaging_service_sid") and not sender_phone:
+            raise ValueError(
+                "Either the twilio_messaging_service_sid or the twilio_sender_phone_number should be supplied."
+            )
+        return values
+
+
+class MessagingServiceSecretsTwilioEmail(BaseModel):
+    """The secrets required to connect to twilio email."""
+
+    twilio_api_key: str
+    model_config = ConfigDict(extra="forbid")
+
+
+class MessagingServiceSecretsMailchimpTransactional(BaseModel):
+    """The secrets required to connect to Mailchimp Transactional."""
+
+    mailchimp_transactional_api_key: str
+    model_config = ConfigDict(extra="forbid")
+
+
+class MessagingServiceSecretsMailchimpTransactionalDocs(
+    MessagingServiceSecretsMailchimpTransactional,
+    NoValidationSchema,
+):
+    """The secrets required to connect Mailchimp Transactional, for documentation"""
+
+
+class MessagingSecretsMailgunDocs(MessagingServiceSecretsMailgun, NoValidationSchema):
+    """The secrets required to connect to Mailgun, for documentation"""
+
+
+class MessagingSecretsTwilioSMSDocs(
+    MessagingServiceSecretsTwilioSMS, NoValidationSchema
+):
+    """The secrets required to connect to Twilio sms, for documentation"""
+
+
+class MessagingSecretsTwilioEmailDocs(
+    MessagingServiceSecretsTwilioEmail, NoValidationSchema
+):
+    """The secrets required to connect to Twilio email, for documentation"""
+
+
+class MessagingServiceSecretsAWS_SES(BaseAWSSchema):
+    """The secrets required to connect to AWS SES."""
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class MessagingServiceSecretsAWS_SESDocs(
+    MessagingServiceSecretsAWS_SES, NoValidationSchema
+):
+    """The secrets required to connect to AWS SES, for documentation"""
+
+
+SUPPORTED_MESSAGING_SERVICE_SECRETS = Union[
+    MessagingServiceSecretsMailgun,
+    MessagingServiceSecretsTwilioSMS,
+    MessagingServiceSecretsTwilioEmail,
+    MessagingServiceSecretsMailchimpTransactional,
+    MessagingServiceSecretsAWS_SES,
+]
+
+PossibleMessagingSecrets = Union[
+    MessagingSecretsMailgunDocs,
+    MessagingSecretsTwilioSMSDocs,
+    MessagingSecretsTwilioEmailDocs,
+    MessagingServiceSecretsMailchimpTransactionalDocs,
+    MessagingServiceSecretsAWS_SESDocs,
+]