ethyca-fides 2.59.2b3__py2.py3-none-any.whl → 2.59.2rc0__py2.py3-none-any.whl

{ethyca_fides-2.59.2b3.dist-info → ethyca_fides-2.59.2rc0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.0)
+Generator: setuptools (79.0.0)
 Root-Is-Purelib: true
 Tag: py2-none-any
 Tag: py3-none-any

fides/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-04-18T13:02:59-0700",
+ "date": "2025-04-21T14:22:11-0400",
  "dirty": false,
  "error": null,
- "full-revisionid": "a519c45aafb62a2f424457ed2d702ef4be4af781",
- "version": "2.59.2b3"
+ "full-revisionid": "5349c2139e880663be7de5d9dcc20d58fabb22ce",
+ "version": "2.59.2rc0"
 }
 '''  # END VERSION_JSON
 

fides/api/api/v1/endpoints/storage_endpoints.py

@@ -40,7 +40,6 @@ from fides.api.schemas.storage.storage import (
     FULLY_CONFIGURED_STORAGE_TYPES,
     AWSAuthMethod,
     BulkPutStorageConfigResponse,
-    GCSAuthMethod,
     StorageConfigStatus,
     StorageConfigStatusMessage,
     StorageDestination,
@@ -220,7 +219,7 @@ def put_config_secrets(
 
     msg = f"Secrets updated for StorageConfig with key: {config_key}."
     if verify:
-        status = secrets_are_valid(secrets_schema, storage_config)
+        status = secrets_are_valid(secrets_schema, storage_config.type)
         if status:
             logger.info(
                 "Storage secrets are valid for config with key '{}'", config_key
@@ -419,10 +418,10 @@ def get_storage_status(
 
 
 def _storage_config_requires_secrets(storage_config: StorageConfig) -> bool:
-    return storage_config.details.get(StorageDetails.AUTH_METHOD.value, None) in [
-        AWSAuthMethod.SECRET_KEYS.value,
-        GCSAuthMethod.SERVICE_ACCOUNT_KEYS.value,
-    ]
+    return (
+        storage_config.details.get(StorageDetails.AUTH_METHOD.value, None)
+        == AWSAuthMethod.SECRET_KEYS.value
+    )
 
 
 @router.put(
@@ -534,7 +533,7 @@ def put_default_config_secrets(
 
     msg = f"Secrets updated for default config of storage type: {storage_type.value}."
     if verify:
-        status = secrets_are_valid(secrets_schema, storage_config)
+        status = secrets_are_valid(secrets_schema, storage_config.type)
         if status:
             logger.info(
                 "Storage secrets are valid for default config of storage type '{}'",

fides/api/db/system.py

@@ -8,15 +8,19 @@ from typing import Any, Dict, List, Optional, Tuple, Type, Union
 
 from deepdiff import DeepDiff
 from fastapi import HTTPException
+from fideslang.models import Cookies as CookieSchema
 from fideslang.models import System as SystemSchema
 from fideslang.validation import FidesKey
 from loguru import logger as log
+from sqlalchemy import and_, delete, insert, select, update
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import Session
+from sqlalchemy.sql.elements import BinaryExpression
 from starlette.status import HTTP_400_BAD_REQUEST, HTTP_404_NOT_FOUND
 
 from fides.api.db.crud import create_resource, get_resource, update_resource
 from fides.api.models.sql_models import (  # type: ignore[attr-defined]
+    Cookies,
     DataCategory,
     DataSubject,
     DataUse,
@@ -151,6 +155,7 @@ async def upsert_privacy_declarations(
         for privacy_declaration in resource.privacy_declarations:
             # prepare our 'payload' for either create or update
             data = privacy_declaration.model_dump(mode="json")
+            privacy_declaration_cookies: List[Dict] = data.pop("cookies", None)
             data["system_id"] = system.id  # include FK back to system
 
             # if we find matching declaration, remove it from our map
@@ -163,11 +168,102 @@ async def upsert_privacy_declarations(
                 # otherwise, create a new declaration record
                 declaration = PrivacyDeclaration.create(db, data=data)
 
+            # Upsert cookies for the given privacy declaration
+            await upsert_cookies(
+                db, privacy_declaration_cookies, declaration, system=None
+            )
+
         # delete any existing privacy declarations that have not been "matched" in the request
         for existing_declarations in existing_declarations.values():
             await db.delete(existing_declarations)
 
 
+async def upsert_cookies(
+    async_session: AsyncSession,
+    cookies: Optional[List[Dict]],
+    privacy_declaration: Optional[PrivacyDeclaration],
+    system: Optional[System],
+) -> None:
+    """
+    Upsert cookies for the given system or privacy_declaration.  Cookies can be attached at the system-level
+    or the privacy declaration-level.
+
+    Remove any existing cookies that aren't specified here.
+    """
+    if not (privacy_declaration or system):
+        # Dev-level error
+        raise ValueError(
+            "Either system or privacy declaration must be supplied to upsert cookies"
+        )
+
+    if privacy_declaration and system:
+        # Dev-level error
+        raise ValueError(
+            "Supply either system or privacy declaration, not both, to upsert cookies"
+        )
+
+    parsed_cookies = (
+        [CookieSchema.model_validate(cookie) for cookie in cookies] if cookies else []
+    )
+
+    resource_filter: BinaryExpression = (
+        Cookies.system_id == system.id
+        if system
+        else Cookies.privacy_declaration_id == privacy_declaration.id  # type: ignore[union-attr]
+    )
+
+    for cookie_data in parsed_cookies:
+        # Check if cookie exists on the resource
+        result = await async_session.execute(
+            select(Cookies).where(
+                and_(Cookies.name == cookie_data.name, resource_filter)
+            )
+        )
+        row: Optional[Cookies] = result.scalars().first()
+        if row:
+            # Update existing cookie
+            await async_session.execute(
+                update(Cookies)
+                .where(Cookies.id == row.id)
+                .values(cookie_data.model_dump(mode="json"))
+            )
+
+        else:
+            # Insert new cookie
+            await async_session.execute(
+                insert(Cookies).values(
+                    {
+                        "name": cookie_data.name,
+                        "path": cookie_data.path,
+                        "domain": cookie_data.domain,
+                        "privacy_declaration_id": (
+                            privacy_declaration.id if privacy_declaration else None
+                        ),
+                        "system_id": system.id if system else None,
+                    }
+                )
+            )
+
+    # Select cookies which are currently on the application resource, but not included in the request
+    delete_result = await async_session.execute(
+        select(Cookies).where(
+            and_(
+                Cookies.name.notin_([cookie.name for cookie in parsed_cookies]),
+                resource_filter,
+            )
+        )
+    )
+
+    # Remove those cookies altogether
+    await async_session.execute(
+        delete(Cookies).where(
+            Cookies.id.in_(
+                [cookie.id for cookie in delete_result.scalars().unique().all()]
+            )
+        )
+    )
+
+
 async def update_system(
     resource: SystemSchema, db: AsyncSession, current_user_id: Optional[str] = None
 ) -> Tuple[Dict, bool]:
@@ -192,10 +288,18 @@ async def update_system(
         resource, "privacy_declarations"
     )  # remove the attribute on the system since we've already updated declarations
 
+    # Remove system-level cookies from request before updating the system.
+    # Cookies are upserted separately
+    proposed_system_cookies: Optional[List[Cookies]] = resource.cookies
+    delattr(resource, "cookies")
+
     # perform any updates on the system resource itself
     updated_system = await update_resource(System, resource.model_dump(), db)
 
     async with db.begin():
+        await upsert_cookies(
+            db, proposed_system_cookies, privacy_declaration=None, system=updated_system
+        )  # Upsert the associated cookies at the System-level
 
         await db.refresh(updated_system)
 
@@ -296,6 +400,10 @@ async def create_system(
     # remove the attribute on the system update since the declarations will be created separately
     delattr(resource, "privacy_declarations")
 
+    # Remove system-level cookies from request; these will be processed after the system is added
+    proposed_system_cookies: Optional[List[Cookies]] = resource.cookies
+    delattr(resource, "cookies")
+
     # create the system resource using generic creation
     # the system must be created before the privacy declarations so that it can be referenced
     resource_dict = resource.model_dump()
@@ -310,15 +418,27 @@ async def create_system(
     privacy_declaration_exception = None
     try:
         async with db.begin():
+            await upsert_cookies(
+                db,
+                proposed_system_cookies,
+                privacy_declaration=None,
+                system=created_system,
+            )  # Create the associated cookies at the System-level
 
             # create the specified declarations as records in their own table
             for privacy_declaration in privacy_declarations:
                 data = privacy_declaration.model_dump(mode="json")
                 data["system_id"] = created_system.id  # add FK back to system
+                privacy_declaration_cookies: List[Dict] = data.pop("cookies", [])
                 privacy_declaration = PrivacyDeclaration.create(
                     db, data=data
                 )  # create the associated PrivacyDeclaration
-
+                await upsert_cookies(
+                    db,
+                    privacy_declaration_cookies,
+                    privacy_declaration=privacy_declaration,
+                    system=None,
+                )  # Create the associated cookies on the Privacy Declaration
     except Exception as e:
         log.error(
             f"Error adding privacy declarations, reverting system creation: {str(privacy_declaration_exception)}"

fides/api/models/asset.py

@@ -25,7 +25,8 @@ from fides.api.models.sql_models import System  # type: ignore[attr-defined]
 
 class Asset(Base):
     """
-    Web assets associated with a system
+    Web assets associated with a system. This model will supersede `Cookies` once we have established
+    a migration path and backward compatibility with all `Cookies` related APIs.
     """
 
     # Common attributes

fides/api/models/privacy_notice.py

@@ -20,9 +20,10 @@ from fides.api.models import (
     dry_update_data,
     update_if_modified,
 )
-from fides.api.models.asset import Asset
 from fides.api.models.location_regulation_selections import DeprecatedNoticeRegion
 from fides.api.models.sql_models import (  # type: ignore[attr-defined]
+    Cookies,
+    PrivacyDeclaration,
     System,
     get_system_data_uses,
 )
@@ -190,20 +191,24 @@ class PrivacyNotice(PrivacyNoticeBase, Base):
         raise Exception("Invalid notice consent mechanism.")
 
     @property
-    def cookies(self) -> List[Asset]:
-        """Return relevant assets of type 'cookie' (via the data use)"""
+    def cookies(self) -> List[Cookies]:
+        """Return relevant cookie names (via the data use)"""
         db = Session.object_session(self)
-        or_queries = [
-            f"array_to_string(data_uses, ',') ILIKE '{data_use}%'"
-            for data_use in self.data_uses
-        ]
-
-        query = db.query(Asset).filter(
-            Asset.asset_type == "Cookie",
-            or_(*[text(query) for query in or_queries]),
-        )
-
-        return query.all()
+        return (
+            db.query(Cookies)
+            .join(
+                PrivacyDeclaration,
+                PrivacyDeclaration.id == Cookies.privacy_declaration_id,
+            )
+            .filter(
+                or_(
+                    *[
+                        PrivacyDeclaration.data_use.like(f"{notice_use}%")
+                        for notice_use in self.data_uses
+                    ]
+                )
+            )
+        ).all()
 
     @property
     def calculated_systems_applicable(self) -> bool:

fides/api/models/sql_models.py

@@ -457,6 +457,10 @@ class System(Base, FidesBase):
         lazy="selectin",
     )
 
+    cookies = relationship(
+        "Cookies", back_populates="system", lazy="selectin", uselist=True, viewonly=True
+    )
+
     assets = relationship(
         "Asset", back_populates="system", lazy="selectin", uselist=True, viewonly=True
     )
@@ -556,6 +560,9 @@ class PrivacyDeclaration(Base):
     system = relationship(
         System, back_populates="privacy_declarations", lazy="selectin"
     )
+    cookies = relationship(
+        "Cookies", back_populates="privacy_declaration", lazy="joined", uselist=True
+    )
 
     @classmethod
     def create(
@@ -859,6 +866,50 @@ class AuditLogResource(Base):
     extra_data = Column(JSON, nullable=True)
 
 
+class Cookies(Base):
+    """
+    Stores cookies.  Cookies have a FK to system and privacy declaration. If a privacy declaration is deleted,
+    the cookie can still remain linked to the system but unassociated with a data use.
+    """
+
+    name = Column(String, index=True, nullable=False)
+    path = Column(String)
+    domain = Column(String)
+
+    system_id = Column(
+        String, ForeignKey(System.id_field_path, ondelete="CASCADE"), index=True
+    )  # If system is deleted, remove the associated cookies.
+
+    privacy_declaration_id = Column(
+        String,
+        ForeignKey(PrivacyDeclaration.id_field_path, ondelete="CASCADE"),
+        index=True,
+    )  # If privacy declaration is deleted, remove the associated cookies.
+
+    system = relationship(
+        "System",
+        back_populates="cookies",
+        cascade="all,delete",
+        uselist=False,
+        lazy="selectin",
+    )
+
+    privacy_declaration = relationship(
+        "PrivacyDeclaration",
+        back_populates="cookies",
+        cascade="all,delete",
+        uselist=False,
+        lazy="joined",  # Joined is intentional, instead of selectin
+    )
+
+    __table_args__ = (
+        UniqueConstraint(
+            "name", "privacy_declaration_id", name="_cookie_name_privacy_declaration_uc"
+        ),
+        UniqueConstraint("name", "system_id", name="_cookie_name_system_uc"),
+    )
+
+
 def get_system_data_uses(db: Session, include_parents: bool) -> Set:
     """Get data uses across all systems and those data uses' parents if include_parents is True
 

fides/api/schemas/application_config.py

@@ -14,7 +14,6 @@ class StorageTypeApiAccepted(Enum):
     """Enum for storage destination types accepted in API updates"""
 
     s3 = "s3"
-    gcs = "gcs"
     local = "local"  # local should be used for testing only, not for processing real-world privacy requests
 
 

fides/api/schemas/connection_configuration/connection_secrets_datahub.py

@@ -20,11 +20,11 @@ class PeriodicIntegrationFrequency(Enum):
 
 class DatahubSchema(ConnectionConfigSecretsSchema):
     datahub_server_url: AnyHttpUrlStringRemovesSlash = Field(
-        title="DataHub server URL",
+        title="DataHub Server URL",
         description="The URL of your DataHub server.",
     )
     datahub_token: str = Field(
-        title="DataHub token",
+        title="DataHub Token",
         description="The token used to authenticate with your DataHub server.",
         json_schema_extra={"sensitive": True},
     )
@@ -33,7 +33,7 @@ class DatahubSchema(ConnectionConfigSecretsSchema):
         description="The frequency at which the integration should run. Available options are daily, weekly, and monthly.",
     )
     glossary_node: str = Field(
-        title="Glossary node",
+        title="Glossary Node",
         description="The glossary node name to use on Datahub for Fides Data Categories. (e.g. FidesDataCategories)",
     )
 

fides/api/schemas/connection_configuration/connection_secrets_mysql.py

@@ -1,4 +1,3 @@
-from enum import Enum
 from typing import ClassVar, List, Optional
 
 from pydantic import Field
@@ -9,12 +8,6 @@ from fides.api.schemas.connection_configuration.connection_secrets import (
 )
 
 
-class MySQLSSLMode(str, Enum):
-    preferred = "preferred"
-    required = "required"
-    disabled = "disabled"
-
-
 class MySQLSchema(ConnectionConfigSecretsSchema):
     """Schema to validate the secrets needed to connect to a MySQL Database"""
 
@@ -47,11 +40,6 @@ class MySQLSchema(ConnectionConfigSecretsSchema):
         title="SSH required",
         description="Indicates whether an SSH tunnel is required for the connection. Enable this option if your MySQL server is behind a firewall and requires SSH tunneling for remote connections.",
     )
-    ssl_mode: Optional[MySQLSSLMode] = Field(
-        None,  # TODO: support for verify-ca and verify-full
-        title="SSL Mode",
-        description="The SSL mode to use for the connection. Valid values are 'required', 'preferred', and 'disabled'.",
-    )
 
     _required_components: ClassVar[List[str]] = ["host", "dbname"]
 

fides/api/schemas/connection_configuration/connection_secrets_postgres.py

@@ -46,6 +46,10 @@ class PostgreSQLSchema(ConnectionConfigSecretsSchema):
         title="Schema",
         description="The default schema to be used for the database connection (defaults to public).",
     )
+    ssl_mode: Optional[str] = Field(
+        default=None,
+        title="SSL Mode",
+    )
 
     _required_components: ClassVar[List[str]] = [
         "host",

fides/api/schemas/consentable_item.py

@@ -3,6 +3,7 @@ from typing import Dict, List, Literal, Optional
 from pydantic import BaseModel, Field
 
 from fides.api.models.consent_automation import ConsentableItem as ConsentableItemModel
+from fides.api.models.privacy_notice import UserConsentPreference
 from fides.api.schemas.base_class import FidesSchema
 
 
@@ -84,8 +85,10 @@ class ConsentWebhookResult(BaseModel):
 
     identity_map: Dict[
         Literal["email", "phone_number", "fides_user_device", "external_id"], str
-    ] = Field(default_factory=dict, description="The identity of the user.")
-    notice_id_map: Dict[str, str] = Field(
-        default_factory=dict,
-        description="A map of privacy notice IDs to user consent preferences.",
-    )
+    ] = {}
+    notice_map: Dict[str, UserConsentPreference] = {}
+
+    @property
+    def success(self) -> bool:
+        """Returns true if both the identity map and notice map are not empty."""
+        return bool(self.identity_map) and bool(self.notice_map)

fides/api/schemas/messaging/messaging.py

@@ -286,19 +286,12 @@ class MessagingServiceDetailsTwilioEmail(BaseModel):
 class MessagingServiceDetailsAWS_SES(BaseModel):
     """The details required to represent an AWS SES email configuration."""
 
-    email_from: Optional[str] = None
-    domain: Optional[str] = None
+    email_from: str
+    domain: str
     aws_region: str
 
     model_config = ConfigDict(extra="forbid")
 
-    @model_validator(mode="before")
-    @classmethod
-    def validate_fields(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        if not values.get("domain") and not values.get("email_from"):
-            raise ValueError("Either 'email_from' or 'domain' must be provided.")
-        return values
-
 
 class MessagingServiceSecrets(Enum):
     """Enum for message service secrets"""

fides/api/schemas/storage/storage.py

@@ -61,20 +61,6 @@ class StorageDetailsS3(FileBasedStorageDetails):
     model_config = ConfigDict(use_enum_values=True)
 
 
-class GCSAuthMethod(str, Enum):
-    ADC = "adc"  # Application Default Credentials
-    SERVICE_ACCOUNT_KEYS = "service_account_keys"
-
-
-class StorageDetailsGCS(FileBasedStorageDetails):
-    """The details required to represent a Google Cloud Storage bucket."""
-
-    auth_method: GCSAuthMethod
-    bucket: str
-    max_retries: Optional[int] = 0
-    model_config = ConfigDict(use_enum_values=True)
-
-
 class StorageDetailsLocal(FileBasedStorageDetails):
     """The details required to configurate local storage configuration"""
 
@@ -85,8 +71,6 @@ class StorageSecrets(Enum):
     # s3-specific
     AWS_ACCESS_KEY_ID = "aws_access_key_id"
     AWS_SECRET_ACCESS_KEY = "aws_secret_access_key"
-    REGION_NAME = "region_name"
-    AWS_ASSUME_ROLE = "assume_role_arn"
 
 
 class StorageSecretsLocal(BaseModel):
@@ -96,27 +80,10 @@ class StorageSecretsLocal(BaseModel):
 
 
 class StorageSecretsS3(BaseModel):
-    aws_access_key_id: Optional[str] = None
-    aws_secret_access_key: Optional[str] = None
-    region_name: Optional[str] = None
-    assume_role_arn: Optional[str] = None
-    model_config = ConfigDict(extra="forbid")
-
+    """The secrets required to connect to an S3 bucket."""
 
-class StorageSecretsGCS(BaseModel):
-    """The secrets required to connect to a Google Cloud Storage bucket."""
-
-    type: str = "service_account"
-    project_id: str
-    private_key_id: str
-    private_key: str
-    client_email: str
-    client_id: str
-    auth_uri: str
-    token_uri: str
-    auth_provider_x509_cert_url: str
-    client_x509_cert_url: str
-    universe_domain: str
+    aws_access_key_id: str
+    aws_secret_access_key: str
     model_config = ConfigDict(extra="forbid")
 
 
@@ -132,7 +99,6 @@ class StorageType(Enum):
 
 FULLY_CONFIGURED_STORAGE_TYPES = (
     StorageType.s3,
-    StorageType.gcs,
 )  # storage types that are considered "fully configured"
 
 
@@ -142,7 +108,6 @@ class StorageDestinationBase(BaseModel):
     type: StorageType
     details: Union[
         StorageDetailsS3,
-        StorageDetailsGCS,
         StorageDetailsLocal,
     ] = Field(validate_default=True)
     format: Optional[ResponseFormat] = ResponseFormat.json.value  # type: ignore
@@ -180,7 +145,6 @@ class StorageDestinationBase(BaseModel):
         try:
             schema = {
                 StorageType.s3.value: StorageDetailsS3,
-                StorageType.gcs.value: StorageDetailsGCS,
                 StorageType.local.value: StorageDetailsLocal,
             }[storage_type]
         except KeyError:
@@ -245,7 +209,7 @@ class BulkPutStorageConfigResponse(BulkResponse):
     failed: List[BulkUpdateFailed] = []
 
 
-SUPPORTED_STORAGE_SECRETS = Union[StorageSecretsS3, StorageSecretsGCS]
+SUPPORTED_STORAGE_SECRETS = StorageSecretsS3
 
 
 class StorageConfigStatus(Enum):

fides/api/schemas/storage/storage_secrets_docs_only.py

@@ -1,15 +1,9 @@
-from typing import Union
-
 from fides.api.schemas.base_class import NoValidationSchema
-from fides.api.schemas.storage.storage import StorageSecretsGCS, StorageSecretsS3
+from fides.api.schemas.storage.storage import StorageSecretsS3
 
 
 class StorageSecretsS3Docs(StorageSecretsS3, NoValidationSchema):
     """The secrets required to connect to S3, for documentation"""
 
 
-class StorageSecretsGCSDocs(StorageSecretsGCS, NoValidationSchema):
-    """The secrets required to connect to Google Cloud Storage, for documentation"""
-
-
-possible_storage_secrets = Union[StorageSecretsS3Docs, StorageSecretsGCSDocs]
+possible_storage_secrets = StorageSecretsS3Docs

fides/api/schemas/system.py

@@ -1,7 +1,7 @@
 from datetime import datetime
 from typing import Any, Dict, List, Optional, Sequence
 
-from fideslang.models import PrivacyDeclaration, System
+from fideslang.models import Cookies, PrivacyDeclaration, System
 from pydantic import ConfigDict, Field
 from pydantic.main import BaseModel
 
@@ -17,6 +17,7 @@ class PrivacyDeclarationResponse(PrivacyDeclaration):
     id: str = Field(
         description="The database-assigned ID of the privacy declaration on the system. This is meant to be a read-only field, returned only in API responses"
     )
+    cookies: Optional[List[Cookies]] = []
 
 
 class BasicSystemResponse(System):

fides/api/service/connectors/mysql_connector.py

@@ -1,11 +1,10 @@
-from typing import Dict, List
+from typing import List
 
 from sqlalchemy.engine import Engine, LegacyCursorResult, create_engine  # type: ignore
 
 from fides.api.graph.execution import ExecutionNode
 from fides.api.schemas.connection_configuration.connection_secrets_mysql import (
     MySQLSchema,
-    MySQLSSLMode,
 )
 from fides.api.service.connectors.query_configs.mysql_query_config import (
     MySQLQueryConfig,
@@ -70,27 +69,16 @@ class MySQLConnector(SQLConnector):
             uri = self.build_ssh_uri(local_address=self.ssh_server.local_bind_address)
         else:
             uri = (self.configuration.secrets or {}).get("url") or self.build_uri()
-        connect_args = self.get_connect_args()
         return create_engine(
             uri,
             hide_parameters=self.hide_parameters,
             echo=not self.hide_parameters,
-            connect_args=connect_args,
         )
 
     def query_config(self, node: ExecutionNode) -> SQLQueryConfig:
         """Query wrapper corresponding to the input execution_node."""
         return MySQLQueryConfig(node)
 
-    def get_connect_args(self) -> Dict[str, Dict[str, MySQLSSLMode]]:
-        """Get connection arguments for the engine"""
-        ssl_mode = self.configuration.secrets.get("ssl_mode", MySQLSSLMode.preferred)
-        return {
-            "ssl": {
-                "mode": ssl_mode,
-            }
-        }
-
     @staticmethod
     def cursor_result_to_rows(results: LegacyCursorResult) -> List[Row]:
         """