ethyca-fides 2.73.2b0__py2.py3-none-any.whl → 2.73.2b1__py2.py3-none-any.whl

fides/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-10-30T20:40:29+0000",
+ "date": "2025-10-31T14:51:49+0000",
  "dirty": false,
  "error": null,
- "full-revisionid": "b17dcbb16dfac3ce994a9bd97fd39d126ec66d9f",
- "version": "2.73.2b0"
+ "full-revisionid": "3a382cb972e2ea964f078259f93ed9b6ea0b1d02",
+ "version": "2.73.2b1"
 }
 '''  # END VERSION_JSON
 

fides/api/alembic/migrations/versions/xx_2025_10_29_1659_80d28dea3b6b_added_duplicate_group_table.py

@@ -0,0 +1,79 @@
+"""added duplicate group table
+
+Revision ID: 80d28dea3b6b
+Revises: c09e76282dd1
+Create Date: 2025-10-29 16:59:09.551676
+
+"""
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision = "80d28dea3b6b"
+down_revision = "c09e76282dd1"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table(
+        "duplicate_group",
+        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("id", postgresql.UUID(as_uuid=True), nullable=False),
+        sa.Column("rule_version", sa.Text(), nullable=False),
+        sa.Column("is_active", sa.Boolean(), server_default="t", nullable=False),
+        sa.Column("dedup_key", sa.Text(), nullable=False),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    op.drop_index(
+        "ix_privacyrequest_duplicate_request_group_id", table_name="privacyrequest"
+    )
+    op.drop_column("privacyrequest", "duplicate_request_group_id")
+    op.add_column(
+        "privacyrequest",
+        sa.Column(
+            "duplicate_request_group_id", postgresql.UUID(as_uuid=True), nullable=True
+        ),
+    )
+    op.create_foreign_key(
+        "fk_privacyrequest_duplicate_group",
+        "privacyrequest",
+        "duplicate_group",
+        ["duplicate_request_group_id"],
+        ["id"],
+    )
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_constraint(
+        "fk_privacyrequest_duplicate_group", "privacyrequest", type_="foreignkey"
+    )
+    op.drop_column("privacyrequest", "duplicate_request_group_id")
+    op.add_column(
+        "privacyrequest",
+        sa.Column("duplicate_request_group_id", sa.String(), nullable=True),
+    )
+    op.create_index(
+        "ix_privacyrequest_duplicate_request_group_id",
+        "privacyrequest",
+        ["duplicate_request_group_id"],
+        unique=False,
+    )
+    op.drop_table("duplicate_group")
+    # ### end Alembic commands ###

fides/api/models/privacy_request/duplicate_group.py

@@ -0,0 +1,84 @@
+import hashlib
+import json
+import uuid
+from typing import TYPE_CHECKING, Any
+
+from sqlalchemy import Boolean, Column, Text
+from sqlalchemy.dialects.postgresql import UUID
+from sqlalchemy.ext.declarative import declared_attr
+from sqlalchemy.orm import Session, relationship
+
+from fides.api.db.base_class import Base  # type: ignore[attr-defined]
+from fides.config.duplicate_detection_settings import DuplicateDetectionSettings
+
+if TYPE_CHECKING:
+    from fides.api.models.privacy_request.privacy_request import PrivacyRequest
+
+
+def generate_deterministic_uuid(rule_version: str, dedup_key: str) -> uuid.UUID:
+    """Overrides the base class method to generate a deterministic group id.
+
+    The actual rule version is a hash of the duplicate detection settings config,
+    using simple examples here for illustration:
+    - under rule "email", duplicate@example.com → group A,
+    - under rule "email|phone", duplicate@example.com|1234567890 → group B.
+    - ... and so on.
+
+    No collisions, no overlap.
+    """
+    # Combine the rule version and the key into a stable hash
+    hash_input = f"{rule_version}:{dedup_key}".encode("utf-8")
+    return uuid.UUID(hashlib.md5(hash_input).hexdigest())
+
+
+def generate_rule_version(config: DuplicateDetectionSettings) -> str:
+    """Generate a stable short hash for the dedup rule config."""
+    normalized = json.dumps(config.model_dump(), sort_keys=True)
+    return hashlib.sha256(normalized.encode("utf-8")).hexdigest()[:8]
+
+
+class DuplicateGroup(Base):
+    """
+    A table for storing duplicate request group information.
+    """
+
+    @declared_attr
+    def __tablename__(self) -> str:
+        return "duplicate_group"
+
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    rule_version = Column(Text, nullable=False)
+    # TODO: The is_active column is not used yet since we are defaulting to just email for
+    # duplicate detection. When we allow users to configure the duplicate detection settings,
+    # we will need to add a way to activate/deactivate duplicate groups.
+    # This should be done by getting the previous rule version and deactivating all groups with
+    # that rule version. New groups will be created with the new rule version.
+    is_active = Column(Boolean, default=True, nullable=False)
+    dedup_key = Column(Text, nullable=False)
+    privacy_requests = relationship(
+        "PrivacyRequest",
+        back_populates="duplicate_group",
+        lazy="dynamic",
+        primaryjoin="and_(DuplicateGroup.id == PrivacyRequest.duplicate_request_group_id)",
+    )
+
+    @classmethod
+    def create(
+        cls, db: Session, *, data: dict[str, Any], check_name: bool = False
+    ) -> "DuplicateGroup":
+        """Create a new duplicate group.
+        Override the base class method to generate a deterministic group id.
+        If the group already exists, update the is_active column to True and return the group.
+        """
+        group_id = generate_deterministic_uuid(data["rule_version"], data["dedup_key"])
+        # If the group already exists, update the is_active column to True and return the group
+        duplicate_group = (
+            db.query(DuplicateGroup).filter(DuplicateGroup.id == group_id).one_or_none()
+        )
+        if duplicate_group:
+            duplicate_group.update(db, data={"is_active": True})
+            return duplicate_group
+
+        # If the group does not exist, create a new one
+        data["id"] = group_id
+        return super().create(db, data=data, check_name=check_name)

fides/api/models/privacy_request/privacy_request.py

@@ -9,7 +9,7 @@ from typing import TYPE_CHECKING, Any, Dict, List, Optional, Set, Union
 from celery.result import AsyncResult
 from loguru import logger
 from sqlalchemy import Boolean, Column, DateTime, ForeignKey, Integer, String
-from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy.dialects.postgresql import JSONB, UUID
 from sqlalchemy.ext.declarative import declared_attr
 from sqlalchemy.ext.mutable import MutableDict, MutableList
 from sqlalchemy.orm import Query, RelationshipProperty, Session, backref, relationship
@@ -69,6 +69,7 @@ from fides.api.models.pre_approval_webhook import (
     PreApprovalWebhook,
     PreApprovalWebhookReply,
 )
+from fides.api.models.privacy_request.duplicate_group import DuplicateGroup
 from fides.api.models.privacy_request.execution_log import (
     COMPLETED_EXECUTION_LOG_STATUSES,
     EXITED_EXECUTION_LOG_STATUSES,
@@ -225,7 +226,16 @@ class PrivacyRequest(
     location = Column(String, nullable=True)
 
     # Duplicate detection - group ID to link duplicates together
-    duplicate_request_group_id = Column(String, index=True, nullable=True)
+    duplicate_request_group_id = Column(
+        UUID(as_uuid=True),
+        ForeignKey("duplicate_group.id"),
+        nullable=True,
+    )
+    duplicate_group = relationship(
+        DuplicateGroup,
+        back_populates="privacy_requests",
+        uselist=False,
+    )
 
     # A PrivacyRequest can be soft deleted, so we store when it was deleted
     deleted_at = Column(DateTime(timezone=True), nullable=True)

fides/api/schemas/privacy_request.py

@@ -1,6 +1,7 @@
 from datetime import datetime
 from enum import Enum as EnumType
 from typing import Any, Dict, List, Optional, Type, Union
+from uuid import UUID
 
 from fideslang.validation import FidesKey
 from pydantic import ConfigDict, Field, field_serializer, field_validator
@@ -343,7 +344,7 @@ class PrivacyRequestResponse(FidesSchema):
     deleted_by: Optional[str] = None
     finalized_at: Optional[datetime] = None
     finalized_by: Optional[str] = None
-    duplicate_request_group_id: Optional[str] = None
+    duplicate_request_group_id: Optional[UUID] = None
 
     model_config = ConfigDict(from_attributes=True, use_enum_values=True)
 

fides/api/service/async_dsr/strategies/async_dsr_strategy_polling.py

@@ -551,13 +551,20 @@ class AsyncPollingStrategy(AsyncDSRStrategy):
                 self.result_request.result_path,
             )
 
-        # Ensure we have the expected polling result type
-        if not isinstance(polling_result, PollingResult):
-            raise PrivacyRequestError("Polling result must be PollingResult instance")
-
-        # Store results on the sub-request
-        self._store_sub_request_result(polling_result, sub_request, polling_task)
+        # Checks if we have a polling result, response could be empty in case there was no data to access
+        if polling_result:
+            # Ensure we have the expected polling result type
+            if not isinstance(polling_result, PollingResult):
+                raise PrivacyRequestError(
+                    "Polling result must be PollingResult instance"
+                )
 
+            # Store results on the sub-request
+            self._store_sub_request_result(polling_result, sub_request, polling_task)
+        else:
+            logger.info(
+                f"No result response for sub-request {sub_request.id} for task {polling_task.id}"
+            )
         # Mark as complete using existing method
         sub_request.update_status(self.session, ExecutionLogStatus.complete.value)
 

fides/api/service/privacy_request/duplication_detection.py

@@ -0,0 +1,357 @@
+from datetime import datetime, timedelta, timezone
+from typing import Optional
+
+from loguru import logger
+from sqlalchemy.orm import Session
+
+from fides.api.models.privacy_request.duplicate_group import (
+    DuplicateGroup,
+    generate_rule_version,
+)
+from fides.api.models.privacy_request.privacy_request import PrivacyRequest
+from fides.api.schemas.policy import ActionType
+from fides.api.schemas.privacy_request import PrivacyRequestStatus
+from fides.api.task.conditional_dependencies.schemas import (
+    Condition,
+    ConditionGroup,
+    ConditionLeaf,
+    GroupOperator,
+    Operator,
+)
+from fides.api.task.conditional_dependencies.sql_translator import (
+    SQLConditionTranslator,
+)
+from fides.config.duplicate_detection_settings import DuplicateDetectionSettings
+
+ACTIONED_REQUEST_STATUSES = [
+    PrivacyRequestStatus.approved,
+    PrivacyRequestStatus.in_processing,
+    PrivacyRequestStatus.complete,
+    PrivacyRequestStatus.requires_manual_finalization,
+    PrivacyRequestStatus.requires_input,
+    PrivacyRequestStatus.paused,
+    PrivacyRequestStatus.awaiting_email_send,
+    PrivacyRequestStatus.error,
+]
+
+
+class DuplicateDetectionService:
+    def __init__(self, db: Session):
+        self.db = db
+
+    def _create_identity_conditions(
+        self, current_request: PrivacyRequest, config: DuplicateDetectionSettings
+    ) -> list[Condition]:
+        """Creates conditions for matching identity fields.
+
+        For identity field matching using the EAV pattern in ProvidedIdentity, we need to match both field_name
+        and hashed_value. This function creates the required nested conditions for each identity field.
+        Also adds a condition for the policy_id to ensure that we are only matching requests for the same policy.
+        """
+        conditions: list[Condition] = []
+        current_identities: dict[str, str] = {
+            pi.field_name: pi.hashed_value
+            for pi in current_request.provided_identities  # type: ignore [attr-defined]
+            if pi.field_name in config.match_identity_fields
+        }
+        if len(current_identities) != len(config.match_identity_fields):
+            missing_fields = [
+                field
+                for field in config.match_identity_fields
+                if field not in current_identities.keys()
+            ]
+            logger.debug(
+                f"Some identity fields were not found in the current request: {missing_fields}"
+            )
+            return []
+
+        for field_name, hashed_value in current_identities.items():
+            identity_condition = ConditionGroup(
+                logical_operator=GroupOperator.and_,
+                conditions=[
+                    ConditionLeaf(
+                        field_address="privacyrequest.provided_identities.field_name",
+                        operator=Operator.eq,
+                        value=field_name,
+                    ),
+                    ConditionLeaf(
+                        field_address="privacyrequest.provided_identities.hashed_value",
+                        operator=Operator.eq,
+                        value=hashed_value,
+                    ),
+                ],
+            )
+            conditions.append(identity_condition)
+        policy_condition = ConditionLeaf(
+            field_address="privacyrequest.policy_id",
+            operator=Operator.eq,
+            value=current_request.policy_id,
+        )
+        conditions.append(policy_condition)
+        return conditions
+
+    def _create_time_window_condition(self, time_window_days: int) -> Condition:
+        """Creates a condition for matching requests within a time window."""
+        cutoff_date = datetime.now(timezone.utc) - timedelta(days=time_window_days)
+        condition = ConditionLeaf(
+            field_address="privacyrequest.created_at",
+            operator=Operator.gte,
+            value=cutoff_date.isoformat(),
+        )
+        return condition
+
+    def create_duplicate_detection_conditions(
+        self,
+        current_request: PrivacyRequest,
+        config: DuplicateDetectionSettings,
+    ) -> Optional[ConditionGroup]:
+        """
+        Create conditions for duplicate detection based on configuration.
+
+        Args:
+            current_request: The current privacy request to find duplicates for
+            config: Duplicate detection configuration settings
+
+        Returns:
+            A ConditionGroup with AND operator, or None if no conditions can be created
+        """
+        if len(config.match_identity_fields) == 0:
+            return None
+
+        identity_conditions = self._create_identity_conditions(current_request, config)
+        if not identity_conditions:
+            return None  # Only proceed if we have identity conditions
+
+        time_window_condition = self._create_time_window_condition(
+            config.time_window_days
+        )
+
+        # Combine all conditions with AND operator
+        all_conditions: list[Condition] = [*identity_conditions, time_window_condition]
+        return ConditionGroup(
+            logical_operator=GroupOperator.and_, conditions=all_conditions
+        )
+
+    def find_duplicate_privacy_requests(
+        self,
+        current_request: PrivacyRequest,
+        config: DuplicateDetectionSettings,
+    ) -> list[PrivacyRequest]:
+        """
+        Find potential duplicate privacy requests based on duplicate detection configuration.
+
+        Uses the SQLConditionTranslator to build queries from conditions, which handles
+        the ProvidedIdentity relationship using SQLAlchemy's .any() method.
+
+        Args:
+            current_request: The privacy request to check for duplicates
+            config: Duplicate detection configuration settings
+
+        Returns:
+            List of PrivacyRequest objects that match the duplicate criteria,
+            does not include the current request
+        """
+        condition = self.create_duplicate_detection_conditions(current_request, config)
+
+        if condition is None:
+            return []
+
+        translator = SQLConditionTranslator(self.db)
+        query = translator.generate_query_from_condition(condition)
+
+        query = query.filter(PrivacyRequest.id != current_request.id)
+        return query.all()
+
+    def generate_dedup_key(
+        self, request: PrivacyRequest, config: DuplicateDetectionSettings
+    ) -> str:
+        """
+        Generate a dedup key for a request based on the duplicate detection settings.
+        """
+        current_identities: dict[str, str] = {
+            pi.field_name: pi.hashed_value
+            for pi in request.provided_identities  # type: ignore [attr-defined]
+            if pi.field_name in config.match_identity_fields
+        }
+        if len(current_identities) != len(config.match_identity_fields):
+            raise ValueError(
+                "This request does not contain the required identity fields for duplicate detection."
+            )
+        return "|".join(
+            [
+                current_identities[field]
+                for field in sorted(config.match_identity_fields)
+            ]
+        )
+
+    def verified_identity_cases(
+        self, request: PrivacyRequest, duplicates: list[PrivacyRequest]
+    ) -> bool:
+        """
+        Apply verified identity rules to determine if a request is a duplicate request.
+        - If this request does not have a verified identity, it may be a duplicate if another request in the group is verified.
+        - If this is the first request to be verified, it is not a duplicate request
+        - If other requests identities were verified before this request, it is a duplicate request
+        Args:
+            request: The privacy request to check
+            duplicates: The list of duplicate requests
+
+        Returns:
+            True if the request is a duplicate request, False otherwise
+        """
+        verified_in_group = [
+            duplicate for duplicate in duplicates if duplicate.identity_verified_at
+        ]
+
+        # The request identity is not verified.
+        if not request.identity_verified_at:
+            if len(verified_in_group) > 0:
+                logger.debug(
+                    f"Request {request.id} is a duplicate: it is not verified and duplicating verified request(s) {verified_in_group}."
+                )
+                return True
+
+            min_created_at = min(
+                (d.created_at for d in duplicates if d.created_at), default=None
+            ) or datetime.now(timezone.utc)
+            request_created_at = (
+                request.created_at
+                if request.created_at is not None
+                else datetime.now(timezone.utc)
+            )
+            if request_created_at < min_created_at:
+                logger.debug(
+                    f"Request {request.id} is not a duplicate: it is the first request to be created in the group."
+                )
+                return False
+            logger.debug(
+                f"Request {request.id} is a duplicate: it is not verified and is not the first request to be created in the group."
+            )
+            return True
+
+        # The request identity is verified.
+        if not verified_in_group:
+            logger.debug(
+                f"Request {request.id} is not a duplicate: it is verified and no other requests in the group are verified."
+            )
+            return False
+
+        # If this request is the first with a verified identity, it is not a duplicate.
+        min_verified_at = min(
+            (d.identity_verified_at for d in duplicates if d.identity_verified_at),
+            default=None,
+        ) or datetime.now(timezone.utc)
+        request_verified_at = (
+            request.identity_verified_at
+            if request.identity_verified_at is not None
+            else datetime.now(timezone.utc)
+        )
+        if request_verified_at < min_verified_at:
+            logger.debug(
+                f"Request {request.id} is not a duplicate: it is the first request to be verified in the group."
+            )
+            return False
+        logger.debug(
+            f"Request {request.id} is a duplicate: it is verified but not the first request to be verified in the group."
+        )
+        return True
+
+    # pylint: disable=too-many-return-statements
+    def is_duplicate_request(
+        self, request: PrivacyRequest, config: DuplicateDetectionSettings
+    ) -> bool:
+        """
+        Determine if a request is a duplicate request and assigns a duplicate request group id.
+
+        The hierarchy is:
+        1. Actioned requests: if this request duplicates an actioned request, it is a duplicate.
+        2. Verified identity requests:
+          a. if this request has a verified identity:
+            - If none of the duplicates have a verified identity, it is not a duplicate.
+            - If duplicates have verified identities, but this request is the first with a verified identity, it is not a duplicate.
+          b. if this request does not have a verified identity:
+            - If no duplicates have a verified identity, and this was the first created request, it is not a duplicate.
+        3. First created request: if this is the first created request in the group, it is not a duplicate.
+        4. If no canonical requests are found (meaning all requests are marked as duplicates), this request is not a duplicate.
+            - Could occur if configuration changes and previous requests were already marked as duplicates.
+
+        Args:
+            request: The privacy request to check
+            config: Duplicate detection configuration settings
+        Returns:
+            True if the request is a duplicate request, False otherwise
+        """
+        duplicates = self.find_duplicate_privacy_requests(request, config)
+        rule_version = generate_rule_version(config)
+        try:
+            dedup_key = self.generate_dedup_key(request, config)
+        except ValueError as e:
+            logger.debug(f"Request {request.id} is not a duplicate: {e}")
+            return False
+
+        _, duplicate_group = DuplicateGroup.get_or_create(
+            db=self.db, data={"rule_version": rule_version, "dedup_key": dedup_key}
+        )
+        if duplicate_group is None:
+            logger.error(
+                f"Failed to create duplicate group for request {request.id} with dedup key {dedup_key}"
+            )
+            return False
+        logger.info(
+            f"Duplicate group {duplicate_group.id} created for request {request.id} with dedup key {dedup_key}"
+        )
+        request.update(
+            db=self.db, data={"duplicate_request_group_id": duplicate_group.id}
+        )
+
+        # if this is the only request in the group, it is not a duplicate
+        if len(duplicates) == 0:
+            logger.debug(
+                f"Request {request.id} is not a duplicate: no matching requests were found."
+            )
+            return False
+
+        if request.status == PrivacyRequestStatus.duplicate:
+            logger.warning(
+                f"Request {request.id} is a duplicate request that was requeued. This should not happen."
+            )
+            request.add_error_execution_log(
+                db=self.db,
+                connection_key=None,
+                dataset_name="Duplicate Request Detection",
+                collection_name=None,
+                message=f"Request {request.id} is a duplicate request that was requeued. This should not happen.",
+                action_type=(
+                    request.policy.get_action_type()  # type: ignore [arg-type]
+                    if request.policy
+                    else ActionType.access
+                ),
+            )
+            return True
+
+        # only compare to non-duplicate requests for the following cases
+        canonical_requests = [
+            duplicate
+            for duplicate in duplicates
+            if duplicate.status != PrivacyRequestStatus.duplicate
+        ]
+        # If no non-duplicate requests are found, this request is not a duplicate.
+        if len(canonical_requests) == 0:
+            logger.debug(
+                f"Request {request.id} is not a duplicate: all matching requests have been marked as duplicate requests."
+            )
+            return False
+
+        # If any requests in group are actioned, this request is a duplicate.
+        actioned_in_group = [
+            duplicate
+            for duplicate in canonical_requests
+            if duplicate.status in ACTIONED_REQUEST_STATUSES
+        ]
+        if len(actioned_in_group) > 0:
+            logger.debug(
+                f"Request {request.id} is a duplicate: it is duplicating actioned request(s) {actioned_in_group}."
+            )
+            return True
+        # Check against verified identity rules.
+        return self.verified_identity_cases(request, canonical_requests)

fides/api/service/saas_request/saas_request_override_factory.py

@@ -1,6 +1,6 @@
 from enum import Enum
 from inspect import Signature, signature
-from typing import TYPE_CHECKING, Callable, Dict, List, Union
+from typing import TYPE_CHECKING, Callable, Dict, List, Optional, Union
 
 from loguru import logger
 
@@ -319,7 +319,12 @@ def validate_polling_result_override_function(f: Callable) -> None:
 
     # Check return type annotation - handle both direct class and string literals
     return_annotation = sig.return_annotation
-    if return_annotation not in (PollingResult, "PollingResult"):
+    if return_annotation not in (
+        PollingResult,
+        "PollingResult",
+        Optional[PollingResult],
+        "Optional[PollingResult]",
+    ):
         raise InvalidSaaSRequestOverrideException(
             "Polling result override function must return a PollingResult"
         )

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/d78390d6134d8328.css" as="style"/><link rel="stylesheet" href="/_next/static/css/d78390d6134d8328.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-c2c11809187b9f84.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-ee588a308812715d.js" defer=""></script><script src="/_next/static/chunks/pages/404-eb019192ce498f32.js" defer=""></script><script src="/_next/static/wCNFtmYQhEDMaMPeBB4BM/_buildManifest.js" defer=""></script><script src="/_next/static/wCNFtmYQhEDMaMPeBB4BM/_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":"wCNFtmYQhEDMaMPeBB4BM","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/d78390d6134d8328.css" as="style"/><link rel="stylesheet" href="/_next/static/css/d78390d6134d8328.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-d8c0ff59e7dbc75d.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-2986534ccbf5e4a5.js" defer=""></script><script src="/_next/static/chunks/pages/404-e30ec05084303d6b.js" defer=""></script><script src="/_next/static/wfI6N9ecEPXinU3OlxHLy/_buildManifest.js" defer=""></script><script src="/_next/static/wfI6N9ecEPXinU3OlxHLy/_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":"wfI6N9ecEPXinU3OlxHLy","nextExport":true,"autoExport":true,"isFallback":false,"scriptLoader":[]}</script></body></html>