ethyca-fides 2.68.0rc3__py2.py3-none-any.whl → 2.68.1b1__py2.py3-none-any.whl

fides/api/task/manual/manual_task_conditional_evaluation.py

@@ -0,0 +1,193 @@
+from typing import Any, Optional
+
+from pydantic.v1.utils import deep_update
+from sqlalchemy.orm import Session
+
+from fides.api.graph.config import CollectionAddress, FieldAddress
+from fides.api.models.manual_task import ManualTask
+from fides.api.models.manual_task.conditional_dependency import (
+    ManualTaskConditionalDependency,
+)
+from fides.api.task.conditional_dependencies.evaluator import ConditionEvaluator
+from fides.api.task.conditional_dependencies.schemas import EvaluationResult
+from fides.api.util.collection_util import Row
+
+
+def extract_conditional_dependency_data_from_inputs(
+    *inputs: list[Row], manual_task: ManualTask, input_keys: list[CollectionAddress]
+) -> dict[str, Any]:
+    """
+    Extract data for conditional dependency field addresses from input data.
+
+    This method processes data from upstream regular tasks that provide fields
+    referenced in manual task conditional dependencies. It extracts the relevant
+    field values and makes them available for conditional dependency evaluation.
+
+    Args:
+        *inputs: Input data from upstream nodes (regular tasks)
+        manual_task: Manual task to extract conditional dependencies from
+
+    Returns:
+        Dictionary mapping field addresses to their values from input data
+    """
+
+    conditional_data: dict[str, Any] = {}
+
+    # Get all conditional dependencies field addresses
+    field_addresses = [
+        dependency.field_address
+        for dependency in manual_task.conditional_dependencies
+        if dependency.field_address
+    ]
+
+    # if no field addresses, return empty conditional data
+    # This will allow the manual task to be executed if there are no conditional dependencies
+    if not field_addresses:
+        return conditional_data
+
+    # For manual tasks, we need to preserve the original field names from conditional dependencies
+    # Instead of using pre_process_input_data which consolidates fields, we'll extract directly
+    # from the raw input data based on the execution node's input_keys
+
+    # Create a mapping between collections and their input data
+    # Convert CollectionAddress objects to strings for consistent key types
+    collection_data_map = {
+        str(collection_key): input_data
+        for collection_key, input_data in zip(input_keys, inputs)
+    }
+
+    # Extract data for each conditional dependency field address
+    for field_address in field_addresses:
+        source_collection_key, field_path = parse_field_address(field_address)
+
+        # Find the input data for this collection
+        field_value = None
+        input_data = collection_data_map.get(source_collection_key)
+        if input_data:
+
+            # Look for the field in the input data
+            for row in input_data:
+
+                # Traverse the nested field path to get the actual value
+                field_value = extract_nested_field_value(row, field_path)
+
+                if field_value is not None:
+                    break
+            # Found the field value, break out of the inner loop (over rows)
+            # but continue with the outer loop to process this field
+
+        # Always include the field in conditional_data, even if value is None
+        # This allows conditional dependencies to evaluate existence, non-existence, and falsy values
+        nested_data = set_nested_value(field_address, field_value)
+        conditional_data = deep_update(conditional_data, nested_data)
+
+    return conditional_data
+
+
+def parse_field_address(field_address: str) -> tuple[str, list[str]]:
+    """
+    Parse a field address into dataset, collection, and field path.
+
+    For complex addresses with > 2 colons, uses manual string parsing.
+    For simple addresses with ≤ 2 colons, uses FieldAddress.from_string().
+    """
+    if field_address.count(":") > 2:
+        # Parse manually: dataset:collection:field:subfield -> dataset, collection, [field, subfield]
+        dataset, collection, *field_path = field_address.split(":")
+        source_collection_key = f"{dataset}:{collection}"
+    else:
+        # Use standard FieldAddress parsing for simple cases
+        field_address_obj = FieldAddress.from_string(field_address)
+        source_collection_key = str(field_address_obj.collection_address())
+        field_path = list(field_address_obj.field_path.levels)
+    return source_collection_key, field_path
+
+
+def extract_nested_field_value(data: Any, field_path: list[str]) -> Any:
+    """
+    Extract a nested field value by traversing the field path.
+
+    Args:
+        data: The data to extract from (usually a dict)
+        field_path: List of field names to traverse (e.g., ["profile", "preferences", "theme"])
+
+    Returns:
+        The value at the end of the field path, or None if not found
+    """
+    if not field_path:
+        return data
+
+    current = data
+    for field_name in field_path:
+        if isinstance(current, dict) and field_name in current:
+            current = current[field_name]
+        else:
+            return None
+
+    return current
+
+
+def set_nested_value(field_address: str, value: Any) -> dict[str, Any]:
+    """
+    Set a field value in the conditional data structure.
+
+    Args:
+        field_address: Colon-separated field address (e.g., "dataset:collection:field" or "dataset:collection:nested:field")
+        value: The value to set
+
+    Returns:
+        Dictionary with the field value set at the specified path
+    """
+    # For conditional dependencies, we want to set the field value directly
+    # The field_address format is "dataset:collection:field" or "dataset:collection:nested:field"
+    # We want to create: {dataset: {collection: {field: value}}} or {dataset: {collection: {nested: {field: value}}}}
+    parts = field_address.split(":")
+
+    if len(parts) >= 3:
+        dataset, collection = parts[0], parts[1]
+        # Handle nested field paths beyond the first 3 parts
+        if len(parts) == 3:
+            # Simple case: dataset:collection:field
+            field = parts[2]
+            return {dataset: {collection: {field: value}}}
+
+        # Nested case: dataset:collection:nested:field
+        # Build the nested structure from the remaining parts
+        nested_structure = value
+        for part in reversed(parts[2:]):
+            nested_structure = {part: nested_structure}
+        return {dataset: {collection: nested_structure}}
+
+    # Fallback for unexpected formats
+    return {field_address: value}
+
+
+def evaluate_conditional_dependencies(
+    db: Session, manual_task: ManualTask, conditional_data: dict[str, Any]
+) -> Optional[EvaluationResult]:
+    """
+    Evaluate conditional dependencies for a manual task using data from regular tasks.
+
+    This method evaluates whether a manual task should be executed based on its
+    conditional dependencies and the data received from upstream regular tasks.
+
+    Args:
+        manual_task: The manual task to evaluate
+        conditional_data: Data from regular tasks for conditional dependency fields
+
+    Returns:
+        EvaluationResult object containing detailed information about which conditions
+        were met or not met, or None if no conditional dependencies exist
+    """
+    # Get the root condition for this manual task
+    root_condition = ManualTaskConditionalDependency.get_root_condition(
+        db, manual_task.id
+    )
+
+    if not root_condition:
+        # No conditional dependencies - always execute
+        return None
+
+    # Evaluate the condition using the data from regular tasks
+    evaluator = ConditionEvaluator(db)
+    return evaluator.evaluate_rule(root_condition, conditional_data)

