ethyca-fides 2.62.1b3__py2.py3-none-any.whl → 2.62.1rc1__py2.py3-none-any.whl

fides/api/service/connectors/saas_connector.py

@@ -530,15 +530,11 @@ class SaaSConnector(BaseConnector[AuthenticatedClient], Contextualizable):
 
         session = Session.object_session(privacy_request)
         masking_request = query_config.get_masking_request(session)
-        rows_updated = 0
-
         if not masking_request:
-            logger.info(
-                "No masking request found for the '{}' collection in {}",
-                self.current_collection_name,
-                self.saas_config.fides_key,  # type: ignore
+            raise Exception(
+                f"Either no masking request configured or no valid masking request for {node.address.collection}. "
+                f"Check that MASKING_STRICT env var is appropriately set"
             )
-            return rows_updated
 
         self.set_saas_request_state(masking_request)
 
@@ -569,6 +565,7 @@ class SaaSConnector(BaseConnector[AuthenticatedClient], Contextualizable):
             cast(Optional[List[PostProcessorStrategy]], masking_request.postprocessors),
         )
 
+        rows_updated = 0
         client = self.create_client()
         for row in rows:
             try:

fides/api/service/privacy_request/dsr_package/dsr_report_builder.py

@@ -11,7 +11,7 @@ from jinja2 import Environment, FileSystemLoader
 
 from fides.api.models.privacy_request import PrivacyRequest
 from fides.api.schemas.policy import ActionType
-from fides.api.util.storage_util import StorageJSONEncoder
+from fides.api.util.storage_util import storage_json_encoder
 
 DSR_DIRECTORY = Path(__file__).parent.resolve()
 
@@ -41,9 +41,7 @@ class DsrReportBuilder:
 
         # Jinja template environment initialization
         def pretty_print(value: str, indent: int = 4) -> str:
