ethyca-fides 2.68.1b3__py2.py3-none-any.whl → 2.69.0__py2.py3-none-any.whl

fides/api/schemas/enums/integration_feature.py

@@ -0,0 +1,26 @@
+from enum import Enum
+
+
+class IntegrationFeature(str, Enum):
+    """
+    Features that can be enabled for different integration types.
+    These control which tabs and functionality are available in the integration detail view.
+    """
+
+    # Enables data discovery and monitoring functionality - shows "Data discovery" tab
+    DATA_DISCOVERY = "DATA_DISCOVERY"
+
+    # Enables data synchronization to external systems - shows "Data sync" tab
+    DATA_SYNC = "DATA_SYNC"
+
+    # Enables task/workflow management for manual processes - shows "Tasks" tab
+    TASKS = "TASKS"
+
+    # Indicates integration doesn't require connection testing - shows "Details" tab instead of "Connection" tab
+    WITHOUT_CONNECTION = "WITHOUT_CONNECTION"
+
+    # Enables Data Subject Request automation for SAAS integrations
+    DSR_AUTOMATION = "DSR_AUTOMATION"
+
+    # Enables conditions configuration for manual task creation - shows "Conditions" tab
+    CONDITIONS = "CONDITIONS"

fides/api/schemas/external_https.py

@@ -39,3 +39,12 @@ class RequestTaskJWE(BaseModel):
     request_task_id: str
     scopes: List[str]
     iat: str
+
+
+class DownloadTokenJWE(BaseModel):
+    """Describes JWE that is given to users to access their privacy request download package"""
+
+    privacy_request_id: str
+    scopes: List[str]
+    iat: str
+    exp: str

fides/api/schemas/privacy_request.py

@@ -18,6 +18,7 @@ from fides.api.schemas.user import PrivacyRequestReviewer
 from fides.api.util.collection_util import Row
 from fides.api.util.encryption.aes_gcm_encryption_scheme import verify_encryption_key
 from fides.api.util.enums import ColumnSort
+from fides.api.util.text import normalize_location_code
 from fides.config import CONFIG
 
 
@@ -103,6 +104,7 @@ class PrivacyRequestCreate(FidesSchema):
     property_id: Optional[str] = None
     consent_preferences: Optional[List[Consent]] = None  # TODO Slated for deprecation
     source: Optional[PrivacyRequestSource] = None
+    location: Optional[str] = None
 
     @field_validator("encryption_key")
     @classmethod
@@ -114,6 +116,18 @@ class PrivacyRequestCreate(FidesSchema):
             verify_encryption_key(value.encode(CONFIG.security.encoding))
         return value
 
+    @field_validator("location")
+    @classmethod
+    def validate_location(
+        cls: Type["PrivacyRequestCreate"], value: Optional[str] = None
+    ) -> Optional[str]:
+        """Validate and normalize location to ISO 3166 format"""
+        if value is None:
+            return None
+
+        # nuance here is the validator will coalesce values from the less strict format to ISO 3166 (i.e. "us_ca" -> "US-CA")
+        return normalize_location_code(value)
+
 
 class PrivacyRequestResubmit(PrivacyRequestCreate):
     """Schema used to copy a privacy request for resubmission"""
@@ -321,6 +335,7 @@ class PrivacyRequestResponse(FidesSchema):
     custom_privacy_request_fields_approved_by: Optional[str] = None
     custom_privacy_request_fields_approved_at: Optional[datetime] = None
     source: Optional[PrivacyRequestSource] = None
+    location: Optional[str] = None
     deleted_at: Optional[datetime] = None
     deleted_by: Optional[str] = None
     finalized_at: Optional[datetime] = None
@@ -437,6 +452,7 @@ class PrivacyRequestFilter(FidesSchema):
     errored_lt: Optional[datetime] = None
     errored_gt: Optional[datetime] = None
     external_id: Optional[str] = None
+    location: Optional[str] = None
     action_type: Optional[ActionType] = None
     verbose: Optional[bool] = False
     include_identities: Optional[bool] = False

fides/api/schemas/saas/connector_template.py

@@ -4,6 +4,8 @@ from fideslang.models import Dataset
 from pydantic import BaseModel, field_validator
 
 from fides.api.models.datasetconfig import validate_masking_strategy_override