fides/api/task/manual/manual_task_graph_task.py

@@ -1,7 +1,7 @@
 from typing import Any, Optional
 
 from loguru import logger
-from sqlalchemy.orm import Session
+from pydantic.v1.utils import deep_update
 
 from fides.api.common_exceptions import AwaitingAsyncTaskCallback
 from fides.api.models.attachment import AttachmentType
@@ -15,13 +15,23 @@ from fides.api.models.manual_task import (
     StatusType,
 )
 from fides.api.models.privacy_request import PrivacyRequest
+from fides.api.models.worker_task import ExecutionLogStatus
 from fides.api.schemas.policy import ActionType
 from fides.api.schemas.privacy_request import PrivacyRequestStatus
+from fides.api.task.conditional_dependencies.logging_utils import (
+    format_evaluation_failure_message,
+    format_evaluation_success_message,
+)
 from fides.api.task.graph_task import GraphTask, retry
 from fides.api.task.manual.manual_task_address import ManualTaskAddress
+from fides.api.task.manual.manual_task_conditional_evaluation import (
+    evaluate_conditional_dependencies,
+    extract_conditional_dependency_data_from_inputs,
+)
 from fides.api.task.manual.manual_task_utils import (
     get_manual_task_for_connection_config,
 )
+from fides.api.task.task_resources import TaskResources
 from fides.api.util.collection_util import Row
 from fides.api.util.storage_util import format_size
 
@@ -29,88 +39,225 @@ from fides.api.util.storage_util import format_size
 class ManualTaskGraphTask(GraphTask):
     """GraphTask implementation for ManualTask execution"""
 