-            return json.dumps(
-                value, indent=indent, default=StorageJSONEncoder().default
-            )
+            return json.dumps(value, indent=indent, default=storage_json_encoder)
 
         jinja2.filters.FILTERS["pretty_print"] = pretty_print
         self.template_loader = Environment(

fides/api/service/privacy_request/request_runner_service.py

@@ -1,4 +1,3 @@
-import time
 from datetime import datetime, timedelta
 from typing import Any, Dict, List, Optional, Set, Tuple
 
@@ -68,7 +67,6 @@ from fides.api.tasks import DatabaseTask, celery_app
 from fides.api.tasks.scheduled.scheduler import scheduler
 from fides.api.util.collection_util import Row
 from fides.api.util.logger import Pii, _log_exception, _log_warning
-from fides.api.util.logger_context_utils import LoggerContextKeys, log_context
 from fides.common.api.v1.urn_registry import (
     PRIVACY_REQUEST_TRANSFER_TO_PARENT,
     V1_URL_PREFIX,
@@ -202,11 +200,6 @@ def run_webhooks_and_report_status(
     return True
 
 
-@log_context(
-    capture_args={
-        "privacy_request_id": LoggerContextKeys.privacy_request_id,
-    }
-)
 def upload_access_results(  # pylint: disable=R0912
     session: Session,
     policy: Policy,
@@ -217,7 +210,6 @@ def upload_access_results(  # pylint: disable=R0912
     fides_connector_datasets: Set[str],
 ) -> List[str]:
     """Process the data uploads after the access portion of the privacy request has completed"""
-    start_time = time.time()
     download_urls: List[str] = []
     if not access_result:
         logger.info("No results returned for access request")
@@ -259,30 +251,12 @@ def upload_access_results(  # pylint: disable=R0912
             )
             if download_url:
                 download_urls.append(download_url)
-                privacy_request.add_success_execution_log(
-                    session,
-                    connection_key=None,
-                    dataset_name="Access Package Upload",
-                    collection_name=None,
-                    message="Access Package Upload successful for privacy request.",
-                    action_type=ActionType.access,
-                )
-            logger.bind(
-                time_taken=time.time() - start_time,
-            ).info("Access Package Upload successful for privacy request.")
         except common_exceptions.StorageUploadError as exc:
-            logger.bind(
-                policy_key=policy.key,
-                rule_key=rule.key,
-                error=Pii(str(exc)),
-            ).error("Error uploading subject access data for rule.")
-            privacy_request.add_error_execution_log(
-                session,
-                connection_key=None,
-                dataset_name="Access Package Upload",
-                collection_name=None,
-                message="Access Package Upload failed for privacy request.",
-                action_type=ActionType.access,
+            logger.error(
+                "Error uploading subject access data for rule {} on policy {}: {}",
+                rule.key,
+                policy.key,
+                Pii(str(exc)),
             )
             privacy_request.status = PrivacyRequestStatus.error
     # Save the results we uploaded to the user for later retrieval
@@ -622,22 +596,19 @@ def run_privacy_request(
                     # If dev mode, log traceback
                     _log_exception(e, CONFIG.dev_mode)
                     return
-
-            # Only mark as complete if not in error state
-            if privacy_request.status != PrivacyRequestStatus.error:
-                privacy_request.finished_processing_at = datetime.utcnow()
-                AuditLog.create(
-                    db=session,
-                    data={
-                        "user_id": "system",
-                        "privacy_request_id": privacy_request.id,
-                        "action": AuditLogAction.finished,
-                        "message": "",
-                    },
-                )
-                privacy_request.status = PrivacyRequestStatus.complete
-                logger.info("Privacy request run completed.")
-                privacy_request.save(db=session)
+            privacy_request.finished_processing_at = datetime.utcnow()
+            AuditLog.create(
+                db=session,
+                data={
+                    "user_id": "system",
+                    "privacy_request_id": privacy_request.id,
+                    "action": AuditLogAction.finished,
+                    "message": "",
+                },
+            )
+            privacy_request.status = PrivacyRequestStatus.complete
+            logger.info("Privacy request run completed.")
+            privacy_request.save(db=session)
 
 
 def initiate_privacy_request_completion_email(

fides/api/service/storage/s3.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import IO, Any, Dict, Tuple, Union
+from typing import IO, Any, Dict, Tuple
 
 from boto3.s3.transfer import TransferConfig
 from botocore.exceptions import ClientError, ParamValidationError
@@ -129,38 +129,25 @@ def generic_retrieve_from_s3(
     bucket_name: str,
     file_key: str,
     auth_method: str,
-    get_content: bool = False,
-) -> Tuple[int, Union[str, bytes]]:
+) -> Tuple[int, AnyHttpUrlString]:
     """
-    Retrieves a file from S3 and returns its size and either a presigned URL or the actual content.
-
-    Args:
-        storage_secrets: Dictionary containing S3 credentials
-        bucket_name: Name of the S3 bucket
-        file_key: Key of the file in the bucket
-        auth_method: Authentication method to use
-        get_content: If True, returns the actual content instead of a presigned URL
+    Retrieves file metadata and generates a presigned URL for downloading an S3 object.
 
-    Returns:
-        Tuple containing (file_size, presigned_url_or_content)
+    :param storage_secrets: S3 storage secrets
+    :param bucket_name: Name of the S3 bucket
+    :param file_key: Key of the file in the bucket
+    :param auth_method: Authentication method for S3
+    :return: Tuple containing (file_size, presigned_url)
     """
     logger.info("Retrieving S3 object: {}", file_key)
-    s3_client = get_s3_client(auth_method, storage_secrets)
 
+    s3_client = maybe_get_s3_client(auth_method, storage_secrets)
     try:
-        if get_content:
-            # Get the actual content
-            response = s3_client.get_object(Bucket=bucket_name, Key=file_key)
-            content = response["Body"].read()
-            return response["ContentLength"], content
-
-        # Get presigned URL
-        presigned_url = create_presigned_url_for_s3(s3_client, bucket_name, file_key)
-        # Get file size
-        response = s3_client.head_object(Bucket=bucket_name, Key=file_key)
-        return int(response["ContentLength"]), str(presigned_url)
-    except ClientError as e:
-        logger.error(f"Error retrieving file from S3: {e}")
+        get_allowed_file_type_or_raise(file_key)
+        file_size = get_file_size(s3_client, bucket_name, file_key)
+        return file_size, create_presigned_url_for_s3(s3_client, bucket_name, file_key)
+    except Exception as e:
+        logger.error("Encountered error while retrieving S3 object: {}", e)
         raise e
 
 
@@ -171,8 +158,7 @@ def generic_delete_from_s3(
     auth_method: str,
 ) -> None:
     """
-    Deletes arbitrary data from s3. If file_key ends with a filename, deletes just that file.
-    If file_key ends with a '/', deletes all objects with that prefix.
+    Deletes arbitrary data from s3
 
     :param storage_secrets: S3 storage secrets
     :param bucket_name: Name of the S3 bucket
@@ -183,17 +169,6 @@ def generic_delete_from_s3(
 
     s3_client = maybe_get_s3_client(auth_method, storage_secrets)
     try:
-        # If the file_key ends with a '/', it's a folder prefix
-        if file_key.endswith("/"):
-            # List all objects with the prefix, handling pagination
-            paginator = s3_client.get_paginator("list_objects_v2")
-            for page in paginator.paginate(Bucket=bucket_name, Prefix=file_key):
-                if "Contents" in page:
-                    for obj in page["Contents"]:
-                        s3_client.delete_object(Bucket=bucket_name, Key=obj["Key"])
-            return
-
-        # Delete single object
         s3_client.delete_object(Bucket=bucket_name, Key=file_key)
     except Exception as e:
         logger.error("Encountered error while deleting s3 object: {}", e)

fides/api/tasks/storage.py

@@ -11,7 +11,6 @@ from botocore.exceptions import ClientError, ParamValidationError
 from fideslang.validation import AnyHttpUrlString
 from loguru import logger
 
-from fides.api.common_exceptions import StorageUploadError
 from fides.api.cryptography.cryptographic_util import bytes_to_b64_str
 from fides.api.schemas.storage.storage import ResponseFormat, StorageSecrets
 from fides.api.service.privacy_request.dsr_package.dsr_report_builder import (
@@ -31,7 +30,7 @@ from fides.api.util.cache import get_cache, get_encryption_cache_key
 from fides.api.util.encryption.aes_gcm_encryption_scheme import (
     encrypt_to_bytes_verify_secrets_length,
 )
-from fides.api.util.storage_util import StorageJSONEncoder
+from fides.api.util.storage_util import storage_json_encoder
 from fides.config import CONFIG
 
 if TYPE_CHECKING:
@@ -76,7 +75,7 @@ def write_to_in_memory_buffer(
     logger.debug("Writing data to in-memory buffer")
 
     if resp_format == ResponseFormat.json.value:
-        json_str = json.dumps(data, indent=2, default=StorageJSONEncoder().default)
+        json_str = json.dumps(data, indent=2, default=storage_json_encoder)
         return BytesIO(
             encrypt_access_request_results(json_str, privacy_request.id).encode(
                 CONFIG.security.encoding
@@ -161,9 +160,9 @@ def upload_to_s3(  # pylint: disable=R0913
         logger.error(
             "Encountered error while uploading and generating link for s3 object: {}", e
         )
-        raise StorageUploadError(f"Error uploading to S3: {e}")
+        raise e
     except ParamValidationError as e:
-        raise StorageUploadError(f"The parameters you provided are incorrect: {e}")
+        raise ValueError(f"The parameters you provided are incorrect: {e}")
 
 
 def upload_to_gcs(
@@ -206,7 +205,7 @@ def upload_to_gcs(
             "Encountered error while uploading and generating link for Google Cloud Storage object: {}",
             e,
         )
-        raise StorageUploadError(f"Error uploading to Google Cloud Storage: {e}")
+        raise e
 
 
 def upload_to_local(

fides/api/util/storage_util.py

@@ -1,5 +1,5 @@
 from datetime import datetime
-from typing import Any, Union
+from typing import Any, Dict, Union
 
 from bson import ObjectId
 from pydantic import ValidationError
@@ -11,7 +11,6 @@ from fides.api.schemas.storage.storage import (
     StorageType,
 )
 from fides.api.schemas.storage.storage_secrets_docs_only import possible_storage_secrets
-from fides.api.util.custom_json_encoder import CustomJSONEncoder
 
 
 def get_schema_for_secrets(
@@ -49,15 +48,10 @@ def get_schema_for_secrets(
         raise ValueError(errors)
 
 
-class StorageJSONEncoder(CustomJSONEncoder):
-    """
-    A JSON encoder specifically for storage operations that maintains the original
-    format for datetime and ObjectId while inheriting other functionality from CustomJSONEncoder.
-    """
-
-    def default(self, o: Any) -> Any:
-        if isinstance(o, datetime):
-            return o.strftime("%Y-%m-%dT%H:%M:%S")
-        if isinstance(o, ObjectId):
-            return {"$oid": str(o)}
-        return super().default(o)
+def storage_json_encoder(field: Any) -> Union[str, Dict[str, str]]:
+    """Specify str format for datetime objects"""
+    if isinstance(field, datetime):
+        return field.strftime("%Y-%m-%dT%H:%M:%S")
+    if isinstance(field, ObjectId):
+        return {"$oid": str(field)}
+    return field

fides/common/api/scope_registry.py

@@ -37,7 +37,6 @@ EXEC = "exec"
 FIDES_TAXONOMY = "fides_taxonomy"
 GENERATE = "generate"
 INSTANTIATE = "instantiate"
-MANUAL_STEPS = "manual-steps"
 MASKING = "masking"
 MESSAGING = "messaging"
 ORGANIZATION = "organization"
@@ -52,7 +51,6 @@ PRIVACY_REQUEST_NOTIFICATIONS = "privacy-request-notifications"
 READ = "read"
 REGISTER = "register"
 RESET = "reset"
-RESPOND = "respond"
 RESUME = "resume"
 REVIEW = "review"
 RULE = "rule"
@@ -176,8 +174,6 @@ PRIVACY_PREFERENCE_HISTORY_READ = f"{PRIVACY_PREFERENCE_HISTORY}:{READ}"
 PRIVACY_REQUEST_CALLBACK_RESUME = f"{PRIVACY_REQUEST}:{RESUME}"  # User has permission to restart a paused privacy request
 PRIVACY_REQUEST_CREATE = f"{PRIVACY_REQUEST}:{CREATE}"
 PRIVACY_REQUEST_DELETE = f"{PRIVACY_REQUEST}:{DELETE}"
-PRIVACY_REQUEST_MANUAL_STEPS_REVIEW = f"{PRIVACY_REQUEST}:{MANUAL_STEPS}:{REVIEW}"
-PRIVACY_REQUEST_MANUAL_STEPS_RESPOND = f"{PRIVACY_REQUEST}:{MANUAL_STEPS}:{RESPOND}"
 PRIVACY_REQUEST_NOTIFICATIONS_CREATE_OR_UPDATE = (
     f"{PRIVACY_REQUEST_NOTIFICATIONS}:{CREATE_OR_UPDATE}"
 )
@@ -316,8 +312,6 @@ SCOPE_DOCS = {
     PRIVACY_REQUEST_CALLBACK_RESUME: "Restart paused privacy requests",
     PRIVACY_REQUEST_READ_ACCESS_RESULTS: "Download access data for the privacy request",
     PRIVACY_REQUEST_DELETE: "Remove privacy requests",
-    PRIVACY_REQUEST_MANUAL_STEPS_RESPOND: "Respond to manual steps for the privacy request",
-    PRIVACY_REQUEST_MANUAL_STEPS_REVIEW: "Review manual steps for the privacy request",
     PRIVACY_REQUEST_NOTIFICATIONS_CREATE_OR_UPDATE: "",
     PRIVACY_REQUEST_NOTIFICATIONS_READ: "",
     PRIVACY_REQUEST_READ: "View privacy requests",

fides/config/config_proxy.py

@@ -106,6 +106,7 @@ class ExecutionSettingsProxy(ConfigProxyBase):
     subject_identity_verification_required: bool
     disable_consent_identity_verification: bool
     require_manual_request_approval: bool
+    masking_strict: bool
 
     def __getattribute__(self, name: str) -> Any:
         """

fides/config/execution_settings.py

@@ -11,6 +11,10 @@ ENV_PREFIX = "FIDES__EXECUTION__"
 class ExecutionSettings(FidesSettings):
     """Configuration settings for DSR execution."""
 
+    masking_strict: bool = Field(
+        default=True,
+        description="If set to True, only use UPDATE requests to mask data. If False, Fides will use any defined DELETE or GDPR DELETE endpoints to remove PII, which may extend beyond the specific data categories that configured in your execution policy.",
+    )
     privacy_request_delay_timeout: int = Field(
         default=3600,
         description="The amount of time to wait for actions which delay privacy requests (e.g., pre- and post-processing webhooks).",

fides/service/error_handling/error_handler.py

@@ -0,0 +1,202 @@
+from functools import wraps
+from typing import Any, Callable, Optional, TypeVar
+
+from fastapi import HTTPException
+from loguru import logger
+from starlette.status import HTTP_400_BAD_REQUEST, HTTP_422_UNPROCESSABLE_ENTITY
+
+T = TypeVar("T")
+
+
+class ErrorHandler:
+    """Utility class for handling errors consistently throughout the application.
+
+    Usage Examples:
+    -----------------------------------------------------------------------------
+
+    1. Basic Validation:
+    ```python
+    from fastapi import FastAPI
+    from fides.service.error_handling.error_handler import ErrorHandler
+
+    app = FastAPI()
+
+    @app.post("/users")
+    def create_user(age: int):
+        # Simple validation
+        ErrorHandler.validate(age >= 18, "User must be 18 or older")
+        return {"message": "User created"}
+
+    @app.get("/items/{item_id}")
+    def get_item(item_id: str):
+        # Direct error raising
+        if not item_id:
+            ErrorHandler.raise_error("Item ID is required", status_code=400)
+        return {"item_id": item_id}
+    ```
+
+    2. Exception Handling Decorator:
+    ```python
+    @app.post("/orders")
+    @ErrorHandler.handle_exceptions("Failed to create order")
+    def create_order(order_data: dict):
+        if not order_data.get("items"):
+            raise ValueError("Order must contain items")
+        # Process order...
+        return {"message": "Order created"}
+
+    @app.get("/products/{product_id}")
+    @ErrorHandler.handle_exceptions("Failed to fetch product", status_code=404)
+    def get_product(product_id: str):
+        product = database.get_product(product_id)
+        if not product:
+            raise ValueError("Product not found")
+        return product
+    ```
+
+    3. Complex Validation:
+    ```python
+    @app.post("/payments")
+    @ErrorHandler.handle_exceptions("Payment processing failed")
+    def process_payment(payment: dict):
+        # Validate amount
+        ErrorHandler.validate(
+            payment.get("amount", 0) > 0,
+            "Payment amount must be positive",
+            HTTP_400_BAD_REQUEST
+        )
+
+        # Validate currency
+        ErrorHandler.validate(
+            payment.get("currency") in ["USD", "EUR"],
+            "Invalid currency",
+            HTTP_400_BAD_REQUEST,
+            "Unsupported currency provided"  # Optional log message
+        )
+
+        # Custom error for insufficient funds
+        if payment.get("amount", 0) > get_balance():
+            ErrorHandler.raise_error(
+                "Insufficient funds",
+                status_code=HTTP_400_BAD_REQUEST,
+                log_message="User attempted payment exceeding balance"
+            )
+
+        return {"status": "payment processed"}
+    ```
+
+    4. Error Logging:
+    ```python
+    @app.post("/imports")
+    @ErrorHandler.handle_exceptions("Import failed")
+    def import_data(data: dict):
+        try:
+            process_import(data)
+        except Exception as e:
+            # Log error with custom message before raising
+            ErrorHandler.raise_error(
+                "Import failed: invalid format",
+                status_code=400,
+                log_message=f"Import failed with error: {str(e)}"
+            )
+        return {"status": "import complete"}
+    ```
+
+    Key Features:
+    - Simple validation with custom error messages
+    - Consistent error handling across endpoints
+    - Built-in error logging
+    - HTTP status code customization
+    - Exception handling decorator for common patterns
+    """
+
+    @staticmethod
+    def raise_error(
+        detail: str,
+        status_code: int = HTTP_422_UNPROCESSABLE_ENTITY,
+        log_message: Optional[str] = None,
+    ) -> None:
+        """Raise an HTTPException with consistent logging.
+
+        Args:
+            detail: Error message to include in the HTTPException
+            status_code: HTTP status code to use (default: 422)
+            log_message: Optional message to log before raising the exception
+
+        Raises:
+            HTTPException: Always raised with the provided details
+        """
+        if log_message:
+            logger.error(log_message)
+        raise HTTPException(status_code=status_code, detail=detail)
+
+    @staticmethod
+    def validate(
+        condition: bool,
+        detail: str,
+        status_code: int = HTTP_400_BAD_REQUEST,
+        log_message: Optional[str] = None,
+    ) -> None:
+        """Validate a condition and raise an error if it's False.
+
+        Args:
+            condition: The condition to check
+            detail: Error message if condition is False
+            status_code: HTTP status code to use if condition is False
+            log_message: Optional message to log before raising the exception
+
+        Raises:
+            HTTPException: If the condition is False
+        """
+        if not condition:
+            ErrorHandler.raise_error(detail, status_code, log_message)
+
+    @classmethod
+    def handle_exceptions(
+        cls, error_message: str, status_code: int = HTTP_422_UNPROCESSABLE_ENTITY
+    ) -> Callable[[Callable[..., T]], Callable[..., T]]:
+        """Decorator to handle exceptions consistently.
+
+        Args:
+            error_message: Base error message to use
+            status_code: HTTP status code to use for unexpected errors
+
+        Returns:
+            Callable: The decorated function that handles exceptions
+
+        Note:
+            This decorator will catch specific exceptions and convert them to HTTPExceptions.
+            HTTPExceptions are re-raised as is, while other exceptions are wrapped with
+            additional context.
+        """
+
+        def decorator(func: Callable[..., T]) -> Callable[..., T]:
+            @wraps(func)
+            def wrapper(*args: Any, **kwargs: Any) -> Optional[T]:
+                try:
+                    return func(*args, **kwargs)
+                except HTTPException:
+                    # Re-raise HTTP exceptions without modification
+                    raise
+                except (ValueError, TypeError, AttributeError, KeyError) as e:
+                    # Handle common validation and data access errors
+                    cls.raise_error(
+                        f"{error_message}: {str(e)}",
+                        status_code,
+                        f"{error_message}: {e}",
+                    )
+                except Exception as e:  # pylint: disable=broad-except
+                    # Log unexpected errors with full context but present a sanitized message
+                    logger.error(
+                        f"Unexpected error in {func.__name__}: {str(e)}", exc_info=True
+                    )
+                    cls.raise_error(
+                        f"{error_message}: An unexpected error occurred",
+                        status_code,
+                        f"{error_message}: Unexpected {type(e).__name__}",
+                    )
+                return None  # This line is never reached but satisfies the return type checker
+
+            return wrapper  # type: ignore[return-value]
+
+        return decorator

fides/service/messaging/aws_ses_service.py

@@ -1,5 +1,6 @@
 from typing import Any, Optional
 
+from fides.api.models.property import CONFIG
 from loguru import logger
 
 from fides.api.models.messaging import MessagingConfig
@@ -86,7 +87,10 @@ class AWS_SES_Service:
         aws_session = get_aws_session(
             auth_method=self.messaging_config_secrets.auth_method.value,
             storage_secrets=storage_secrets,  # type: ignore[arg-type]
-            assume_role_arn=self.messaging_config_secrets.aws_assume_role_arn,
+            assume_role_arn=CONFIG.credentials.get("notifications", {}).get(
+                "aws_ses_assume_role_arn"
+            )
+            or self.messaging_config_secrets.aws_assume_role_arn,
         )
         aws_ses_client = aws_session.client(
             "ses", region_name=self.messaging_config_details.aws_region

fides/ui-build/static/admin/404.html

@@ -1 +1 @@
-<!DOCTYPE html><html lang="en"><head><meta charSet="utf-8"/><meta name="viewport" content="width=device-width"/><meta name="next-head-count" content="2"/><link data-next-font="" rel="preconnect" href="/" crossorigin="anonymous"/><link rel="preload" href="/_next/static/css/1b227ba7eabbfe2f.css" as="style"/><link rel="stylesheet" href="/_next/static/css/1b227ba7eabbfe2f.css" data-n-g=""/><noscript data-n-css=""></noscript><script defer="" nomodule="" src="/_next/static/chunks/polyfills-42372ed130431b0a.js"></script><script src="/_next/static/chunks/webpack-3a61b934ba2fb620.js" defer=""></script><script src="/_next/static/chunks/framework-c92fc3344e6fd165.js" defer=""></script><script src="/_next/static/chunks/main-090643377c8254e6.js" defer=""></script><script src="/_next/static/chunks/pages/_app-f1add6386651ca3d.js" defer=""></script><script src="/_next/static/chunks/pages/404-e868487119cd14fc.js" defer=""></script><script src="/_next/static/D-B-G-FV05_6iwXWBGS0J/_buildManifest.js" defer=""></script><script src="/_next/static/D-B-G-FV05_6iwXWBGS0J/_ssgManifest.js" defer=""></script><style>.data-ant-cssinjs-cache-path{content:"";}</style></head><body><div id="__next"><div style="height:100%;display:flex"></div></div><script id="__NEXT_DATA__" type="application/json">{"props":{"pageProps":{}},"page":"/404","query":{},"buildId":"D-B-G-FV05_6iwXWBGS0J","nextExport":true,"autoExport":true,"isFallback":false,"scriptLoader":[]}</script></body></html>
+<!DOCTYPE html><html lang="en"><head><meta charSet="utf-8"/><meta name="viewport" content="width=device-width"/><meta name="next-head-count" content="2"/><link data-next-font="" rel="preconnect" href="/" crossorigin="anonymous"/><link rel="preload" href="/_next/static/css/c0c2eb63ad3e7390.css" as="style"/><link rel="stylesheet" href="/_next/static/css/c0c2eb63ad3e7390.css" data-n-g=""/><noscript data-n-css=""></noscript><script defer="" nomodule="" src="/_next/static/chunks/polyfills-42372ed130431b0a.js"></script><script src="/_next/static/chunks/webpack-abd3efcb23c0bb03.js" defer=""></script><script src="/_next/static/chunks/framework-c92fc3344e6fd165.js" defer=""></script><script src="/_next/static/chunks/main-090643377c8254e6.js" defer=""></script><script src="/_next/static/chunks/pages/_app-814e3d1cb7005cd4.js" defer=""></script><script src="/_next/static/chunks/pages/404-c00773c4c6e930af.js" defer=""></script><script src="/_next/static/W6B1Xt1795h6VsbJCzmnd/_buildManifest.js" defer=""></script><script src="/_next/static/W6B1Xt1795h6VsbJCzmnd/_ssgManifest.js" defer=""></script><style>.data-ant-cssinjs-cache-path{content:"";}</style></head><body><div id="__next"><div style="height:100%;display:flex"></div></div><script id="__NEXT_DATA__" type="application/json">{"props":{"pageProps":{}},"page":"/404","query":{},"buildId":"W6B1Xt1795h6VsbJCzmnd","nextExport":true,"autoExport":true,"isFallback":false,"scriptLoader":[]}</script></body></html>