+from fides.api.schemas.enums.connection_category import ConnectionCategory
+from fides.api.schemas.enums.integration_feature import IntegrationFeature
 from fides.api.schemas.policy import ActionType
 from fides.api.schemas.saas.saas_config import SaaSConfig
 from fides.api.util.saas_util import load_config_from_string, load_dataset_from_string
@@ -22,6 +24,9 @@ class ConnectorTemplate(BaseModel):
     authorization_required: bool
     user_guide: Optional[str] = None
     supported_actions: List[ActionType]
+    category: Optional[ConnectionCategory] = None
+    tags: Optional[List[str]] = None
+    enabled_features: Optional[List[IntegrationFeature]] = None
 
     @field_validator("config")
     @classmethod

fides/api/schemas/saas/display_info.py

@@ -0,0 +1,19 @@
+from typing import List, Optional
+
+from pydantic import BaseModel, ConfigDict
+
+from fides.api.schemas.enums.connection_category import ConnectionCategory
+from fides.api.schemas.enums.integration_feature import IntegrationFeature
+
+
+class SaaSDisplayInfo(BaseModel):
+    """
+    Optional display information for SAAS integrations to enhance frontend presentation.
+    When not provided, smart defaults will be inferred based on the integration type.
+    """
+
+    category: Optional[ConnectionCategory] = None
+    tags: Optional[List[str]] = None
+    enabled_features: Optional[List[IntegrationFeature]] = None
+
+    model_config = ConfigDict(use_enum_values=True)

fides/api/schemas/saas/saas_config.py

@@ -17,6 +17,7 @@ from fides.api.graph.config import (
 from fides.api.schemas.base_class import FidesSchema
 from fides.api.schemas.limiter.rate_limit_config import RateLimitConfig
 from fides.api.schemas.policy import ActionType
+from fides.api.schemas.saas.display_info import SaaSDisplayInfo
 from fides.api.schemas.saas.shared_schemas import HTTPMethod
 from fides.api.service.saas_request.saas_request_override_factory import (
     SaaSRequestOverrideFactory,
@@ -428,6 +429,7 @@ class SaaSConfig(SaaSConfigBase):
     rate_limit_config: Optional[RateLimitConfig] = None
     consent_requests: Optional[ConsentRequestMap] = None
     user_guide: Optional[str] = None
+    display_info: Optional[SaaSDisplayInfo] = None
 
     @property
     def top_level_endpoint_dict(self) -> Dict[str, Endpoint]:

fides/api/schemas/storage/storage.py

@@ -38,6 +38,7 @@ class StorageDetails(Enum):
     MAX_RETRIES = "max_retries"
     AUTH_METHOD = "auth_method"
     ENABLE_STREAMING = "enable_streaming"
+    ENABLE_ACCESS_PACKAGE_REDIRECT = "enable_access_package_redirect"
     model_config = ConfigDict(extra="forbid")
 
 
@@ -60,6 +61,7 @@ class StorageDetailsS3(FileBasedStorageDetails):
     bucket: str
     max_retries: Optional[int] = 0
     enable_streaming: Optional[bool] = False
+    enable_access_package_redirect: Optional[bool] = False
     model_config = ConfigDict(use_enum_values=True)
 
 

fides/api/service/connectors/saas/connector_registry_service.py

@@ -26,6 +26,7 @@ from fides.api.service.authentication.authentication_strategy_oauth2_authorizati
 )
 from fides.api.util.saas_util import (
     encode_file_contents,
+    extract_display_info_from_config,
     load_config,
     load_config_from_string,
     load_dataset_from_string,
@@ -78,6 +79,8 @@ class FileConnectorTemplateLoader(ConnectorTemplateLoader):
                     == OAuth2AuthorizationCodeAuthenticationStrategy.name
                 )
 
+                display_info = extract_display_info_from_config(config)
+
                 try:
                     icon = encode_file_contents(f"data/saas/icon/{connector_type}.svg")
                 except FileNotFoundError:
@@ -100,6 +103,7 @@ class FileConnectorTemplateLoader(ConnectorTemplateLoader):
                         authorization_required=authorization_required,
                         user_guide=config.user_guide,
                         supported_actions=config.supported_actions,
+                        **display_info,
                     )
                 except Exception:
                     logger.exception("Unable to load {} connector", connector_type)
@@ -165,6 +169,8 @@ class CustomConnectorTemplateLoader(ConnectorTemplateLoader):
             == OAuth2AuthorizationCodeAuthenticationStrategy.name
         )
 