+    # class level constants
+    DRY_RUN_PLACEHOLDER_VALUE = 1
+
+    def __init__(self, resources: TaskResources) -> None:
+        super().__init__(resources)
+        self.connection_key = ManualTaskAddress.get_connection_key(
+            self.execution_node.address
+        )
+
+    # ------------------------------------------------------------------------------------------------
+    # Public methods
+    # ------------------------------------------------------------------------------------------------
+
+    def dry_run_task(self) -> int:
+        """Return estimated row count for dry run - manual tasks don't have predictable counts"""
+        return self.DRY_RUN_PLACEHOLDER_VALUE
+
     @retry(action_type=ActionType.access, default_return=[])
     def access_request(self, *inputs: list[Row]) -> list[Row]:
+        """
+        Execute manual task logic following the standard GraphTask pattern.
+        Calls _run_request with ACCESS configs.
+        Returns data if submitted, raise AwaitingAsyncTaskCallback if not
+        """
+        result = self._run_request(
+            ManualTaskConfigurationType.access_privacy_request,
+            ActionType.access,
+            *inputs,
+        )
+        if result is None:
+            # Conditional skip or not applicable already logged upstream; do not mark complete here
+            return []
+
+        # We are picking up after awaiting input and have provided data – mark complete with record count
+        self.log_end(ActionType.access, record_count=len(result))
+        return result
+
+    # Provide erasure support for manual tasks
+    @retry(action_type=ActionType.erasure, default_return=0)
+    def erasure_request(
+        self,
+        retrieved_data: list[Row],  # This is not used for manual tasks.
+        *erasure_prereqs: int,  # noqa: D401, pylint: disable=unused-argument # TODO Remove when we stop support for DSR 2.0
+        inputs: Optional[list[list[Row]]] = None,
+    ) -> int:
+        """Execute manual-task-driven erasure logic.
+        Calls _run_request with ERASURE configs.
+
+        Mirrors access_request behaviour but returns the number of rows masked (always 0)
+        once all required manual task submissions are present. If submissions are
+        incomplete the privacy request is paused awaiting user input.
+        Returns the number of rows masked (always 0)
+        Raises AwaitingAsyncTaskCallback if data is not submitted
+        """
+        if not inputs:
+            inputs = []
+        result = self._run_request(
+            ManualTaskConfigurationType.erasure_privacy_request,
+            ActionType.erasure,
+            *inputs,
+        )
+        if result is None:
+            # Conditional skip or not applicable already logged upstream; do not mark complete here
+            return 0
+
+        # Mark rows_masked = 0 (manual tasks do not mask data directly)
+        if self.request_task.id:
+            # Storing result for DSR 3.0; SQLAlchemy column typing triggers mypy warning
+            self.request_task.rows_masked = 0  # type: ignore[assignment]
+
+        # Picking up after awaiting input, mark erasure node complete with rows masked count (always 0)
+        self.log_end(ActionType.erasure, record_count=0)
+        return 0
+
+    # ------------------------------------------------------------------------------------------------
+    # Private methods
+    # ------------------------------------------------------------------------------------------------
+
+    def _run_request(
+        self,
+        config_type: ManualTaskConfigurationType,
+        action_type: ActionType,
+        *inputs: list[Row],
+    ) -> Optional[list[Row]]:
         """
         Execute manual task logic following the standard GraphTask pattern:
         1. Create ManualTaskInstances if they don't exist
-        2. Check for submissions
+        2. Check if all required submissions are present
         3. Return data if submitted, raise AwaitingAsyncTaskCallback if not
         """
-        db = self.resources.session
-        collection_address = self.execution_node.address
+        manual_task = self._get_manual_task_or_none()
+        if manual_task is None:
+            return None
 
-        # Verify this is a manual task address
-        if not ManualTaskAddress.is_manual_task_address(collection_address):
-            raise ValueError(f"Invalid manual task address: {collection_address}")
+        # Complete a series of checks to determine if the manual task should be executed
+        # If any of these checks fail, complete immediately or mark as skipped
 
-        connection_key = ManualTaskAddress.get_connection_key(collection_address)
+        # Check if any eligible manual tasks have applicable configs
+        if not self._check_manual_task_configs(manual_task, config_type, action_type):
+            return None
 
