ethyca-fides 2.66.2b2__py2.py3-none-any.whl → 2.66.2rc0__py2.py3-none-any.whl

fides/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-07-29T12:07:43-0300",
+ "date": "2025-07-29T12:24:25-0400",
  "dirty": false,
  "error": null,
- "full-revisionid": "4ba0450a533ee5c9b65ed8ae70df97cfb829ef8d",
- "version": "2.66.2b2"
+ "full-revisionid": "0d085cb0c09afcc5309f42f6c24de184d443af13",
+ "version": "2.66.2rc0"
 }
 '''  # END VERSION_JSON
 

fides/api/api/v1/endpoints/dataset_config_endpoints.py

@@ -1,7 +1,7 @@
 from typing import Annotated, Any, Dict, List, Optional
 
 import yaml
-from fastapi import Depends, HTTPException, Query, Request
+from fastapi import Depends, HTTPException, Request
 from fastapi.encoders import jsonable_encoder
 from fastapi.params import Security
 from fastapi_pagination import Page, Params
@@ -68,18 +68,10 @@ from fides.api.models.sql_models import (  # type: ignore[attr-defined] # isort:
 )
 
 X_YAML = "application/x-yaml"
-MAX_DATASET_CONFIGS_FOR_INTEGRATION_FORM = 1000
 
 router = APIRouter(tags=["Dataset Configs"], prefix=V1_URL_PREFIX)
 
 
-# Custom Params class with higher limit for dataset configs
-class DatasetConfigParams(Params):
-    size: int = Query(
-        50, ge=1, le=MAX_DATASET_CONFIGS_FOR_INTEGRATION_FORM, description="Page size"
-    )
-
-
 # Helper method to inject the parent ConnectionConfig into these child routes
 def _get_connection_config(
     connection_key: FidesKey, db: Session = Depends(deps.get_db)
@@ -139,7 +131,7 @@ def validate_dataset(
     response_model=BulkPutDataset,
 )
 def put_dataset_configs(
-    dataset_pairs: Annotated[List[DatasetConfigCtlDataset], Field(max_length=MAX_DATASET_CONFIGS_FOR_INTEGRATION_FORM)],  # type: ignore
+    dataset_pairs: Annotated[List[DatasetConfigCtlDataset], Field(max_length=50)],  # type: ignore
     db: Session = Depends(deps.get_db),
     dataset_config_service: DatasetConfigService = Depends(get_dataset_config_service),
     connection_config: ConnectionConfig = Depends(_get_connection_config),
@@ -189,7 +181,7 @@ def put_dataset_configs(
     response_model=BulkPutDataset,
 )
 def patch_dataset_configs(
-    dataset_pairs: Annotated[List[DatasetConfigCtlDataset], Field(max_length=MAX_DATASET_CONFIGS_FOR_INTEGRATION_FORM)],  # type: ignore
+    dataset_pairs: Annotated[List[DatasetConfigCtlDataset], Field(max_length=50)],  # type: ignore
     dataset_config_service: DatasetConfigService = Depends(get_dataset_config_service),
     connection_config: ConnectionConfig = Depends(_get_connection_config),
 ) -> BulkPutDataset:
@@ -225,7 +217,7 @@ def patch_dataset_configs(
     response_model=BulkPutDataset,
 )
 def patch_datasets(
-    datasets: Annotated[List[FideslangDataset], Field(max_length=1000)],  # type: ignore
+    datasets: Annotated[List[FideslangDataset], Field(max_length=50)],  # type: ignore
     dataset_config_service: DatasetConfigService = Depends(get_dataset_config_service),
     connection_config: ConnectionConfig = Depends(_get_connection_config),
 ) -> BulkPutDataset:
@@ -375,7 +367,7 @@ def get_dataset(
 )
 def get_dataset_configs(
     db: Session = Depends(deps.get_db),
-    params: DatasetConfigParams = Depends(),
+    params: Params = Depends(),
     connection_config: ConnectionConfig = Depends(_get_connection_config),
 ) -> AbstractPage[DatasetConfig]:
     """Returns all Dataset Configs attached to current Connection Config."""

fides/api/api/v1/endpoints/drp_endpoints.py

@@ -125,13 +125,7 @@ async def create_drp_privacy_request(
             "Decrypting identity for DRP privacy request {}", privacy_request.id
         )
 
-        cache_data(privacy_request, mapped_identity, None, data)
-
-        if masking_secrets := policy.generate_masking_secrets():
-            logger.info(
-                "Caching masking secrets for privacy request {}", privacy_request.id
-            )
-            privacy_request.persist_masking_secrets(masking_secrets)
+        cache_data(privacy_request, policy, mapped_identity, None, data)
 
         queue_privacy_request(privacy_request.id)
 

fides/api/api/v1/endpoints/privacy_request_endpoints.py

@@ -4,7 +4,7 @@ import csv
 import io
 import json
 from collections import defaultdict
-from datetime import datetime, timezone
+from datetime import datetime
 from typing import (
     Annotated,
     Any,
@@ -146,7 +146,6 @@ from fides.common.api.v1.urn_registry import (
     PRIVACY_REQUEST_BULK_SOFT_DELETE,
     PRIVACY_REQUEST_DENY,
     PRIVACY_REQUEST_FILTERED_RESULTS,
-    PRIVACY_REQUEST_FINALIZE,
     PRIVACY_REQUEST_MANUAL_WEBHOOK_ACCESS_INPUT,
     PRIVACY_REQUEST_MANUAL_WEBHOOK_ERASURE_INPUT,
     PRIVACY_REQUEST_NOTIFICATIONS,
@@ -1863,48 +1862,6 @@ def resume_privacy_request_from_requires_input(
     return privacy_request  # type: ignore[return-value]
 
 
-@router.post(
-    PRIVACY_REQUEST_FINALIZE,
-    status_code=HTTP_200_OK,
-    response_model=PrivacyRequestResponse,
-    dependencies=[Security(verify_oauth_client, scopes=[PRIVACY_REQUEST_REVIEW])],
-)
-def finalize_privacy_request(
-    privacy_request_id: str,
-    *,
-    db: Session = Depends(deps.get_db),
-    client: ClientDetail = Security(
-        verify_oauth_client,
-        scopes=[PRIVACY_REQUEST_REVIEW],
-    ),
-) -> PrivacyRequestResponse:
-    """
-    Finalizes a privacy request, moving it from the 'requires_finalization' state to 'complete'.
-    This is done by re-queueing the request, which will then hit the finalization logic in the
-    request runner service. This logic marks the privacy request as complete
-    and sends out any configured messaging to the user.
-    """
-    privacy_request = get_privacy_request_or_error(db, privacy_request_id)
-
-    if privacy_request.status != PrivacyRequestStatus.requires_manual_finalization:
-        raise HTTPException(
-            status_code=HTTP_400_BAD_REQUEST,
-            detail=f"Cannot manually finalize privacy request '{privacy_request_id}': status is {privacy_request.status}, not requires_manual_finalization.",
-        )
-
-    # Set finalized_by and finalized_at here, so the request runner service knows not to
-    # put the request back into the requires_finalization state.
-    privacy_request.finalized_at = datetime.now(timezone.utc)
-    privacy_request.finalized_by = client.user_id
-    privacy_request.save(db=db)
-
-    queue_privacy_request(
-        privacy_request_id=privacy_request_id,
-    )
-
-    return privacy_request  # type: ignore[return-value]
-
-
 @router.get(
     REQUEST_TASKS,
     dependencies=[Security(verify_oauth_client, scopes=[PRIVACY_REQUEST_READ])],

fides/api/api/v1/endpoints/user_endpoints.py

@@ -6,7 +6,6 @@ from typing import List, Optional
 
 import jose.exceptions
 from fastapi import Depends, HTTPException, Security
-from fastapi.security import SecurityScopes
 from fastapi_pagination import Page, Params
 from fastapi_pagination.bases import AbstractPage
 from fastapi_pagination.ext.sqlalchemy import paginate
@@ -40,9 +39,7 @@ from fides.api.oauth.roles import APPROVER, VIEWER
 from fides.api.oauth.utils import (
     create_temporary_user_for_login_flow,
     extract_payload,
-    extract_token_and_load_client,
     get_current_user,
-    has_permissions,
     oauth2_scheme,
     verify_oauth_client,
 )
@@ -68,7 +65,6 @@ from fides.common.api.scope_registry import (
     USER_DELETE,
     USER_PASSWORD_RESET,
     USER_READ,
-    USER_READ_OWN,
     USER_UPDATE,
 )
 from fides.common.api.v1 import urn_registry as urls
@@ -111,37 +107,6 @@ def _validate_current_user(user_id: str, user_from_token: FidesUser) -> None:
         )
 
 
-def verify_user_read_scopes(
-    authorization: str = Security(oauth2_scheme),
-    db: Session = Depends(get_db),
-) -> ClientDetail:
-    """
-    Custom dependency that verifies the user has either USER_READ or USER_READ_OWN scope.
-    Returns the client if authorized.
-    """
-    token_data, client = extract_token_and_load_client(authorization, db)
-
-    # Try USER_READ first
-    if has_permissions(
-        token_data=token_data,
-        client=client,
-        endpoint_scopes=SecurityScopes([USER_READ]),
-    ):
-        return client
-
-    if has_permissions(
-        token_data=token_data,
-        client=client,
-        endpoint_scopes=SecurityScopes([USER_READ_OWN]),
-    ):
-        return client
-
-    raise HTTPException(
-        status_code=HTTP_403_FORBIDDEN,
-        detail="Not authorized.",
-    )
-
-
 @router.put(
     urls.USER_DETAIL,
     dependencies=[Security(verify_oauth_client)],
@@ -533,38 +498,14 @@ def delete_user(
 
 @router.get(
     urls.USER_DETAIL,
-    dependencies=[Security(verify_user_read_scopes)],
+    dependencies=[Security(verify_oauth_client, scopes=[USER_READ])],
     response_model=UserResponse,
 )
-def get_user(
-    *,
-    db: Session = Depends(get_db),
-    user_id: str,
-    client: ClientDetail = Security(verify_user_read_scopes),
-    authorization: str = Security(oauth2_scheme),
-) -> FidesUser:
-    """Returns a User based on an Id. Users with USER_READ_OWN scope can only access their own data."""
+def get_user(*, db: Session = Depends(get_db), user_id: str) -> FidesUser:
+    """Returns a User based on an Id"""
     user: Optional[FidesUser] = FidesUser.get_by_key_or_id(db, data={"id": user_id})
     if user is None:
         raise HTTPException(status_code=HTTP_404_NOT_FOUND, detail="User not found")
-    token_data, _ = extract_token_and_load_client(authorization, db)
-    # Check if user has USER_READ_OWN scope and is trying to access someone else's data
-    # The verify_user_read_scopes dependency already verified the user has either USER_READ or USER_READ_OWN
-    # We need to check if they have USER_READ_OWN and are accessing their own data
-    if has_permissions(
-        token_data=token_data,
-        client=client,
-        endpoint_scopes=SecurityScopes([USER_READ]),
-    ):
-        logger.debug("Returning user with id: '{}'.", user_id)
-        return user
-
-    # User has USER_READ_OWN scope, check if they're accessing their own data
-    if user.id != client.user_id:
-        raise HTTPException(
-            status_code=HTTP_403_FORBIDDEN,
-            detail="You can only access your own user data with USER_READ_OWN scope.",
-        )
 
     logger.debug("Returning user with id: '{}'.", user_id)
     return user
@@ -572,7 +513,7 @@ def get_user(
 
 @router.get(
     urls.USERS,
-    dependencies=[Security(verify_user_read_scopes)],
+    dependencies=[Security(verify_oauth_client, scopes=[USER_READ])],
     response_model=Page[UserResponse],
 )
 def get_users(
@@ -580,28 +521,11 @@ def get_users(
     db: Session = Depends(get_db),
     params: Params = Depends(),
     username: Optional[str] = None,
-    client: ClientDetail = Security(verify_user_read_scopes),
-    authorization: str = Security(oauth2_scheme),
 ) -> AbstractPage[FidesUser]:
-    """Returns a paginated list of users. Users with USER_READ_OWN scope only see their own data."""
+    """Returns a paginated list of all users"""
     query = FidesUser.query(db)
-
-    # Check if user has USER_READ_OWN scope and filter accordingly
-    # The verify_user_read_scopes dependency already verified the user has either USER_READ or USER_READ_OWN
-    token_data, _ = extract_token_and_load_client(authorization, db)
-    if has_permissions(
-        token_data=token_data,
-        client=client,
-        endpoint_scopes=SecurityScopes([USER_READ]),
-    ):
-        # User has USER_READ scope, can see all users
-        if username:
-            query = query.filter(FidesUser.username.ilike(f"%{escape_like(username)}%"))
-    else:
-        # User has USER_READ_OWN scope, only show their own data
-        query = query.filter(FidesUser.id == client.user_id)
-        if username:
-            query = query.filter(FidesUser.username.ilike(f"%{escape_like(username)}%"))
+    if username:
+        query = query.filter(FidesUser.username.ilike(f"%{escape_like(username)}%"))
 
     logger.debug("Returning a paginated list of users.")
 

fides/api/app_setup.py

@@ -171,9 +171,8 @@ async def run_database_startup(app: FastAPI) -> None:
     if CONFIG.database.automigrate:
         try:
             configure_db(CONFIG.database.sync_database_uri)
-            if not CONFIG.test_mode:
-                with get_autoclose_db_session() as session:
-                    seed_db(session)
+            with get_autoclose_db_session() as session:
+                seed_db(session)
             if CONFIG.database.load_samples:
                 async with get_async_autoclose_db_session() as async_session:
                     await seed.load_samples(async_session)

fides/api/common_exceptions.py

@@ -283,10 +283,6 @@ class MalisciousUrlException(Exception):
     """Fides has detected a potentially maliscious URL."""
 
 
-class MaskingSecretsExpired(BaseException):
-    """The cached masking secrets have expired for the given privacy request."""
-
-
 class AuthenticationError(HTTPException):
     """To be raised when attempting to fetch an access token using
     invalid credentials.

fides/api/db/base.py

@@ -33,7 +33,6 @@ from fides.api.models.identity_salt import IdentitySalt
 from fides.api.models.location_regulation_selections import LocationRegulationSelections
 from fides.api.models.manual_task import (
     ManualTask,
-    ManualTaskConditionalDependency,
     ManualTaskConfig,
     ManualTaskConfigField,
     ManualTaskInstance,

fides/api/db/database.py

@@ -123,7 +123,7 @@ def get_db_health(
 
 
 def seed_db(session: Session) -> None:
-    """Load default resources into the database"""
+    """Load default resources into the database, and optionally load samples."""
     load_default_resources(session)
 
 

fides/api/graph/execution.py

@@ -1,7 +1,6 @@
 from typing import Any, Callable, Dict, List, Optional, Set, Tuple
 
 from fideslang.validation import FidesKey
-from loguru import logger
 
 from fides.api.graph.config import (
     Collection,
@@ -118,8 +117,6 @@ class ExecutionNode(Contextualizable):  # pylint: disable=too-many-instance-attr
         The values are cast based on field types, if those types are specified.
         """
         out = {}
-        failed_conversions: Dict[str, Dict[str, Any]] = {}
-
         for key, values in input_data.items():
             path: FieldPath = FieldPath.parse(key)
             field: Optional[Field] = self.collection.field(path)
@@ -129,31 +126,4 @@ class ExecutionNode(Contextualizable):  # pylint: disable=too-many-instance-attr
                 filtered = list(filter(lambda x: x is not None, cast_values))
                 if filtered:
                     out[key] = filtered
-                elif values:  # Had input values but all failed conversion
-                    # Track conversion failures for logging
-                    failed_conversions[key] = {"field": field, "input_values": values}
-
-        # Log conversion failures if any occurred
-        if failed_conversions:
-            field_details = []
-            for field_name, failure_info in failed_conversions.items():
-                field = failure_info["field"]
-                values = failure_info["input_values"]
-
-                expected_type = field.data_type() if field else "unknown"
-                actual_types = {type(v).__name__ for v in values if v is not None}
-                actual_type_str = (
-                    ", ".join(sorted(actual_types)) if actual_types else "NoneType"
-                )
-
-                field_details.append(
-                    f"{field_name} (expected: {expected_type}, got: {actual_type_str})"
-                )
-
-            logger.warning(
-                "Type conversion failures for {}: {}",
-                self.address,
-                "; ".join(field_details),
-            )
-
         return out

fides/api/graph/traversal.py

@@ -115,7 +115,7 @@ class BaseTraversal:
             )
 
         # Ensure manual_task collections execute right after ROOT
-        from fides.api.task.manual.manual_task_address import ManualTaskAddress
+        from fides.api.task.manual.manual_task_utils import ManualTaskAddress
 
         for addr in self.traversal_node_dict.keys():
             if ManualTaskAddress.is_manual_task_address(addr):

fides/api/models/{manual_task/manual_task.py → manual_task.py}

@@ -26,9 +26,6 @@ from fides.api.schemas.base_class import FidesSchema
 if TYPE_CHECKING:
     from fides.api.models.attachment import Attachment
     from fides.api.models.fides_user import FidesUser
-    from fides.api.models.manual_task.conditional_dependency import (
-        ManualTaskConditionalDependency,
-    )
 
 # ------------------------------------------------------------
 # Enums
@@ -245,13 +242,6 @@ class ManualTask(Base):
         viewonly=True,  # No cascade delete - submissions are historical data
     )
 
-    conditional_dependencies = relationship(
-        "ManualTaskConditionalDependency",
-        back_populates="task",
-        uselist=True,
-        cascade="all, delete-orphan",
-    )
-
     # Properties
     @property
     def assigned_users(self) -> list[str]:

fides/api/models/policy.py

@@ -25,9 +25,7 @@ from fides.api.models.client import ClientDetail
 from fides.api.models.connectionconfig import ConnectionConfig
 from fides.api.models.sql_models import DataCategory  # type: ignore
 from fides.api.models.storage import StorageConfig, get_active_default_storage_config
-from fides.api.schemas.masking.masking_secrets import MaskingSecretCache
 from fides.api.schemas.policy import ActionType, DrpAction
-from fides.api.service.masking.strategy.masking_strategy import MaskingStrategy
 from fides.api.util.data_category import _validate_data_category
 from fides.config import CONFIG
 
@@ -142,27 +140,6 @@ class Policy(Base):
         except IndexError:
             return None
 
-    def generate_masking_secrets(self) -> Optional[List[MaskingSecretCache]]:
-        """
-        Returns a list of masking secrets for the masking strategies in the policy.
-        """
-
-        masking_secrets: List[MaskingSecretCache] = []
-        erasure_rules = self.get_rules_for_action(action_type=ActionType.erasure)
-        unique_masking_strategies_by_name: Set[str] = set()
-        for rule in erasure_rules:
-            strategy_name: str = rule.masking_strategy["strategy"]  # type: ignore
-            configuration = rule.masking_strategy["configuration"]  # type: ignore
-            if strategy_name in unique_masking_strategies_by_name:
-                continue
-            unique_masking_strategies_by_name.add(strategy_name)
-            masking_strategy = MaskingStrategy.get_strategy(
-                strategy_name, configuration
-            )
-            if masking_strategy.secrets_required():
-                masking_secrets.extend(masking_strategy.generate_secrets_for_cache())
-        return masking_secrets
-
     def applies_to(self, node: "TraversalNode") -> bool:
         """
         Returns True if any data category in the traversal node starts with any of the policy's target categories.

fides/api/models/privacy_request/execution_log.py

@@ -24,7 +24,6 @@ EXECUTION_CHECKPOINTS = [
     CurrentStep.finalize_consent,
     CurrentStep.email_post_send,
     CurrentStep.post_webhooks,
-    CurrentStep.finalization,
 ]
 
 COMPLETED_EXECUTION_LOG_STATUSES = [

fides/api/models/privacy_request/privacy_request.py

@@ -50,7 +50,6 @@ from fides.api.models.comment import Comment, CommentReference, CommentReference
 from fides.api.models.fides_user import FidesUser
 from fides.api.models.field_types import EncryptedLargeDataDescriptor
 from fides.api.models.manual_webhook import AccessManualWebhook
-from fides.api.models.masking_secret import MaskingSecret
 from fides.api.models.policy import (
     Policy,
     PolicyPreWebhook,
@@ -99,6 +98,7 @@ from fides.api.util.cache import (
     get_drp_request_body_cache_key,
     get_encryption_cache_key,
     get_identity_cache_key,
+    get_masking_secret_cache_key,
 )
 from fides.api.util.collection_util import Row, extract_key_for_address
 from fides.api.util.constants import API_DATE_FORMAT
@@ -145,12 +145,6 @@ class PrivacyRequest(
         ForeignKey(FidesUser.id_field_path, ondelete="SET NULL"),
         nullable=True,
     )
-    finalized_at = Column(DateTime(timezone=True), nullable=True)
-    finalized_by = Column(
-        String,
-        ForeignKey(FidesUser.id_field_path, ondelete="SET NULL"),
-        nullable=True,
-    )
     submitted_by = Column(
         String,
         ForeignKey(FidesUser.id_field_path, ondelete="SET NULL"),
@@ -295,13 +289,6 @@ class PrivacyRequest(
         order_by="RequestTask.created_at",
     )
 
-    masking_secrets: "RelationshipProperty[List[MaskingSecret]]" = relationship(
-        "MaskingSecret",
-        back_populates="privacy_request",
-        uselist=True,
-        passive_deletes="all",
-    )
-
     @property
     def days_left(self: PrivacyRequest) -> Union[int, None]:
         if self.due_date is None:
@@ -579,24 +566,19 @@ class PrivacyRequest(
             encryption_key,
         )
 
-    def persist_masking_secrets(
-        self, masking_secrets: List[MaskingSecretCache]
-    ) -> None:
-        """Persists masking encryption secrets to database."""
-        if not masking_secrets:
+    def cache_masking_secret(self, masking_secret: MaskingSecretCache) -> None:
+        """Sets masking encryption secrets in the Fides app cache if provided"""
+        if not masking_secret:
             return
-
-        session = Session.object_session(self)
-        for masking_secret in masking_secrets:
-            MaskingSecret.create(
-                db=session,
-                data={
-                    "privacy_request_id": self.id,
-                    "secret": masking_secret.secret,
-                    "masking_strategy": masking_secret.masking_strategy,
-                    "secret_type": masking_secret.secret_type,
-                },
-            )
+        cache: FidesopsRedis = get_cache()
+        cache.set_with_autoexpire(
+            get_masking_secret_cache_key(
+                self.id,
+                masking_strategy=masking_secret.masking_strategy,
+                secret_type=masking_secret.secret_type,
+            ),
+            FidesopsRedis.encode_obj(masking_secret.secret),
+        )
 
     def get_cached_identity_data(self) -> Dict[str, Any]:
         """Retrieves any identity data pertaining to this request from the cache"""

fides/api/oauth/roles.py

@@ -47,7 +47,6 @@ from fides.common.api.scope_registry import (
     SYSTEM_READ,
     USER_PERMISSION_ASSIGN_OWNERS,
     USER_READ,
-    USER_READ_OWN,
     WEBHOOK_READ,
 )
 
@@ -127,7 +126,6 @@ viewer_scopes = [  # Intentionally omitted USER_PERMISSION_READ and PRIVACY_REQU
 
 respondent_scopes = [
     PRIVACY_REQUEST_MANUAL_STEPS_RESPOND,  # allows respondents to respond to assigned manual steps
-    USER_READ_OWN,
 ]
 
 external_respondent_scopes = [

fides/api/schemas/application_config.py

@@ -11,14 +11,6 @@ from fides.api.schemas.messaging.messaging import MessagingServiceType
 from fides.config.admin_ui_settings import ErrorNotificationMode
 
 
-class SqlDryRunMode(str, Enum):
-    """SQL dry run mode for controlling execution of SQL statements in privacy requests"""
-
-    none = "none"
-    access = "access"
-    erasure = "erasure"
-
-
 class StorageTypeApiAccepted(Enum):
     """Enum for storage destination types accepted in API updates"""
 
@@ -70,9 +62,7 @@ class ExecutionApplicationConfig(FidesSchema):
     subject_identity_verification_required: Optional[bool] = None
     disable_consent_identity_verification: Optional[bool] = None
     require_manual_request_approval: Optional[bool] = None
-    sql_dry_run: Optional[SqlDryRunMode] = None
-
-    model_config = ConfigDict(use_enum_values=True, extra="forbid")
+    model_config = ConfigDict(extra="forbid")
 
 
 class AdminUIConfig(FidesSchema):

fides/api/schemas/masking/masking_secrets.py

@@ -5,7 +5,7 @@ from typing import Callable, Generic, TypeVar
 T = TypeVar("T")
 
 
-class SecretType(str, Enum):
+class SecretType(Enum):
     """Enum that holds all possible types of secrets across all masking strategies"""
 
     key = "key"

fides/api/schemas/policy.py

@@ -28,7 +28,6 @@ class CurrentStep(EnumType):
     finalize_consent = "finalize_consent"
     email_post_send = "email_post_send"
     post_webhooks = "post_webhooks"
-    finalization = "finalization"
 
 
 # action types we actively support in policies/requests

fides/api/schemas/privacy_request.py

@@ -124,8 +124,6 @@ class PrivacyRequestResubmit(PrivacyRequestCreate):
     identity_verified_at: Optional[datetime] = None
     custom_privacy_request_fields_approved_at: Optional[datetime] = None
     custom_privacy_request_fields_approved_by: Optional[str] = None
-    finalized_at: Optional[datetime] = None
-    finalized_by: Optional[str] = None
 
 
 class ConsentRequestCreate(FidesSchema):
@@ -289,7 +287,6 @@ class PrivacyRequestStatus(str, EnumType):
     complete = "complete"
     paused = "paused"
     awaiting_email_send = "awaiting_email_send"
-    requires_manual_finalization = "requires_manual_finalization"
     canceled = "canceled"
     error = "error"
 
@@ -323,8 +320,6 @@ class PrivacyRequestResponse(FidesSchema):
     source: Optional[PrivacyRequestSource] = None
     deleted_at: Optional[datetime] = None
     deleted_by: Optional[str] = None
-    finalized_at: Optional[datetime] = None
-    finalized_by: Optional[str] = None
     model_config = ConfigDict(from_attributes=True, use_enum_values=True)
 
 

fides/api/service/connectors/base_connector.py

@@ -82,7 +82,6 @@ class BaseConnector(Generic[DB_CONNECTOR_TYPE], ABC):
         privacy_request: PrivacyRequest,
         request_task: RequestTask,
         rows: List[Row],
-        input_data: Optional[Dict[str, List[Any]]] = None,
     ) -> int:
         """Execute a masking request. Return the number of rows that have been updated