+        display_info = extract_display_info_from_config(config)
+
         connector_template = ConnectorTemplate(
             config=template.config,
             dataset=template.dataset,
@@ -173,6 +179,7 @@ class CustomConnectorTemplateLoader(ConnectorTemplateLoader):
             authorization_required=authorization_required,
             user_guide=config.user_guide,
             supported_actions=config.supported_actions,
+            **display_info,
         )
 
         # register the template in the loader's template dictionary

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

@@ -1,8 +1,8 @@
+import copy
 import json
 import os
 import time as time_module
 import zipfile
-from collections import defaultdict
 from io import BytesIO
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Optional
@@ -12,7 +12,18 @@ from jinja2 import Environment, FileSystemLoader
 from loguru import logger
 
 from fides.api.schemas.policy import ActionType
+from fides.api.service.storage.util import (
+    _get_datasets_from_dsr_data,
+    create_attachment_info_dict,
+    format_attachment_size,
+    generate_attachment_url_from_storage_path,
+    is_attachment_field,
+    process_attachment_naming,
+    process_attachments_contextually,
+    resolve_directory_from_context,
+)
 from fides.api.util.storage_util import StorageJSONEncoder, format_size
+from fides.config import CONFIG
 
 DSR_DIRECTORY = Path(__file__).parent.resolve()
 
@@ -46,6 +57,7 @@ class DsrReportBuilder:
         self,
         privacy_request: "PrivacyRequest",
         dsr_data: dict[str, Any],
+        enable_streaming: bool = False,
     ):
         """
         Initializes the DSR report builder.
@@ -54,7 +66,6 @@ class DsrReportBuilder:
         jinja2.filters.FILTERS["pretty_print"] = lambda value, indent=4: json.dumps(
             value, indent=indent, cls=StorageJSONEncoder
         )
-
         # Initialize instance zip file variables
         self.baos = BytesIO()
 
@@ -70,15 +81,29 @@ class DsrReportBuilder:
             "text_color": TEXT_COLOR,
             "header_color": HEADER_COLOR,
             "border_color": BORDER_COLOR,
+            "download_link_ttl_days": self._get_download_link_ttl_days(),
+            "enable_streaming": enable_streaming,
         }
         self.main_links: dict[str, Any] = {}  # used to track the generated pages
 
         # report data to populate the templates
         self.request_data = _map_privacy_request(privacy_request)
         self.dsr_data = dsr_data
+        self.enable_streaming = enable_streaming
+
+        # Track used filenames per dataset to prevent conflicts within the same dataset
+        # Maps dataset_name -> set of used filenames
+        self.used_filenames_per_dataset: dict[str, set[str]] = {}
+
+        # Track attachments by their unique identifier to prevent duplicate processing
+        # Maps (download_url, file_name) -> unique_filename
+        self.processed_attachments: dict[tuple[str, str], str] = {}
+        # Track which attachments were processed as dataset attachments (not top-level)
+        self.dataset_processed_attachments: set[tuple[str, str]] = set()
 
-        # Track used filenames across all attachments
-        self.used_filenames: set[str] = set()
+    def _get_download_link_ttl_days(self) -> int:
+        """Get the download link TTL in days from the security configuration."""
+        return int(CONFIG.security.subject_request_download_link_ttl_seconds / 86400)
 
     def _populate_template(
         self,
@@ -148,34 +173,12 @@ class DsrReportBuilder:
             ),
         )
 
-    def _get_unique_filename(self, filename: str) -> str:
-        """
-        Generates a unique filename by appending a counter if the file already exists.
-        Now tracks filenames across all directories to ensure global uniqueness.
-
-        Args:
-            filename: The original filename
-
-        Returns:
-            A unique filename that won't conflict with existing files
-        """
-        base_name, extension = os.path.splitext(filename)
-        counter = 1
-        unique_filename = filename
-
-        # Check if file exists in used_filenames set
-        while unique_filename in self.used_filenames:
-            unique_filename = f"{base_name}_{counter}{extension}"
-            counter += 1
-
-        # Add the new filename to the set
-        self.used_filenames.add(unique_filename)
-        return unique_filename
-
+    # pylint: disable=too-many-branches
     def _write_attachment_content(
         self,
         attachments: list[dict[str, Any]],
         directory: str,
+        dataset_name: str = "attachments",
     ) -> dict[str, dict[str, str]]:
         """
         Processes attachments and returns a dictionary mapping filenames to their download URLs and sizes.