-        # Get manual tasks for this connection
-        manual_task = get_manual_task_for_connection_config(db, connection_key)
+        # Check if there are any rules for this action type
+        if not self.resources.request.policy.get_rules_for_action(
+            action_type=action_type
+        ):
+            return None
 
-        if not manual_task:
-            return []
+        # Extract conditional dependency data from inputs
+        conditional_data = extract_conditional_dependency_data_from_inputs(
+            *inputs, manual_task=manual_task, input_keys=self.execution_node.input_keys
+        )
+        # Evaluate conditional dependencies
+        evaluation_result = evaluate_conditional_dependencies(
+            self.resources.session, manual_task, conditional_data=conditional_data
+        )
+        detailed_message: Optional[str] = None
+        # if there were conditional dependencies and they were not met,
+        # clean up any existing ManualTaskInstances and return None to cause a skip
+        if evaluation_result is not None and not evaluation_result.result:
+            self._cleanup_manual_task_instances(manual_task, self.resources.request)
+            detailed_message = format_evaluation_failure_message(evaluation_result)
+            self.update_status(
+                f"Manual task conditional dependencies not met. {detailed_message}",
+                [],
+                ActionType(self.resources.privacy_request_task.action_type),
+                ExecutionLogStatus.skipped,
+            )
+            return None
 
-        # Check if any manual tasks have ACCESS configs
-        # TODO: This will be changed with Manual Task Dependencies Implementation.
+        # Check/Create manual task instances for applicable configs only
+        self._ensure_manual_task_instances(
+            manual_task,
+            self.resources.request,
+            config_type,
+        )
 
+        # Check if all manual task instances have submissions for applicable configs only
+        # No separate pending log; include details in the awaiting-processing log
+        if evaluation_result:
+            detailed_message = format_evaluation_success_message(evaluation_result)
+        result = self._set_submitted_data_or_raise_awaiting_async_task_callback(
+            manual_task,
+            config_type,
+            action_type,
+            conditional_data=conditional_data,
+            awaiting_detail_message=detailed_message,
+        )
+        return result
+
+    def _check_manual_task_configs(
+        self,
+        manual_task: ManualTask,
+        config_type: ManualTaskConfigurationType,
+        action_type: ActionType,
+    ) -> bool:
         has_access_configs = [
             config
             for config in manual_task.configs
-            if config.is_current
-            and config.config_type == ManualTaskConfigurationType.access_privacy_request
+            if config.is_current and config.config_type == config_type
         ]
 
         if not has_access_configs:
             # No access configs - complete immediately
-            self.log_end(ActionType.access)
-            return []
+            self.log_end(action_type)
+            return False
 
-        if not self.resources.request.policy.get_rules_for_action(
-            action_type=ActionType.access
-        ):
-            # TODO: This will be changed with Manual Task Dependencies Implementation.
-            self.log_end(ActionType.access)
-            return []
+        return True
 
