ethyca-fides 2.62.0rc0__py2.py3-none-any.whl → 2.62.1b1__py2.py3-none-any.whl

{ethyca_fides-2.62.0rc0.dist-info → ethyca_fides-2.62.1b1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.8.0)
+Generator: setuptools (80.9.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-05-21T15:50:31-0400",
+ "date": "2025-06-02T09:59:07-0700",
  "dirty": false,
  "error": null,
- "full-revisionid": "77ac10c983eb727ff13db6b3f220d9de7e98137f",
- "version": "2.62.0rc0"
+ "full-revisionid": "d7cf6cc495ac932a4b042e8249a4a49c8ae2070c",
+ "version": "2.62.1b1"
 }
 '''  # END VERSION_JSON
 

fides/api/alembic/migrations/versions/2263583b0e44_add_shared_monitor_config.py

@@ -0,0 +1,82 @@
+"""add shared monitor config
+
+Revision ID: 2263583b0e44
+Revises: d0cbfec0b2dd
+Create Date: 2025-05-12 23:44:11.809581
+
+"""
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision = "2263583b0e44"
+down_revision = "d0cbfec0b2dd"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    op.create_table(
+        "shared_monitor_config",
+        sa.Column("id", sa.String(length=255), nullable=False),
+        sa.Column(
+            "created_at",
+            sa.DateTime(timezone=True),
+            server_default=sa.text("now()"),
+            nullable=True,
+        ),
+        sa.Column(
+            "updated_at",
+            sa.DateTime(timezone=True),
+            server_default=sa.text("now()"),
+            nullable=True,
+        ),
+        sa.Column("name", sa.String(), nullable=False),
+        sa.Column("key", sa.String(), nullable=False),
+        sa.Column("description", sa.String(), nullable=True),
+        sa.Column(
+            "classify_params",
+            postgresql.JSONB(astext_type=sa.Text()),
+            server_default="{}",
+            nullable=False,
+        ),
+        sa.PrimaryKeyConstraint("id"),
+        sa.UniqueConstraint("key"),
+    )
+    op.create_index(
+        op.f("ix_shared_monitor_config_id"),
+        "shared_monitor_config",
+        ["id"],
+        unique=False,
+    )
+    op.add_column(
+        "monitorconfig", sa.Column("shared_config_id", sa.String(), nullable=True)
+    )
+    op.create_index(
+        op.f("ix_monitorconfig_shared_config_id"),
+        "monitorconfig",
+        ["shared_config_id"],
+        unique=False,
+    )
+    op.create_foreign_key(
+        "fk_monitorconfig_shared_config_id",
+        "monitorconfig",
+        "shared_monitor_config",
+        ["shared_config_id"],
+        ["id"],
+        ondelete="RESTRICT",
+    )
+
+
+def downgrade():
+    op.drop_constraint(
+        "fk_monitorconfig_shared_config_id", "monitorconfig", type_="foreignkey"
+    )
+    op.drop_index(op.f("ix_monitorconfig_shared_config_id"), table_name="monitorconfig")
+    op.drop_column("monitorconfig", "shared_config_id")
+    op.drop_index(
+        op.f("ix_shared_monitor_config_id"), table_name="shared_monitor_config"
+    )
+    op.drop_table("shared_monitor_config")

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

@@ -120,7 +120,7 @@ from fides.api.util.collection_util import Row
 from fides.api.util.endpoint_utils import validate_start_and_end_filters
 from fides.api.util.enums import ColumnSort
 from fides.api.util.fuzzy_search_utils import get_decrypted_identities_automaton
-from fides.api.util.storage_util import storage_json_encoder
+from fides.api.util.storage_util import StorageJSONEncoder
 from fides.common.api.scope_registry import (
     PRIVACY_REQUEST_CALLBACK_RESUME,
     PRIVACY_REQUEST_CREATE,
@@ -2129,7 +2129,7 @@ def get_test_privacy_request_results(
 
     # Escape datetime and ObjectId values
     raw_data = privacy_request.get_raw_access_results()
-    escaped_json = json.dumps(raw_data, indent=2, default=storage_json_encoder)
+    escaped_json = json.dumps(raw_data, indent=2, cls=StorageJSONEncoder)
     results = json.loads(escaped_json)
 
     filtered_results: Dict[str, Any] = filter_access_results(

fides/api/models/attachment.py

@@ -12,12 +12,14 @@ from sqlalchemy.orm import Session, relationship
 
 from fides.api.db.base_class import Base
 from fides.api.schemas.storage.storage import StorageDetails, StorageType
+from fides.api.service.storage.gcs import get_gcs_client
 from fides.api.service.storage.s3 import (
     generic_delete_from_s3,
     generic_retrieve_from_s3,
     generic_upload_to_s3,
 )
-from fides.api.service.storage.util import get_local_filename
+from fides.api.service.storage.util import AllowedFileType, get_local_filename
+from fides.config import CONFIG
 
 if TYPE_CHECKING:
     from fides.api.models.comment import Comment
@@ -115,8 +117,13 @@ class Attachment(Base):
         uselist=False,
     )
 
+    @property
+    def content_type(self) -> str:
+        """Returns the content type of the attachment."""
+        return AllowedFileType[self.file_name.split(".")[-1]].value
+
     def upload(self, attachment: IO[bytes]) -> None:
-        """Uploads an attachment to S3 or local storage."""
+        """Uploads an attachment to S3, GCS, or local storage."""
         if self.config.type == StorageType.s3:
             bucket_name = f"{self.config.details[StorageDetails.BUCKET.value]}"
             auth_method = self.config.details[StorageDetails.AUTH_METHOD.value]
@@ -130,6 +137,23 @@ class Attachment(Base):
             log.info(f"Uploaded {self.file_name} to S3 bucket {bucket_name}/{self.id}")
             return
 
+        if self.config.type == StorageType.gcs:
+            bucket_name = f"{self.config.details[StorageDetails.BUCKET.value]}"
+            auth_method = self.config.details[StorageDetails.AUTH_METHOD.value]
+            storage_client = get_gcs_client(auth_method, self.config.secrets)
+            bucket = storage_client.bucket(bucket_name)
+            blob = bucket.blob(f"{self.id}/{self.file_name}")
+
+            # Reset the file pointer to the beginning
+            try:
+                attachment.seek(0)
+            except Exception as e:
+                raise ValueError(f"Failed to reset file pointer for attachment: {e}")
+
+            blob.upload_from_file(attachment)
+            log.info(f"Uploaded {self.file_name} to GCS bucket {bucket_name}/{self.id}")
+            return
+
         if self.config.type == StorageType.local:
             filename = get_local_filename(f"{self.id}/{self.file_name}")
 
@@ -164,13 +188,16 @@ class Attachment(Base):
         self,
     ) -> Tuple[int, AnyHttpUrlString]:
         """
-        Retrieves a the size of the attachment and the presigned URL to retrieve it.
+        Retrieves the size of the attachment and a presigned/signed URL.
         - For s3:
           - the size is retrieved from the s3 object metadata
-          - the presigned URL is retrieved from the s3 client
+          - returns presigned URL
+        - For gcs:
+          - the size is retrieved from the blob metadata
+          - returns signed URL
         - For local:
           - the size is retrieved from the file size
-          - the URL is the local file path
+          - returns the local file path
         """
         if self.config.type == StorageType.s3:
             bucket_name = f"{self.config.details[StorageDetails.BUCKET.value]}"
@@ -180,19 +207,81 @@ class Attachment(Base):
                 bucket_name=bucket_name,
                 file_key=f"{self.id}/{self.file_name}",
                 auth_method=auth_method,
+                get_content=False,
             )
             return size, url
 
+        if self.config.type == StorageType.gcs:
+            bucket_name = f"{self.config.details[StorageDetails.BUCKET.value]}"
+            auth_method = self.config.details[StorageDetails.AUTH_METHOD.value]
+            storage_client = get_gcs_client(auth_method, self.config.secrets)
+            bucket = storage_client.bucket(bucket_name)
+            blob = bucket.blob(f"{self.id}/{self.file_name}")
+
+            # Ensure we have the blob metadata
+            blob.reload()
+            url = blob.generate_signed_url(
+                version="v4",
+                expiration=CONFIG.security.subject_request_download_link_ttl_seconds,
+                method="GET",
+            )
+            return blob.size, url
+
+        if self.config.type == StorageType.local:
+            filename = get_local_filename(f"{self.id}/{self.file_name}")
+            size = os.path.getsize(filename)
+            return size, filename
+
+        raise ValueError(f"Unsupported storage type: {self.config.type}")
+
+    def retrieve_attachment_content(
+        self,
+    ) -> Tuple[int, bytes]:
+        """
+        Retrieves the size of the attachment and its actual content.
+        - For s3:
+          - the size is retrieved from the s3 object metadata
+          - returns the actual content
+        - For gcs:
+          - the size is retrieved from the blob metadata
+          - returns the actual content
+        - For local:
+          - the size is retrieved from the file size
+          - returns the actual content
+        """
+        if self.config.type == StorageType.s3:
+            bucket_name = f"{self.config.details[StorageDetails.BUCKET.value]}"
+            auth_method = self.config.details[StorageDetails.AUTH_METHOD.value]
+            size, content = generic_retrieve_from_s3(
+                storage_secrets=self.config.secrets,
+                bucket_name=bucket_name,
+                file_key=f"{self.id}/{self.file_name}",
+                auth_method=auth_method,
+                get_content=True,
+            )
+            return size, content
+
+        if self.config.type == StorageType.gcs:
+            bucket_name = f"{self.config.details[StorageDetails.BUCKET.value]}"
+            auth_method = self.config.details[StorageDetails.AUTH_METHOD.value]
+            storage_client = get_gcs_client(auth_method, self.config.secrets)
+            bucket = storage_client.bucket(bucket_name)
+            blob = bucket.blob(f"{self.id}/{self.file_name}")
+
+            content = blob.download_as_bytes()
+            return len(content), content
+
         if self.config.type == StorageType.local:
             filename = get_local_filename(f"{self.id}/{self.file_name}")
             with open(filename, "rb") as file:
-                size = len(file.read())
-                return size, filename
+                content = file.read()
+                size = len(content)
+                return size, content
 
         raise ValueError(f"Unsupported storage type: {self.config.type}")
 
     def delete_attachment_from_storage(self) -> None:
-        """Deletes an attachment from S3 or local storage."""
+        """Deletes an attachment from S3, GCS, or local storage."""
         if self.config.type == StorageType.s3:
             bucket_name = f"{self.config.details[StorageDetails.BUCKET.value]}"
             auth_method = self.config.details[StorageDetails.AUTH_METHOD.value]
@@ -204,9 +293,27 @@ class Attachment(Base):
             )
             return
 
+        if self.config.type == StorageType.gcs:
+            bucket_name = f"{self.config.details[StorageDetails.BUCKET.value]}"
+            auth_method = self.config.details[StorageDetails.AUTH_METHOD.value]
+            storage_client = get_gcs_client(auth_method, self.config.secrets)
+            bucket = storage_client.bucket(bucket_name)
+
+            # List and delete all blobs in the folder
+            prefix = f"{self.id}/"
+            blobs = bucket.list_blobs(prefix=prefix)
+            for blob in blobs:
+                blob.delete()
+            return
+
         if self.config.type == StorageType.local:
-            filename = get_local_filename(f"{self.id}/{self.file_name}")
-            os.remove(filename)
+            folder_path = os.path.dirname(
+                get_local_filename(f"{self.id}/{self.file_name}")
+            )
+            if os.path.exists(folder_path):
+                import shutil
+
+                shutil.rmtree(folder_path)
             return
 
         raise ValueError(f"Unsupported storage type: {self.config.type}")

fides/api/models/detection_discovery.py

@@ -9,6 +9,7 @@ from loguru import logger
 from sqlalchemy import ARRAY, Boolean, Column, DateTime, ForeignKey, String, func
 from sqlalchemy.dialects.postgresql import JSONB
 from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.ext.declarative import declared_attr
 from sqlalchemy.ext.mutable import MutableDict
 from sqlalchemy.future import select
 from sqlalchemy.orm import Session, relationship
@@ -47,6 +48,29 @@ class MonitorFrequency(Enum):
 QUARTERLY_MONTH_PATTERN = r"^\d+,\d+,\d+,\d+$"
 
 
+class SharedMonitorConfig(Base, FidesBase):
+    """SQL model for shareable monitor configurations"""
+
+    @declared_attr
+    def __tablename__(self) -> str:
+        return "shared_monitor_config"
+
+    # Basic info
+    name = Column(String, nullable=False)
+    key = Column(String, unique=True, nullable=False)
+    description = Column(String, nullable=True)
+
+    # Classification parameters (including regex patterns)
+    classify_params = Column(
+        MutableDict.as_mutable(JSONB),
+        index=False,
+        unique=False,
+        nullable=False,
+        server_default="{}",
+        default=dict,
+    )
+
+
 class MonitorConfig(Base):
     """
     Monitor configuration used for data detection and discovery.
@@ -87,7 +111,9 @@ class MonitorConfig(Base):
     )  # stores the cron-based kwargs for scheduling the monitor execution.
     # see https://apscheduler.readthedocs.io/en/3.x/modules/triggers/cron.html
 
-    classify_params = Column(
+    # We use _classify_params for the actual column to prevent direct access
+    _classify_params = Column(
+        "classify_params",
         MutableDict.as_mutable(JSONB),
         index=False,
         unique=False,
@@ -124,6 +150,45 @@ class MonitorConfig(Base):
         backref="monitor_config",
     )
 
+    shared_config_id = Column(
+        String,
+        ForeignKey(SharedMonitorConfig.id_field_path, ondelete="RESTRICT"),
+        nullable=True,
+        index=True,
+    )
+
+    shared_config = relationship(SharedMonitorConfig)
+
+    @property
+    def classify_params(self) -> dict:
+        """
+        Returns the merged classify parameters from both the monitor config and
+        the shared config (if it exists).
+
+        The shared config parameters take precedence over the monitor's own parameters,
+        but only for values that are not falsy (None, empty, etc.).
+        """
+        # Start with an empty dict
+        merged_params = {}
+
+        # Add this monitor's params if available
+        if self._classify_params:
+            merged_params.update(self._classify_params)
+
+        # Add/override with shared config params if available
+        if self.shared_config and self.shared_config.classify_params:
+            # Only update with non-falsy values from shared config
+            for key, value in self.shared_config.classify_params.items():
+                if value:  # Only override if the value is not falsy
+                    merged_params[key] = value
+
+        return merged_params
+
+    @classify_params.setter
+    def classify_params(self, value: Dict[str, Any]) -> None:
+        """Setter for the classify_params to maintain compatibility with existing code"""
+        self._classify_params = value
+
     @property
     def connection_config_key(self) -> str:
         """Derives the `connection_config_key`"""

fides/api/models/privacy_request/privacy_request.py

@@ -1089,6 +1089,46 @@ class PrivacyRequest(
         if attachment:
             attachment.delete(db)
 
+    def _get_manual_webhook_attachments(
+        self, db: Session, manual_webhook_id: str, reference_type: str
+    ) -> List[Attachment]:
+        """Helper method to get attachments that have references to both this privacy request and the specified manual webhook"""
+        query = """
+            SELECT DISTINCT a.*
+            FROM attachment a
+            INNER JOIN attachment_reference ar1 ON a.id = ar1.attachment_id
+            INNER JOIN attachment_reference ar2 ON a.id = ar2.attachment_id
+            WHERE ar1.reference_id = :privacy_request_id
+            AND ar1.reference_type = 'privacy_request'
+            AND ar2.reference_id = :manual_webhook_id
+            AND ar2.reference_type = :reference_type
+        """
+        result = db.execute(
+            query,
+            {
+                "privacy_request_id": self.id,
+                "manual_webhook_id": manual_webhook_id,
+                "reference_type": reference_type,
+            },
+        )
+        return [Attachment(**row) for row in result]
+
+    def get_access_manual_webhook_attachments(
+        self, db: Session, manual_webhook_id: str
+    ) -> List[Attachment]:
+        """Get all attachments that have references to both this privacy request and the specified access manual webhook"""
+        return self._get_manual_webhook_attachments(
+            db, manual_webhook_id, "access_manual_webhook"
+        )
+
+    def get_erasure_manual_webhook_attachments(
+        self, db: Session, manual_webhook_id: str
+    ) -> List[Attachment]:
+        """Get all attachments that have references to both this privacy request and the specified erasure manual webhook"""
+        return self._get_manual_webhook_attachments(
+            db, manual_webhook_id, "erasure_manual_webhook"
+        )
+
     def get_existing_request_task(
         self,
         db: Session,
@@ -1228,7 +1268,6 @@ class PrivacyRequest(
         """
         if not self.policy.get_rules_for_action(action_type=ActionType.access):
             return None
-
         self.filtered_final_upload = results
         self.save(db)
 

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

fides/api/service/storage/s3.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import IO, Any, Dict, Tuple
+from typing import IO, Any, Dict, Tuple, Union
 
 from boto3.s3.transfer import TransferConfig
 from botocore.exceptions import ClientError, ParamValidationError
@@ -129,25 +129,38 @@ def generic_retrieve_from_s3(
     bucket_name: str,
     file_key: str,
     auth_method: str,
-) -> Tuple[int, AnyHttpUrlString]:
+    get_content: bool = False,
+) -> Tuple[int, Union[str, bytes]]:
     """
-    Retrieves file metadata and generates a presigned URL for downloading an S3 object.
+    Retrieves a file from S3 and returns its size and either a presigned URL or the actual 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)
+    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
+
+    Returns:
+        Tuple containing (file_size, presigned_url_or_content)
     """
     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:
-        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)
+        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}")
         raise e
 
 
@@ -158,7 +171,8 @@ def generic_delete_from_s3(
     auth_method: str,
 ) -> None:
     """
-    Deletes arbitrary data from s3
+    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.
 
     :param storage_secrets: S3 storage secrets
     :param bucket_name: Name of the S3 bucket
@@ -169,6 +183,17 @@ 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

@@ -30,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 storage_json_encoder
+from fides.api.util.storage_util import StorageJSONEncoder
 from fides.config import CONFIG
 
 if TYPE_CHECKING:
@@ -75,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=storage_json_encoder)
+        json_str = json.dumps(data, indent=2, default=StorageJSONEncoder().default)
         return BytesIO(
             encrypt_access_request_results(json_str, privacy_request.id).encode(
                 CONFIG.security.encoding

fides/api/util/storage_util.py

@@ -1,5 +1,5 @@
 from datetime import datetime
-from typing import Any, Dict, Union
+from typing import Any, Union
 
 from bson import ObjectId
 from pydantic import ValidationError
@@ -11,6 +11,7 @@ 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(
@@ -48,10 +49,15 @@ def get_schema_for_secrets(
         raise ValueError(errors)
 
 
-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
+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)

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/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-371b155655c83a1e.js" defer=""></script><script src="/_next/static/chunks/pages/404-c00773c4c6e930af.js" defer=""></script><script src="/_next/static/4OMQ0x81J6D4ksHggHXOF/_buildManifest.js" defer=""></script><script src="/_next/static/4OMQ0x81J6D4ksHggHXOF/_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":"4OMQ0x81J6D4ksHggHXOF","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/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-94950df9c97cd079.js" defer=""></script><script src="/_next/static/chunks/pages/404-e868487119cd14fc.js" defer=""></script><script src="/_next/static/Sez6kqW5dI0lK60IMwICO/_buildManifest.js" defer=""></script><script src="/_next/static/Sez6kqW5dI0lK60IMwICO/_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":"Sez6kqW5dI0lK60IMwICO","nextExport":true,"autoExport":true,"isFallback":false,"scriptLoader":[]}</script></body></html>