@@ -194,33 +197,133 @@ class DsrReportBuilder:
             if not isinstance(attachment, dict):
                 continue
 
-            file_name = attachment.get("file_name")
-            if not file_name:
-                logger.warning("Skipping attachment with no file name")
+            # Get or create the used_filenames set for this dataset
+            if dataset_name not in self.used_filenames_per_dataset:
+                self.used_filenames_per_dataset[dataset_name] = set()
+            used_filenames = self.used_filenames_per_dataset[dataset_name]
+
+            # Process attachment naming using shared utility
+            result = process_attachment_naming(
+                attachment, used_filenames, self.processed_attachments, dataset_name
+            )
+
+            if result is None:  # Skip if processing failed
                 continue
 
+            unique_filename, attachment_key = result
+            # Track that this attachment was processed as a dataset attachment
+            self.dataset_processed_attachments.add(attachment_key)
+
+            # Format file size using shared utility
+            file_size = format_attachment_size(attachment.get("file_size"))
+
+            # Determine the actual directory for this attachment based on its context
+            actual_directory = resolve_directory_from_context(attachment, directory)
+
+            # Generate attachment URL using shared utility with actual storage path
             download_url = attachment.get("download_url")
             if not download_url:
-                logger.warning("Skipping attachment with no download URL")
                 continue
 
-            file_size = attachment.get("file_size")
-            if isinstance(file_size, (int, float)):
-                file_size = format_size(float(file_size))
-            else:
-                file_size = "Unknown"
+            attachment_url = generate_attachment_url_from_storage_path(
+                download_url,
+                unique_filename,
+                actual_directory,  # This is the base_path where the file will be stored
+                actual_directory,  # This is the HTML template directory
+                self.enable_streaming,
+            )
 
-            # Get a unique filename to prevent duplicates
-            unique_filename = self._get_unique_filename(file_name)
+            # Create attachment info dictionary using shared utility
+            file_name = attachment.get("file_name")
+            if not file_name:
+                continue
 