-        # Check/create manual task instances for ACCESS configs only
-        self._ensure_manual_task_instances(
-            db,
-            manual_task,
-            self.resources.request,
-            ManualTaskConfigurationType.access_privacy_request,
+    def _get_manual_task_or_none(self) -> Optional[ManualTask]:
+        # Verify this is a manual task address
+        if not ManualTaskAddress.is_manual_task_address(self.execution_node.address):
+            raise ValueError(
+                f"Invalid manual task address: {self.execution_node.address}"
+            )
+
+        # Get the manual task for this connection config (1:1 relationship)
+        manual_task = get_manual_task_for_connection_config(
+            self.resources.session, self.connection_key
         )
+        return manual_task
 
+    def _set_submitted_data_or_raise_awaiting_async_task_callback(
+        self,
+        manual_task: ManualTask,
+        config_type: ManualTaskConfigurationType,
+        action_type: ActionType,
+        conditional_data: Optional[dict[str, Any]] = None,
+        awaiting_detail_message: Optional[str] = None,
+    ) -> Optional[list[Row]]:
+        """
+        Set submitted data for a manual task and raise AwaitingAsyncTaskCallback if all instances are not completed
+        """
         # Check if all manual task instances have submissions for ACCESS configs only
         submitted_data = self._get_submitted_data(
-            db,
             manual_task,
             self.resources.request,
-            ManualTaskConfigurationType.access_privacy_request,
+            config_type,
+            conditional_data=conditional_data,
         )
 
         if submitted_data is not None:
             result: list[Row] = [submitted_data] if submitted_data else []
             self.request_task.access_data = result
 
-            # Mark request task as complete and write execution log
-            self.log_end(ActionType.access)
             return result
 
         # Set privacy request status to requires_input if not already set
         if self.resources.request.status != PrivacyRequestStatus.requires_input:
             self.resources.request.status = PrivacyRequestStatus.requires_input
-            self.resources.request.save(db)
+            self.resources.request.save(self.resources.session)
 
-        # This should trigger log_awaiting_processing via the @retry decorator
-        raise AwaitingAsyncTaskCallback(
-            f"Manual task for {connection_key} requires user input"
-        )
+        # This will trigger log_awaiting_processing via the @retry decorator; include conditional details
+        base_msg = f"Manual task for {self.connection_key} requires user input"
+        if awaiting_detail_message:
+            base_msg = f"{base_msg}. {awaiting_detail_message}"
+        raise AwaitingAsyncTaskCallback(base_msg)
 
     def _ensure_manual_task_instances(
         self,
-        db: Session,
         manual_task: ManualTask,
         privacy_request: PrivacyRequest,
         allowed_config_type: "ManualTaskConfigurationType",
@@ -139,6 +286,7 @@ class ManualTaskGraphTask(GraphTask):
 
         # If no existing instances, create a new one for the current config
         # There will only be one config of each type per manual task
+        # Sort by version descending to get the latest version first
         config = next(
             (
                 config
@@ -154,7 +302,7 @@ class ManualTaskGraphTask(GraphTask):
 
         if config:
             ManualTaskInstance.create(
-                db=db,
+                db=self.resources.session,
                 data={
                     "task_id": manual_task.id,
                     "config_id": config.id,
@@ -166,10 +314,10 @@ class ManualTaskGraphTask(GraphTask):
 
     def _get_submitted_data(
         self,
-        db: Session,
         manual_task: ManualTask,
         privacy_request: PrivacyRequest,
         allowed_config_type: "ManualTaskConfigurationType",
+        conditional_data: Optional[dict[str, Any]] = None,
     ) -> Optional[dict[str, Any]]:
         """
         Check if all manual task instances have submissions for ALL fields and return aggregated data
@@ -193,10 +341,15 @@ class ManualTaskGraphTask(GraphTask):
             # Update status if needed
             if inst.status != StatusType.completed:
                 inst.status = StatusType.completed
-                inst.save(db)
+                inst.save(self.resources.session)
 
         # Aggregate submission data from all instances
         aggregated_data = self._aggregate_submission_data(candidate_instances)
+
+        # Merge conditional data with aggregated submission data
+        if conditional_data:
+            aggregated_data = deep_update(aggregated_data, conditional_data)
+
         return aggregated_data or None
 
     def _aggregate_submission_data(
@@ -254,84 +407,25 @@ class ManualTaskGraphTask(GraphTask):
                 )
         return attachment_map or None
 
-    def dry_run_task(self) -> int:
-        """Return estimated row count for dry run - manual tasks don't have predictable counts"""
-        return 1  # Placeholder - manual tasks generate variable data
-
-    # Provide erasure support for manual tasks
-    @retry(action_type=ActionType.erasure, default_return=0)
-    def erasure_request(
-        self,
-        retrieved_data: list[Row],
-        *erasure_prereqs: int,  # noqa: D401, pylint: disable=unused-argument
-        inputs: Optional[list[list[Row]]] = None,
-    ) -> int:
-        """Execute manual-task-driven erasure logic.
-
-        Mirrors access_request behaviour but returns the number of rows masked (always 0)
-        once all required manual task submissions are present. If submissions are
-        incomplete the privacy request is paused awaiting user input.
+    def _cleanup_manual_task_instances(
+        self, manual_task: ManualTask, privacy_request: PrivacyRequest
+    ) -> None:
         """
-        db = self.resources.session
-        collection_address = self.execution_node.address
+        Clean up ManualTaskInstances for a manual task when conditional dependencies are not met.
 
-        # Validate manual task address
-        if not ManualTaskAddress.is_manual_task_address(collection_address):
-            raise ValueError(f"Invalid manual task address: {collection_address}")
-
-        connection_key = ManualTaskAddress.get_connection_key(collection_address)
-
-        # Fetch relevant manual tasks for this connection
-        manual_task = get_manual_task_for_connection_config(db, connection_key)
-        if not manual_task:
-            # No manual tasks defined – nothing to erase
-            self.log_end(ActionType.erasure)
-            return 0
-
-        # Check if any manual tasks have ERASURE configs
-        has_erasure_configs = [
-            config
-            for config in manual_task.configs
-            if config.is_current
-            and config.config_type
-            == ManualTaskConfigurationType.erasure_privacy_request
+        This method removes any existing instances that were created before the conditional
+        dependency evaluation determined the task should not execute.
+        """
+        # Find all instances for this manual task and privacy request
+        instances_to_remove = [
+            instance
+            for instance in privacy_request.manual_task_instances
+            if instance.task_id == manual_task.id
         ]
 
-        if not has_erasure_configs:
-            # No erasure configs - complete immediately
-            self.log_end(ActionType.erasure)
-            return 0
-
-        # Create ManualTaskInstances for ERASURE configs only
-        self._ensure_manual_task_instances(
-            db,
-            manual_task,
-            self.resources.request,
-            ManualTaskConfigurationType.erasure_privacy_request,
-        )
-
-        # Check for full submissions – reuse helper used by access flow, filtering ERASURE configs
-        submissions_complete = self._get_submitted_data(
-            db,
-            manual_task,
-            self.resources.request,
-            ManualTaskConfigurationType.erasure_privacy_request,
-        )
+        if instances_to_remove:
 
-        # If any field submissions are missing, pause processing
-        if submissions_complete is None:
-            if self.resources.request.status != PrivacyRequestStatus.requires_input:
-                self.resources.request.status = PrivacyRequestStatus.requires_input
-                self.resources.request.save(db)
-            raise AwaitingAsyncTaskCallback(
-                f"Manual erasure task for {connection_key} requires user input"
-            )
-
-        # Mark rows_masked = 0 (manual tasks do not mask data directly)
-        if self.request_task.id:
-            # Storing result for DSR 3.0; SQLAlchemy column typing triggers mypy warning
-            self.request_task.rows_masked = 0  # type: ignore[assignment]
-
-        # Mark successful completion
-        self.log_end(ActionType.erasure)
-        return 0
+            # Remove instances from the database
+            for instance in instances_to_remove:
+                instance.delete(self.resources.session)
+                self.resources.session.commit()

fides/api/task/manual/manual_task_utils.py

@@ -1,6 +1,5 @@
 from typing import Optional
 
-from loguru import logger
 from sqlalchemy.orm import Session
 
 from fides.api.graph.config import (
@@ -110,9 +109,6 @@ def create_conditional_dependency_scalar_fields(
         # Use the full field address as the field name to preserve collection context
         # This allows the manual task to receive data from specific collections
         # e.g., "user.name" or "customer.profile.email" instead of just "name" or "email"
-        logger.info(
-            f"Creating conditional dependency scalar field for field address: {field_address}"
-        )
         field_address_obj = FieldAddress.from_string(field_address)
 
         scalar_field = ScalarField(

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/e1628f15dd5f019b.css" as="style"/><link rel="stylesheet" href="/_next/static/css/e1628f15dd5f019b.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-69658aeaf6155d89.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-65723cd4b8fc36ac.js" defer=""></script><script src="/_next/static/chunks/pages/404-9174cdb70126c2c5.js" defer=""></script><script src="/_next/static/5XFHjjKVYqngLW-SDXDX4/_buildManifest.js" defer=""></script><script src="/_next/static/5XFHjjKVYqngLW-SDXDX4/_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":"5XFHjjKVYqngLW-SDXDX4","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/e1628f15dd5f019b.css" as="style"/><link rel="stylesheet" href="/_next/static/css/e1628f15dd5f019b.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-69658aeaf6155d89.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-65723cd4b8fc36ac.js" defer=""></script><script src="/_next/static/chunks/pages/404-9174cdb70126c2c5.js" defer=""></script><script src="/_next/static/tzF4yti8NslASlGnxnZ8m/_buildManifest.js" defer=""></script><script src="/_next/static/tzF4yti8NslASlGnxnZ8m/_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":"tzF4yti8NslASlGnxnZ8m","nextExport":true,"autoExport":true,"isFallback":false,"scriptLoader":[]}</script></body></html>