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

fides/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-06-18T10:17:23-0400",
+ "date": "2025-06-19T09:18:36-0400",
  "dirty": false,
  "error": null,
- "full-revisionid": "21a5a1a7cbc29691214ef6286321eec2cc2a002b",
- "version": "2.63.3rc0"
+ "full-revisionid": "c3bc4b8de4e47f68bc323c928a4a0b1aadf2570f",
+ "version": "2.64.1b0"
 }
 '''  # 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/api/v1/endpoints/connection_endpoints.py

@@ -22,6 +22,7 @@ from fides.api.schemas.connection_configuration import connection_secrets_schema
 from fides.api.schemas.connection_configuration.connection_config import (
     BulkPutConnectionConfiguration,
     ConnectionConfigurationResponse,
+    ConnectionConfigurationResponseWithSystemKey,
     CreateConnectionConfigurationWithSecrets,
 )
 from fides.api.schemas.connection_configuration.connection_secrets import (
@@ -154,13 +155,25 @@ def get_connections(
 @router.get(
     CONNECTION_BY_KEY,
     dependencies=[Security(verify_oauth_client, scopes=[CONNECTION_READ])],
-    response_model=ConnectionConfigurationResponse,
+    response_model=ConnectionConfigurationResponseWithSystemKey,
 )
 def get_connection_detail(
     connection_key: FidesKey, db: Session = Depends(deps.get_db)
-) -> ConnectionConfig:
+) -> ConnectionConfigurationResponseWithSystemKey:
     """Returns connection configuration with matching key."""
-    return get_connection_config_or_error(db, connection_key)
+    connection_config = get_connection_config_or_error(db, connection_key)
+
+    # Convert to Pydantic model with all fields
+    response = ConnectionConfigurationResponseWithSystemKey.model_validate(
+        connection_config
+    )
+
+    # Override just the system_key field to use only the system's fides_key without fallback
+    response.system_key = (
+        connection_config.system.fides_key if connection_config.system else None
+    )
+
+    return response
 
 
 @router.patch(

fides/api/api/v1/endpoints/oauth_endpoints.py

@@ -274,9 +274,15 @@ def oauth_callback(code: str, state: str, db: Session = Depends(get_db)) -> Resp
 
             parsed_url = urlparse(authentication_request.referer)
             base_url = f"{parsed_url.scheme}://{parsed_url.netloc}"
-            system_key = connection_config.system.fides_key
+
+            if connection_config.system is not None:
+                system_key = connection_config.system.fides_key
+                redirect_path = f"/systems/configure/{system_key}"
+            else:
+                redirect_path = f"/integrations/{connection_config.key}"
+
             return RedirectResponse(
-                url=f"{base_url}/systems/configure/{system_key}?status={test_status_value}"
+                url=f"{base_url}{redirect_path}?status={test_status_value}"
             )
         return PlainTextResponse(
             content=f"Connection test status: {test_status_value}. No referer URL available. Please navigate back to the Fides Admin UI.",

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

@@ -1,5 +1,6 @@
 import os
 from enum import Enum as EnumType
+from io import BytesIO
 from typing import IO, TYPE_CHECKING, Any, Tuple
 
 from fideslang.validation import AnyHttpUrlString
@@ -19,7 +20,6 @@ from fides.api.service.storage.s3 import (
     generic_upload_to_s3,
 )
 from fides.api.service.storage.util import AllowedFileType, get_local_filename
-from fides.config import CONFIG
 
 if TYPE_CHECKING:
     from fides.api.models.comment import Comment
@@ -28,6 +28,11 @@ if TYPE_CHECKING:
     from fides.api.models.storage import StorageConfig
 
 
+# This is 7 days in seconds and is currently the max allowed
+# configurable expiration time for presigned URLs for both s3 and gcs.
+MAX_TTL_SECONDS = 604800
+
+
 class AttachmentType(str, EnumType):
     """
     Enum for attachment types. Indicates attachment usage.
@@ -46,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):
@@ -122,6 +128,11 @@ class Attachment(Base):
         """Returns the content type of the attachment."""
         return AllowedFileType[self.file_name.split(".")[-1]].value
 
+    @property
+    def file_key(self) -> str:
+        """Returns the file key of the attachment."""
+        return f"{self.id}/{self.file_name}"
+
     def upload(self, attachment: IO[bytes]) -> None:
         """Uploads an attachment to S3, GCS, or local storage."""
         if self.config.type == StorageType.s3:
@@ -130,7 +141,7 @@ class Attachment(Base):
             generic_upload_to_s3(
                 storage_secrets=self.config.secrets,
                 bucket_name=bucket_name,
-                file_key=f"{self.id}/{self.file_name}",
+                file_key=self.file_key,
                 document=attachment,
                 auth_method=auth_method,
             )
@@ -142,7 +153,7 @@ class Attachment(Base):
             auth_method = self.config.details[StorageDetails.AUTH_METHOD.value]
             storage_client = get_gcs_client(auth_method, self.config.secrets)
             bucket = storage_client.bucket(bucket_name)
-            blob = bucket.blob(f"{self.id}/{self.file_name}")
+            blob = bucket.blob(self.file_key)
 
             # Reset the file pointer to the beginning
             try:
@@ -155,7 +166,7 @@ class Attachment(Base):
             return
 
         if self.config.type == StorageType.local:
-            filename = get_local_filename(f"{self.id}/{self.file_name}")
+            filename = get_local_filename(self.file_key)
 
             # Validate that attachment is a file-like object
             if not hasattr(attachment, "read"):
@@ -205,9 +216,10 @@ class Attachment(Base):
             size, url = generic_retrieve_from_s3(
                 storage_secrets=self.config.secrets,
                 bucket_name=bucket_name,
-                file_key=f"{self.id}/{self.file_name}",
+                file_key=self.file_key,
                 auth_method=auth_method,
                 get_content=False,
+                ttl_seconds=MAX_TTL_SECONDS,
             )
             return size, url
 
@@ -216,19 +228,20 @@ class Attachment(Base):
             auth_method = self.config.details[StorageDetails.AUTH_METHOD.value]
             storage_client = get_gcs_client(auth_method, self.config.secrets)
             bucket = storage_client.bucket(bucket_name)
-            blob = bucket.blob(f"{self.id}/{self.file_name}")
+            blob = bucket.blob(self.file_key)
 
             # Ensure we have the blob metadata
             blob.reload()
+            # Expiration is set to 7 days
             url = blob.generate_signed_url(
                 version="v4",
-                expiration=CONFIG.security.subject_request_download_link_ttl_seconds,
+                expiration=MAX_TTL_SECONDS,
                 method="GET",
             )
             return blob.size, url
 
         if self.config.type == StorageType.local:
-            filename = get_local_filename(f"{self.id}/{self.file_name}")
+            filename = get_local_filename(self.file_key)
             size = os.path.getsize(filename)
             return size, filename
 
@@ -236,7 +249,7 @@ class Attachment(Base):
 
     def retrieve_attachment_content(
         self,
-    ) -> Tuple[int, bytes]:
+    ) -> Tuple[int, IO[bytes]]:
         """
         Retrieves the size of the attachment and its actual content.
         - For s3:
@@ -252,30 +265,33 @@ class Attachment(Base):
         if self.config.type == StorageType.s3:
             bucket_name = f"{self.config.details[StorageDetails.BUCKET.value]}"
             auth_method = self.config.details[StorageDetails.AUTH_METHOD.value]
-            size, content = generic_retrieve_from_s3(
+            size, fileobj = generic_retrieve_from_s3(
                 storage_secrets=self.config.secrets,
                 bucket_name=bucket_name,
-                file_key=f"{self.id}/{self.file_name}",
+                file_key=self.file_key,
                 auth_method=auth_method,
                 get_content=True,
             )
-            return size, content
+            return size, fileobj
 
         if self.config.type == StorageType.gcs:
             bucket_name = f"{self.config.details[StorageDetails.BUCKET.value]}"
             auth_method = self.config.details[StorageDetails.AUTH_METHOD.value]
             storage_client = get_gcs_client(auth_method, self.config.secrets)
             bucket = storage_client.bucket(bucket_name)
-            blob = bucket.blob(f"{self.id}/{self.file_name}")
+            blob = bucket.blob(self.file_key)
 
-            content = blob.download_as_bytes()
-            return len(content), content
+            fileobj = BytesIO()
+            blob.download_to_file(fileobj)
+            fileobj.seek(0)  # Reset pointer to beginning after download
+            return blob.size, fileobj
 
         if self.config.type == StorageType.local:
-            filename = get_local_filename(f"{self.id}/{self.file_name}")
-            with open(filename, "rb") as file:
-                content = file.read()
-                size = len(content)
+            filename = get_local_filename(self.file_key)
+            size = os.path.getsize(filename)
+            with open(filename, "rb") as fileobj:
+                content = BytesIO(fileobj.read())
+                content.seek(0)  # Reset pointer to beginning
                 return size, content
 
         raise ValueError(f"Unsupported storage type: {self.config.type}")
@@ -288,7 +304,7 @@ class Attachment(Base):
             generic_delete_from_s3(
                 storage_secrets=self.config.secrets,
                 bucket_name=bucket_name,
-                file_key=f"{self.id}/{self.file_name}",
+                file_key=self.file_key,
                 auth_method=auth_method,
             )
             return
@@ -307,9 +323,7 @@ class Attachment(Base):
             return
 
         if self.config.type == StorageType.local:
-            folder_path = os.path.dirname(
-                get_local_filename(f"{self.id}/{self.file_name}")
-            )
+            folder_path = os.path.dirname(get_local_filename(self.file_key))
             if os.path.exists(folder_path):
                 import shutil
 

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.

fides/api/schemas/connection_configuration/connection_config.py

@@ -111,10 +111,10 @@ class ConnectionConfigSecretsMixin(BaseModel):
         return self
 
 
-class ConnectionConfigurationResponse(ConnectionConfigSecretsMixin):
+class ConnectionConfigurationResponseBase(ConnectionConfigSecretsMixin):
     """
-    Describes the returned schema for a ConnectionConfiguration.
-
+    Base schema for ConnectionConfiguration responses,
+    excluding fields that might be conditionally omitted.
     The mixin base class ensures that `secrets` sensitive values are masked.
     """
 
@@ -129,10 +129,25 @@ class ConnectionConfigurationResponse(ConnectionConfigSecretsMixin):
     last_test_succeeded: Optional[bool] = None
     authorized: Optional[bool] = False
     enabled_actions: Optional[List[ActionType]] = None
-
     model_config = ConfigDict(from_attributes=True)
 
 
+class ConnectionConfigurationResponseWithSystemKey(ConnectionConfigurationResponseBase):
+    """
+    Describes the full returned schema for a ConnectionConfiguration.
+    """
+
+    # Using this response with models returned from an async DB session will error
+    # because the system_key is lazy loaded. Just a quirk of SQLAlchemy 1.4.
+    system_key: Optional[str] = None
+
+
+class ConnectionConfigurationResponse(ConnectionConfigurationResponseBase):
+    """
+    Describes the returned schema for a ConnectionConfiguration.
+    """
+
+
 class BulkPutConnectionConfiguration(BulkResponse):
     """Schema with mixed success/failure responses for Bulk Create/Update of ConnectionConfiguration responses."""