-            # Add to processed attachments
-            processed_attachments.append(
-                (unique_filename, {"url": download_url, "size": file_size})
+            attachment_info = create_attachment_info_dict(
+                attachment_url, file_size, file_name
             )
 
+            processed_attachments.append((unique_filename, attachment_info))
+
         # Convert list of tuples to dictionary
         return dict(processed_attachments)
 
+    def _get_processed_attachments_list(
+        self, data: dict[str, Any]
+    ) -> list[dict[str, Any]]:
+        """Get all processed attachments using shared contextual logic.
+
+        Args:
+            data: The DSR data dictionary
+
+        Returns:
+            List of processed attachment dictionaries
+        """
+        # Create temporary sets for compatibility with the shared function
+        used_filenames_data = set()
+        used_filenames_attachments = set()
+
+        # Populate the temporary sets from our per-dataset tracking
+        for dataset_name, filenames in self.used_filenames_per_dataset.items():
+            if dataset_name == "attachments":
+                used_filenames_attachments.update(filenames)
+            else:
+                used_filenames_data.update(filenames)
+
+        processed_attachments_list = process_attachments_contextually(
+            data,
+            used_filenames_data,
+            used_filenames_attachments,
+            self.processed_attachments,
+            enable_streaming=self.enable_streaming,
+        )
+
+        # Trust the contextual processing completely - it already correctly determines
+        # context based on the attachment's location in the DSR data structure
+        filtered_list = processed_attachments_list
+
+        return filtered_list
+
+    def _generate_attachment_url_from_index(
+        self, context: dict[str, Any], unique_filename: str
+    ) -> str:
+        """Generate the correct URL from attachments/index.html to an attachment file.
+
+        Args:
+            context: The attachment context information
+            unique_filename: The unique filename of the attachment
+
+        Returns:
+            The relative URL from attachments/index.html to the attachment file
+        """
+        if context.get("type") == "top_level":
+            # Top-level attachments are in the same directory as the index
+            return unique_filename
+        if context.get("type") in ["direct", "nested"]:
+            # Dataset attachments are in data/dataset/collection/attachments/
+            # From attachments/index.html, we need to go to ../data/dataset/collection/attachments/filename
+            dataset = context.get("dataset", "unknown")
+            collection = context.get("collection", "unknown")
+            return f"../data/{dataset}/{collection}/attachments/{unique_filename}"
+        # Fallback for other cases - return just the filename
+        return unique_filename
+
+    def _create_attachment_info_with_corrected_url(
+        self, attachment_info: dict[str, str], correct_url: str
+    ) -> dict[str, str]:
+        """Create attachment info with corrected URL.
+
+        Args:
+            attachment_info: The original attachment info
+            correct_url: The corrected URL
+
+        Returns:
+            New attachment info with corrected URL and safe_url
+        """
+        corrected_attachment_info = attachment_info.copy()
+        corrected_attachment_info["url"] = correct_url
+        corrected_attachment_info["safe_url"] = correct_url
+        return corrected_attachment_info
+
     def _add_collection(
         self, rows: list[dict[str, Any]], dataset_name: str, collection_name: str
     ) -> None:
@@ -235,10 +338,11 @@ class DsrReportBuilder:
         items_content = []
 
         for index, collection_item in enumerate(rows, 1):
-            # Create a copy of the item data to avoid modifying the original
-            item_data = collection_item.copy()
+            # Create a deep copy of the item data to avoid modifying the original DSR data
+            # This ensures the comprehensive attachments index can access unmodified attachments
+            item_data = copy.deepcopy(collection_item)
 
-            # Process any attachments in the item
+            # Process any attachments in the item - First check for direct attachments key
             if "attachments" in item_data and isinstance(
                 item_data["attachments"], list
             ):
@@ -246,9 +350,32 @@ class DsrReportBuilder:
                 attachment_links = self._write_attachment_content(
                     item_data["attachments"],
                     f"data/{dataset_name}/{collection_name}",
+                    dataset_name,
                 )
                 # Add the attachment URLs to the item data
                 item_data["attachments"] = attachment_links
+            else:
+                # Check for nested attachment fields (ManualTask format)
+                attachment_fields_found = []
+                for field_name, field_value in item_data.items():
+                    if isinstance(field_value, list) and field_value:
+                        # Check if this field contains attachment-like data
+                        first_item = field_value[0]
+                        if isinstance(first_item, dict) and all(
+                            key in first_item
+                            for key in ["file_name", "download_url", "file_size"]
+                        ):
+                            attachment_fields_found.append(field_name)
+
+                            # Process attachments and get their URLs
+                            attachment_links = self._write_attachment_content(
+                                field_value,
+                                f"data/{dataset_name}/{collection_name}",
+                                dataset_name,
+                            )
+
+                            # Replace the field value with processed attachment links
+                            item_data[field_name] = attachment_links
 
             # Add item content to the list
             items_content.append(
@@ -294,34 +421,67 @@ class DsrReportBuilder:
             ),
         )
 
-    def _get_datasets_from_dsr_data(self) -> dict[str, Any]:
+    def _add_comprehensive_attachments_index(self) -> None:
         """
-        Returns the datasets from the DSR data.
+        Creates a comprehensive attachments index that includes ALL attachments
+        from all datasets and top-level attachments, with links pointing to their
+        actual storage locations.
         """
-        # pre-process data to split the dataset:collection keys
-        datasets: dict[str, Any] = defaultdict(lambda: defaultdict(list))
-        for key, rows in self.dsr_data.items():
-
-            # we handle attachments separately
-            if key == "attachments":
+        # Get all processed attachments using shared logic on original DSR data
+        processed_attachments_list = self._get_processed_attachments_list(self.dsr_data)
+
+        # Create a comprehensive attachment links dictionary with deduplication
+        all_attachment_links = {}
+        seen_attachment_keys = set()
+
+        for processed_attachment in processed_attachments_list:
+            unique_filename = processed_attachment["unique_filename"]
+            attachment_info = processed_attachment["attachment_info"]
+            context = processed_attachment["context"]
+            attachment = processed_attachment["attachment"]
+
+            # Create a unique key based on download_url to avoid duplicates
+            attachment_key = attachment.get("download_url")
+            if attachment_key in seen_attachment_keys:
                 continue
+            seen_attachment_keys.add(attachment_key)
 
-            parts = key.split(":", 1)
-            if len(parts) > 1:
-                dataset_name, collection_name = parts
+            # Generate the correct URL based on streaming settings
+            if self.enable_streaming:
+                # For streaming mode, use local attachment references
+                correct_url = self._generate_attachment_url_from_index(
+                    context, unique_filename
+                )
             else:
