ethyca-fides 2.57.1b8__py2.py3-none-any.whl → 2.57.1rc0__py2.py3-none-any.whl

fides/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-03-24T16:32:51-0600",
+ "date": "2025-03-25T12:32:49-0300",
  "dirty": false,
  "error": null,
- "full-revisionid": "c371f453f33d1af4a35dfe6ae1d78c16b72576d8",
- "version": "2.57.1b8"
+ "full-revisionid": "e52bec9197d4b3ac45f875238ec25f7af6cf5db7",
+ "version": "2.57.1rc0"
 }
 '''  # END VERSION_JSON
 

fides/api/api/v1/endpoints/config_endpoints.py

@@ -58,10 +58,8 @@ def patch_settings(
     Only keys provided will be updated, others will be unaffected,
     i.e. true PATCH behavior.
     """
-    # We use exclude_unset=True to ensure that only the provided keys are updated.
-    # This is particularly useful for allowing setting a specific key to None, while
-    # keeping the existing values for other keys that aren't provided in the payload data.
-    pruned_data = data.model_dump(exclude_unset=True)
+
+    pruned_data = data.model_dump(exclude_none=True)
     logger.info("PATCHing application settings")
     update_config: ApplicationConfig = ApplicationConfig.update_api_set(db, pruned_data)
 

fides/api/api/v1/endpoints/generic_overrides.py

@@ -9,7 +9,7 @@ from fideslang.models import Dataset as FideslangDataset
 from pydantic import ValidationError as PydanticValidationError
 from sqlalchemy import not_, select
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy.orm import Session, load_only
+from sqlalchemy.orm import Session
 from starlette import status
 from starlette.status import (
     HTTP_200_OK,
@@ -22,10 +22,9 @@ from fides.api.common_exceptions import KeyOrNameAlreadyExists, ValidationError
 from fides.api.db.base_class import get_key_from_data
 from fides.api.db.crud import list_resource_query
 from fides.api.db.ctl_session import get_async_db
-from fides.api.models.connectionconfig import ConnectionConfig, ConnectionType
+from fides.api.models.connectionconfig import ConnectionConfig
 from fides.api.models.datasetconfig import DatasetConfig
 from fides.api.oauth.utils import verify_oauth_client
-from fides.api.schemas.dataset import DatasetResponse
 from fides.api.schemas.filter_params import FilterParams
 from fides.api.schemas.taxonomy_extensions import (
     DataCategory,
@@ -99,11 +98,6 @@ async def create_dataset(
                 else exc.message
             ),
         )
-    except KeyOrNameAlreadyExists as exc:
-        raise HTTPException(
-            status_code=HTTP_422_UNPROCESSABLE_ENTITY,
-            detail=str(exc),
-        )
 
 
 @dataset_router.put(
@@ -139,7 +133,7 @@ async def update_dataset(
 @dataset_router.get(
     "/dataset",
     dependencies=[Security(verify_oauth_client, scopes=[CTL_DATASET_READ])],
-    response_model=Union[Page[DatasetResponse], List[DatasetResponse]],
+    response_model=Union[Page[FideslangDataset], List[FideslangDataset]],
     name="List datasets (optionally paginated)",
 )
 async def list_dataset_paginated(
@@ -150,9 +144,7 @@ async def list_dataset_paginated(
     data_categories: Optional[List[str]] = Query(None),
     exclude_saas_datasets: Optional[bool] = Query(False),
     only_unlinked_datasets: Optional[bool] = Query(False),
-    connection_type: Optional[ConnectionType] = Query(None),
-    minimal: Optional[bool] = Query(False),
-) -> Union[Page[DatasetResponse], List[DatasetResponse]]:
+) -> Union[Page[FideslangDataset], List[FideslangDataset]]:
     """
     Get a list of all of the Datasets.
     If any pagination parameters (size or page) are provided, then the response will be paginated.
@@ -164,25 +156,6 @@ async def list_dataset_paginated(
 
     query = select(CtlDataset)
 
-    if minimal:
-        # .options() allows us to modify how the query loads data by configuring the query's loading behavior
-        # load_only() optimizes the query by only loading the specified columns from the database
-        # This reduces memory usage and query time by not loading unnecessary columns
-        # The columns specified below are the minimal set needed for the DatasetResponse model
-        query = query.options(  # type: ignore[attr-defined]
-            load_only(
-                CtlDataset.id,
-                CtlDataset.fides_key,
-                CtlDataset.organization_fides_key,
-                CtlDataset.name,
-                CtlDataset.created_at,
-                CtlDataset.updated_at,
-                CtlDataset.meta,
-                CtlDataset.fides_meta,
-                CtlDataset.description,
-            )
-        )
-
     # Add filters for search and data categories
     filter_params = FilterParams(search=search, data_categories=data_categories)
     filtered_query = apply_filters_to_query(
@@ -192,13 +165,6 @@ async def list_dataset_paginated(
         filter_params=filter_params,
     )
 
-    # If applicable, filter by connection type
-    if connection_type:
-        filtered_query = filtered_query.where(
-            CtlDataset.fides_meta["namespace"]["connection_type"].as_string()
-            == connection_type.value
-        )
-
     # If applicable, keep only unlinked datasets
     if only_unlinked_datasets:
         linked_datasets = select([DatasetConfig.ctl_dataset_id])
@@ -216,18 +182,10 @@ async def list_dataset_paginated(
         )
 
     if not page and not size:
-        results = await list_resource_query(db, filtered_query, CtlDataset)
-        response = [
-            DatasetResponse.model_validate(result.__dict__) for result in results
-        ]
-        return response
+        return await list_resource_query(db, filtered_query, CtlDataset)
 
     pagination_params = Params(page=page or 1, size=size or 50)
-    results = await async_paginate(db, filtered_query, pagination_params)
-    results.items = [  # type: ignore[attr-defined]
-        DatasetResponse.model_validate(result.__dict__) for result in results.items  # type: ignore[attr-defined]
-    ]
-    return results
+    return await async_paginate(db, filtered_query, pagination_params)
 
 
 @dataset_router.get(

fides/api/models/asset.py

@@ -38,8 +38,6 @@ class Asset(Base):
     locations = Column(ARRAY(String), server_default="{}", nullable=False)
     with_consent = Column(BOOLEAN, default=False, nullable=False)
     data_uses = Column(ARRAY(String), server_default="{}", nullable=False)
-    description = Column(String, nullable=True)
-    page = Column(ARRAY(String), server_default="{}", nullable=False)
 
     # generic object to store additional attributes, specific to asset type
     meta = Column(
@@ -95,11 +93,9 @@ class Asset(Base):
         - asset_type
         - domain
         - base_url (if applicable)
-        - system_id
-
-        If you provide the ID of an existing asset it will be updated with any provided data
+        - system_id.
         """
-        if "id" not in data and (
+        if (
             "name" not in data
             or "asset_type" not in data
             or "domain" not in data
@@ -109,40 +105,25 @@ class Asset(Base):
                 "name, asset_type, domain, and system_id are required fields on assets"
             )
 
+        result = await async_session.execute(
+            select(cls).where(  # type: ignore[arg-type, call-arg]
+                cls.name == data["name"],
+                cls.asset_type == data["asset_type"],
+                cls.domain == data["domain"],
+                cls.system_id == data["system_id"],
+                cls.base_url == data.get("base_url"),
+            )
+        )
+        existing_record = result.scalars().first()
         record_id: str
-
-        if "id" in data:
-            result = await async_session.execute(
-                select(cls).where(cls.id == data["id"])  # type: ignore[arg-type]
+        if existing_record:
+            await async_session.execute(
+                update(cls).where(cls.id == existing_record.id).values(data)  # type: ignore[arg-type]
             )
-            existing_record = result.scalars().first()
-            if existing_record:
-                await async_session.execute(
-                    update(cls).where(cls.id == existing_record.id).values(data)  # type: ignore[arg-type]
-                )
-                record_id = existing_record.id
-            else:
-                raise ValueError(f"Asset with id {data['id']} does not exist")
+            record_id = existing_record.id
         else:
-            result = await async_session.execute(
-                select(cls).where(  # type: ignore[arg-type, call-arg]
-                    cls.name == data["name"],
-                    cls.asset_type == data["asset_type"],
-                    cls.domain == data["domain"],
-                    cls.base_url == data.get("base_url"),
-                    cls.system_id == data["system_id"],
-                )
-            )
-
-            existing_record = result.scalars().first()
-            if existing_record:
-                await async_session.execute(
-                    update(cls).where(cls.id == existing_record.id).values(data)  # type: ignore[arg-type]
-                )
-                record_id = existing_record.id
-            else:
-                result = await async_session.execute(insert(cls).values(data))  # type: ignore[arg-type]
-                record_id = result.inserted_primary_key.id
+            result = await async_session.execute(insert(cls).values(data))  # type: ignore[arg-type]
+            record_id = result.inserted_primary_key.id
 
         result = await async_session.execute(select(cls).where(cls.id == record_id))  # type: ignore[arg-type]
         return result.scalars().first()

fides/api/models/attachment.py

@@ -13,14 +13,12 @@ from fides.api.db.base_class import Base
 from fides.api.models.fides_user import FidesUser  # pylint: disable=unused-import
 from fides.api.models.storage import StorageConfig  # pylint: disable=unused-import
 from fides.api.schemas.storage.storage import StorageDetails, StorageType
-from fides.api.service.storage.s3 import (
+from fides.api.tasks.storage import (
+    LOCAL_FIDES_UPLOAD_DIRECTORY,
     generic_delete_from_s3,
     generic_retrieve_from_s3,
-    generic_upload_to_s3,
-)
-from fides.api.service.storage.util import (
-    LOCAL_FIDES_UPLOAD_DIRECTORY,
     get_local_filename,
+    upload_to_s3,
 )
 
 
@@ -93,6 +91,7 @@ class Attachment(Base):
 
     user = relationship(
         "FidesUser",
+        backref="attachments",
         lazy="selectin",
         uselist=False,
     )
@@ -115,10 +114,13 @@ 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]
-            generic_upload_to_s3(
+            upload_to_s3(
                 storage_secrets=self.config.secrets,
+                data={},
                 bucket_name=bucket_name,
                 file_key=self.id,
+                resp_format=self.config.format,
+                privacy_request=None,
                 document=attachment,
                 auth_method=auth_method,
             )

fides/api/models/comment.py

@@ -1,5 +1,5 @@
 from enum import Enum as EnumType
-from typing import TYPE_CHECKING, Any
+from typing import Any
 
 from sqlalchemy import Column
 from sqlalchemy import Enum as EnumColumn
@@ -8,10 +8,8 @@ from sqlalchemy.ext.declarative import declared_attr
 from sqlalchemy.orm import Session, relationship
 
 from fides.api.db.base_class import Base
-
-if TYPE_CHECKING:
-    from fides.api.models.attachment import Attachment
-    from fides.api.models.fides_user import FidesUser
+from fides.api.models.attachment import Attachment, AttachmentReference
+from fides.api.models.fides_user import FidesUser  # pylint: disable=unused-import
 
 
 class CommentType(str, EnumType):
@@ -80,6 +78,7 @@ class Comment(Base):
 
     user = relationship(
         "FidesUser",
+        backref="comments",
         lazy="selectin",
         uselist=False,
     )
@@ -91,19 +90,20 @@ class Comment(Base):
         uselist=True,
     )
 
-    attachments = relationship(
-        "Attachment",
-        secondary="attachment_reference",
-        primaryjoin="Comment.id == AttachmentReference.reference_id",
-        secondaryjoin="Attachment.id == AttachmentReference.attachment_id",
-        order_by="Attachment.created_at",
-        uselist=True,
-    )
+    def get_attachments(self, db: Session) -> list[Attachment]:
+        """Retrieve all attachments associated with this comment."""
+        stmt = (
+            db.query(Attachment)
+            .join(
+                AttachmentReference, Attachment.id == AttachmentReference.attachment_id
+            )
+            .where(AttachmentReference.reference_id == self.id)
+        )
+        return db.execute(stmt).scalars().all()
 
     def delete(self, db: Session) -> None:
         """Delete the comment and all associated references."""
-        # Delete the comment
-        for attachment in self.attachments:
-            if len(attachment.references) == 1:
-                attachment.delete(db)
+        attachments = self.get_attachments(db)
+        for attachment in attachments:
+            attachment.delete(db)
         db.delete(self)

fides/api/models/connectionconfig.py

@@ -186,7 +186,7 @@ class ConnectionConfig(Base):
             )
         ),
         nullable=True,
-    )  # Type bytes in the db
+    )  # Type bytea in the db
     last_test_timestamp = Column(DateTime(timezone=True))
     last_test_succeeded = Column(Boolean)
     disabled = Column(Boolean, server_default="f", default=False)

fides/api/models/detection_discovery.py

@@ -277,18 +277,6 @@ class StagedResource(Base):
         server_default="{}",
         default=dict,
     )
-    user_assigned_data_uses = Column(
-        ARRAY(String),
-        nullable=False,
-        server_default="{}",
-        default=dict,
-    )
-    user_assigned_system_id = Column(
-        String,
-        ForeignKey(System.id_field_path),
-        nullable=True,
-        index=True,
-    )
 
     # pointers to child and parent URNs
     children = Column(

fides/api/models/location_regulation_selections.py

@@ -317,7 +317,6 @@ class Location(LocationRegulationBase):
 
     belongs_to: List[str] = []
     regulation: List[str] = []
-    is_country: bool = False
 
 
 class LocationGroup(Location):