-                for row in rows:
-                    if "system_name" in row:
-                        dataset_name = row["system_name"]
-                        collection_name = parts[0]
-                        break
-                else:
-                    dataset_name = "manual"
-                    collection_name = parts[0]
+                # For non-streaming mode, use original download URLs
+                correct_url = attachment.get("download_url", unique_filename)
+
+            # Create a descriptive key that includes the source location
+            if context.get("type") == "top_level":
+                key = f"Top-level: {unique_filename}"
+            elif context.get("type") in ["direct", "nested"]:
+                dataset = context.get("dataset", "unknown")
+                collection = context.get("collection", "unknown")
+                key = f"{dataset}/{collection}: {unique_filename}"
+            else:
+                key = unique_filename
 
-            datasets[dataset_name][collection_name].extend(rows)
+            # Create new attachment info with the correct URL
+            corrected_attachment_info = self._create_attachment_info_with_corrected_url(
+                attachment_info, correct_url
+            )
+            all_attachment_links[key] = corrected_attachment_info
 
-        return datasets
+        # Generate comprehensive attachments index page
+        self._add_file(
+            "attachments/index.html",
+            self._populate_template(
+                "templates/attachments_index.html",
+                "All Attachments",
+                "All files attached to this privacy request",
+                all_attachment_links,
+            ),
+        )
 
     def generate(self) -> BytesIO:
         """
@@ -343,7 +503,7 @@ class DsrReportBuilder:
             )
 
             # pre-process data to split the dataset:collection keys
-            datasets: dict[str, Any] = self._get_datasets_from_dsr_data()
+            datasets: dict[str, Any] = _get_datasets_from_dsr_data(self.dsr_data)
 
             # Sort datasets alphabetically, excluding special cases
             regular_datasets = [
@@ -360,10 +520,32 @@ class DsrReportBuilder:
                 self._add_dataset("dataset", datasets["dataset"])
                 self.main_links["Additional Data"] = "data/dataset/index.html"
 
-            # Add Additional Attachments last if it exists
-            if "attachments" in self.dsr_data:
-                self._add_attachments(self.dsr_data["attachments"])
-                self.main_links["Additional Attachments"] = "attachments/index.html"
+            # Add comprehensive attachments index that includes ALL attachments
+            # Check if there are any attachments at all (top-level or in datasets)
+            has_top_level_attachments = (
+                "attachments" in self.dsr_data and self.dsr_data["attachments"]
+            )
+            has_dataset_attachments = any(
+                any(
+                    "attachments" in item
+                    or any(
+                        is_attachment_field(field_value)
+                        for field_value in item.values()
+                        if isinstance(field_value, list)
+                    )
+                    for item in collection_items
+                    if isinstance(item, dict)
+                )
+                for collection in datasets.values()
+                if isinstance(collection, dict)
+                for collection_items in collection.values()
+                if isinstance(collection_items, list)
+            )
+            has_attachments = has_top_level_attachments or has_dataset_attachments
+
+            if has_attachments:
+                self._add_comprehensive_attachments_index()
+                self.main_links["All Attachments"] = "attachments/index.html"
 
             # create the main index once all the datasets have been added
             self._add_file(

fides/api/service/privacy_request/dsr_package/templates/attachments_index.html

@@ -14,7 +14,9 @@
                </a>
             </div>
             <h1>Attachments</h1>
-            <p class="expiration-notice">Note: All download links will expire in 7 days.</p>
+            {% if not enable_streaming %}
+            <p class="expiration-notice">Note: All download links will expire in {{ download_link_ttl_days }} days.</p>
+            {% endif %}
             <div class="table table-hover">
                <div class="table-row">
                   <div class="table-cell" style="text-align: left;">File Name</div>
@@ -22,7 +24,7 @@
                </div>
                {% for name, info in data.items() %}
                <a href="{{ info.url }}" class="table-row" target="_blank">
-                  <div class="table-cell" style="text-align: left;">{{ name }}</div>
+                  <div class="table-cell" style="text-align: left;">{% if enable_streaming %}{{ name }}{% else %}{{ info.original_name }}{% endif %}</div>
                   <div class="table-cell" style="text-align: left;">{{ info.size }}</div>
                </a>
                {% endfor %}