Permalink Update - storage version 0.1.0

app.py

@@ -807,7 +807,7 @@ def load_trellis_model():
     gr.Info("TRELLIS_PIPELINE load start", 60)
     global TRELLIS_PIPELINE
     loaded = False
-    if TRELLIS_PIPELINE == None:
+    if (TRELLIS_PIPELINE == None):
         try:
             TRELLIS_PIPELINE = TrellisImageTo3DPipeline.from_pretrained("Surn/TRELLIS-image-large")
             TRELLIS_PIPELINE.cuda()
@@ -1177,8 +1177,9 @@ def update_permalink(glb, gaussian, depth_out, depth_src_file):
         return gr.update(visible=False), ""
     
     smallest_file = min(file_candidates, key=file_candidates.get)
-    permalink = generate_permalink_from_urls(smallest_file, depth_out, depth_src_file)
-    return gr.update(visible=True), permalink
+    # generate_permalink_from_urls now returns a string directly
+    permalink_url = generate_permalink_from_urls(smallest_file, depth_out, depth_src_file)
+    return gr.update(visible=True), permalink_url
 
 def create_permalink(glb, gaussian, depth_out, depth_src_file, folder_name_permalink):
     """
@@ -1202,14 +1203,17 @@ def create_permalink(glb, gaussian, depth_out, depth_src_file, folder_name_perma
     #     return gr.update(visible=False), ""
     smallest_file = min(file_candidates, key=file_candidates.get)
 
-    permalink = upload_files_to_repo(
+    upload_result = upload_files_to_repo(
             files=[smallest_file, depth_out, depth_src_file],
-            repo_id="Surn/Storage",
+            repo_id=constants.HF_REPO_ID, # Use constant for repo_id
             folder_name=folder_name_permalink,
             create_permalink=True,
             repo_type="dataset"
-        )[1]
-    return permalink
+        )
+    # upload_files_to_repo returns a dict with "permalink" and "short_permalink"
+    # We are interested in the "short_permalink" if available, otherwise the "permalink"
+    permalink_url = upload_result.get("short_permalink") or upload_result.get("permalink")
+    return permalink_url
 
 def open_permalink(url: str) -> str:
     if url and url.strip():

utils/constants.py

@@ -675,4 +675,8 @@ card_colors_alternating = [
     "#000000", "#000000", "#000000", "#000000", "#000000", "#000000", "#000000", "#000000", "#000000", "#000000", "#000000", "#000000", "#000000",  # Clubs
     "#FF0000", "#FF0000", "#FF0000", "#FF0000", "#FF0000", "#FF0000", "#FF0000", "#FF0000", "#FF0000", "#FF0000", "#FF0000", "#FF0000", "#FF0000",  # Diamonds
     "#000000", "#000000", "#000000", "#000000", "#000000", "#000000", "#000000", "#000000", "#000000", "#000000", "#000000", "#000000", "#000000"   # Spades
-]
+]
+
+# Constants for URL shortener
+HF_REPO_ID = "Surn/Storage"  # Or your desired repository
+SHORTENER_JSON_FILE = "shortener.json"

utils/storage.md

@@ -0,0 +1,154 @@
+# Storage Module (`modules/storage.py`) Usage Guide
+
+The `storage.py` module provides helper functions for:
+- Generating permalinks for 3D viewer projects.
+- Uploading files in batches to a Hugging Face repository.
+- Managing URL shortening by storing (short URL, full URL) pairs in a JSON file on the repository.
+
+## Key Functions
+
+### 1. `generate_permalink(valid_files, base_url_external, permalink_viewer_url="surn-3d-viewer.hf.space")`
+- **Purpose:**  
+  Given a list of file paths, it looks for exactly one model file (with an extension defined in `model_extensions`) and exactly two image files (extensions defined in `image_extensions`). If the criteria are met, it returns a permalink URL built from the base URL and query parameters.
+- **Usage Example:**from modules.storage import generate_permalink
+
+valid_files = [
+    "models/3d_model.glb",
+    "images/model_texture.png",
+    "images/model_depth.png"
+]
+base_url_external = "https://huggingface.co/datasets/Surn/Storage/resolve/main/saved_models/my_model"
+permalink = generate_permalink(valid_files, base_url_external)
+if permalink:
+    print("Permalink:", permalink)
+### 2. `generate_permalink_from_urls(model_url, hm_url, img_url, permalink_viewer_url="surn-3d-viewer.hf.space")`
+- **Purpose:**  
+  Constructs a permalink URL by combining individual URLs for a 3D model (`model_url`), height map (`hm_url`), and image (`img_url`) into a single URL with corresponding query parameters.
+- **Usage Example:**from modules.storage import generate_permalink_from_urls
+
+model_url = "https://example.com/model.glb"
+hm_url = "https://example.com/heightmap.png"
+img_url = "https://example.com/source.png"
+
+permalink = generate_permalink_from_urls(model_url, hm_url, img_url)
+print("Generated Permalink:", permalink)
+### 3. `upload_files_to_repo(files, repo_id, folder_name, create_permalink=False, repo_type="dataset", permalink_viewer_url="surn-3d-viewer.hf.space")`
+- **Purpose:**  
+  Uploads a batch of files (each file represented as a path string) to a specified Hugging Face repository (e.g. `"Surn/Storage"`) under a given folder.
+  The function's return type is `Union[Dict[str, Any], List[Tuple[Any, str]]]`.
+  - When `create_permalink` is `True` and exactly three valid files (one model and two images) are provided, the function returns a dictionary:```
+{
+    "response": <upload_folder_response>,
+    "permalink": "<full_permalink_url>",
+    "short_permalink": "<shortened_permalink_url_with_sid>"
+}
+```  - Otherwise (or if `create_permalink` is `False` or conditions for permalink creation are not met), it returns a list of tuples, where each tuple is `(upload_folder_response, individual_file_link)`.
+  - If no valid files are provided, it returns an empty list `[]` (this case should ideally also return the dictionary with empty/None values for consistency, but currently returns `[]` as per the code).
+- **Usage Example:**
+
+  **a. Uploading with permalink creation:**from modules.storage import upload_files_to_repo
+
+files_for_permalink = [
+    "local/path/to/model.glb",
+    "local/path/to/heightmap.png",
+    "local/path/to/image.png"
+]
+repo_id = "Surn/Storage" # Make sure this is defined, e.g., from constants
+folder_name = "my_new_model_with_permalink"
+
+upload_result = upload_files_to_repo(
+    files_for_permalink, 
+    repo_id, 
+    folder_name, 
+    create_permalink=True
+)
+
+if isinstance(upload_result, dict):
+    print("Upload Response:", upload_result.get("response"))
+    print("Full Permalink:", upload_result.get("permalink"))
+    print("Short Permalink:", upload_result.get("short_permalink"))
+elif upload_result: # Check if list is not empty
+    print("Upload Response for individual files:")
+    for res, link in upload_result:
+        print(f"  Response: {res}, Link: {link}")
+else:
+    print("No files uploaded or error occurred.")
+  **b. Uploading without permalink creation (or if conditions for permalink are not met):**from modules.storage import upload_files_to_repo
+
+files_individual = [
+    "local/path/to/another_model.obj",
+    "local/path/to/texture.jpg"
+]
+repo_id = "Surn/Storage"
+folder_name = "my_other_uploads"
+
+upload_results_list = upload_files_to_repo(
+    files_individual, 
+    repo_id, 
+    folder_name, 
+    create_permalink=False # Or if create_permalink=True but not 1 model & 2 images
+)
+
+if upload_results_list: # Will be a list of tuples
+    print("Upload results for individual files:")
+    for res, link in upload_results_list:
+        print(f"  Upload Response: {res}, File Link: {link}")
+else:
+    print("No files uploaded or error occurred.")
+### 4. URL Shortening Functions: `gen_full_url(...)` and Helpers
+The module also enables URL shortening by managing a JSON file (e.g. `shortener.json`) in a Hugging Face repository. It supports CRUD-like operations:
+- **Read:** Look up the full URL using a provided short URL ID.
+- **Create:** Generate a new short URL ID for a full URL if no existing mapping exists.
+- **Update/Conflict Handling:**  
+If both short URL ID and full URL are provided, it checks consistency and either confirms or reports a conflict.
+
+#### `gen_full_url(short_url=None, full_url=None, repo_id=None, repo_type="dataset", permalink_viewer_url="surn-3d-viewer.hf.space", json_file="shortener.json")`
+- **Purpose:**  
+  Based on which parameter is provided, it retrieves or creates a mapping between a short URL ID and a full URL.  
+  - If only `short_url` (the ID) is given, it returns the corresponding `full_url`.  
+  - If only `full_url` is given, it looks up an existing `short_url` ID or generates and stores a new one.  
+  - If both are given, it validates and returns the mapping or an error status.
+- **Returns:** A tuple `(status_message, result_url)`, where `status_message` indicates the outcome (e.g., `"success_retrieved_full"`, `"created_short"`) and `result_url` is the relevant URL (full or short ID).
+- **Usage Examples:**
+
+  **a. Convert a full URL into a short URL ID:**from modules.storage import gen_full_url
+from modules.constants import HF_REPO_ID, SHORTENER_JSON_FILE # Assuming these are defined
+
+full_permalink = "https://surn-3d-viewer.hf.space/?3d=https%3A%2F%2Fexample.com%2Fmodel.glb&hm=https%3A%2F%2Fexample.com%2Fheightmap.png&image=https%3A%2F%2Fexample.com%2Fsource.png"
+
+status, short_id = gen_full_url(
+    full_url=full_permalink, 
+    repo_id=HF_REPO_ID, 
+    json_file=SHORTENER_JSON_FILE
+)
+print("Status:", status)
+if status == "created_short" or status == "success_retrieved_short":
+    print("Shortened URL ID:", short_id)
+    # Construct the full short URL for sharing:
+    # permalink_viewer_url = "surn-3d-viewer.hf.space" # Or from constants
+    # shareable_short_url = f"https://{permalink_viewer_url}/?sid={short_id}"
+    # print("Shareable Short URL:", shareable_short_url)
+  **b. Retrieve the full URL from a short URL ID:**from modules.storage import gen_full_url
+from modules.constants import HF_REPO_ID, SHORTENER_JSON_FILE # Assuming these are defined
+
+short_id_to_lookup = "aBcDeFg1"  # Example short URL ID
+
+status, retrieved_full_url = gen_full_url(
+    short_url=short_id_to_lookup, 
+    repo_id=HF_REPO_ID, 
+    json_file=SHORTENER_JSON_FILE
+)
+print("Status:", status)
+if status == "success_retrieved_full":
+    print("Retrieved Full URL:", retrieved_full_url)
+## Notes
+- **Authentication:** All functions that interact with Hugging Face Hub use the HF API token defined as `HF_API_TOKEN` in `modules/constants.py`. Ensure this environment variable is correctly set.
+- **Constants:** Functions like `gen_full_url` and `upload_files_to_repo` (when creating short links) rely on `HF_REPO_ID` and `SHORTENER_JSON_FILE` from `modules/constants.py` for the URL shortening feature.
+- **File Types:** Only files with extensions included in `upload_file_types` (a combination of `model_extensions` and `image_extensions` from `modules/constants.py`) are processed by `upload_files_to_repo`.
+- **Repository Configuration:** When using URL shortening and file uploads, ensure that the specified Hugging Face repository (e.g., defined by `HF_REPO_ID`) exists and that you have write permissions.
+- **Temporary Directory:** `upload_files_to_repo` temporarily copies files to a local directory (configured by `TMPDIR` in `modules/constants.py`) before uploading.
+- **Error Handling:** Functions include basic error handling (e.g., catching `RepositoryNotFoundError`, `EntryNotFoundError`, JSON decoding errors, or upload issues) and print messages to the console for debugging. Review function return values to handle these cases appropriately in your application.
+
+---
+
+This guide provides the essential usage examples for interacting with the storage and URL-shortening functionality. You can integrate these examples into your application or use them as a reference when extending functionality.

utils/storage.py

@@ -1,10 +1,17 @@
 # utils/storage.py
+__version__ = "0.1.0" # Added version
 import os
 import urllib.parse
 import tempfile
 import shutil
-from huggingface_hub import login, upload_folder
-from utils.constants import HF_API_TOKEN, upload_file_types, model_extensions, image_extensions
+import json
+import base64
+from huggingface_hub import login, upload_folder, hf_hub_download, HfApi
+from huggingface_hub.utils import RepositoryNotFoundError, EntryNotFoundError
+from utils.constants import HF_API_TOKEN, upload_file_types, model_extensions, image_extensions, HF_REPO_ID, SHORTENER_JSON_FILE
+from typing import Any, Dict, List, Tuple, Union
+
+# see storage.md for detailed information about the storage module and its functions.
 
 def generate_permalink(valid_files, base_url_external, permalink_viewer_url="surn-3d-viewer.hf.space"):
     """
@@ -49,7 +56,14 @@ def generate_permalink_from_urls(model_url, hm_url, img_url, permalink_viewer_ur
     query_str = urllib.parse.urlencode(params)
     return f"https://{permalink_viewer_url}/?{query_str}"
 
-def upload_files_to_repo(files, repo_id, folder_name, create_permalink=False, repo_type="dataset", permalink_viewer_url="surn-3d-viewer.hf.space"):
+def upload_files_to_repo(
+    files: List[Any],
+    repo_id: str,
+    folder_name: str,
+    create_permalink: bool = False,
+    repo_type: str = "dataset",
+    permalink_viewer_url: str = "surn-3d-viewer.hf.space"
+) -> Union[Dict[str, Any], List[Tuple[Any, str]]]:
     """
     Uploads multiple files to a Hugging Face repository using a batch upload approach via upload_folder.
 
@@ -61,18 +75,24 @@ def upload_files_to_repo(files, repo_id, folder_name, create_permalink=False, re
                                  returns a single permalink to the project with query parameters.
                                  Otherwise, returns individual permalinks for each file.
         repo_type (str): Repository type ("space", "dataset", etc.). Default is "dataset".
+        permalink_viewer_url (str): The base viewer URL.
 
     Returns:
-        If create_permalink is True and files match the criteria:
-            tuple: (response, permalink) where response is the output of the batch upload
-                   and permalink is the URL string (with fully qualified file paths) for the project.
-        Otherwise:
-            list: A list of tuples (response, permalink) for each file.
+        Union[Dict[str, Any], List[Tuple[Any, str]]]:
+            If create_permalink is True and files match the criteria:
+                dict: {
+                    "response": <upload response>,
+                    "permalink": <full_permalink URL>,
+                    "short_permalink": <shortened permalink URL>
+                }
+            Otherwise:
+                list: A list of tuples (response, permalink) for each file.
     """
     # Log in using the HF API token.
     login(token=HF_API_TOKEN)
     
     valid_files = []
+    permalink_short = None
     
     # Ensure folder_name does not have a trailing slash.
     folder_name = folder_name.rstrip("/")
@@ -87,10 +107,17 @@ def upload_files_to_repo(files, repo_id, folder_name, create_permalink=False, re
             valid_files.append(f)
     
     if not valid_files:
-        return []  # or raise an exception
+        # Return a dictionary with None values for permalinks if create_permalink was True
+        if create_permalink:
+            return {
+                "response": "No valid files to upload.",
+                "permalink": None,
+                "short_permalink": None
+            }
+        return [] 
     
     # Create a temporary directory; copy valid files directly into it.
-    with tempfile.TemporaryDirectory() as temp_dir:
+    with tempfile.TemporaryDirectory(dir=os.getenv("TMPDIR", "/tmp")) as temp_dir:
         for file_path in valid_files:
             filename = os.path.basename(file_path)
             dest_path = os.path.join(temp_dir, filename)
@@ -107,8 +134,6 @@ def upload_files_to_repo(files, repo_id, folder_name, create_permalink=False, re
         )
     
     # Construct external URLs for each uploaded file.
-    # For datasets, files are served at:
-    # https://huggingface.co/datasets/<repo_id>/resolve/main/<folder_name>/<filename>
     base_url_external = f"https://huggingface.co/datasets/{repo_id}/resolve/main/{folder_name}"
     individual_links = []
     for file_path in valid_files:
@@ -118,10 +143,179 @@ def upload_files_to_repo(files, repo_id, folder_name, create_permalink=False, re
     
     # If permalink creation is requested and exactly 3 valid files are provided,
     # try to generate a permalink using generate_permalink().
-    if create_permalink and len(valid_files) == 3:
-        permalink = generate_permalink_from_urls(individual_links[0], individual_links[1], individual_links[2], permalink_viewer_url)
+    if create_permalink: # No need to check len(valid_files) == 3 here, generate_permalink will handle it
+        permalink = generate_permalink(valid_files, base_url_external, permalink_viewer_url)
         if permalink:
-            return [response, permalink]
+            status, short_id = gen_full_url(
+                full_url=permalink,
+                repo_id=HF_REPO_ID, # This comes from constants
+                json_file=SHORTENER_JSON_FILE # This comes from constants
+            )
+            if status in ["created_short", "success_retrieved_short", "exists_match"]:
+                permalink_short = f"https://{permalink_viewer_url}/?sid={short_id}"
+            else: # Shortening failed or conflict not resolved to a usable short_id
+                permalink_short = None 
+                print(f"URL shortening status: {status} for {permalink}")
+
+            return {
+                "response": response,
+                "permalink": permalink,
+                "short_permalink": permalink_short
+            }
+        else: # generate_permalink returned None (criteria not met)
+            return {
+                "response": response, # Still return upload response
+                "permalink": None,
+                "short_permalink": None
+            }
 
     # Otherwise, return individual tuples for each file.
     return [(response, link) for link in individual_links]
+
+def _generate_short_id(length=8):
+    """Generates a random base64 URL-safe string."""
+    return base64.urlsafe_b64encode(os.urandom(length * 2))[:length].decode('utf-8')
+
+def _get_json_from_repo(repo_id, json_file_name, repo_type="dataset"):
+    """Downloads and loads the JSON file from the repo. Returns empty list if not found or error."""
+    try:
+        login(token=HF_API_TOKEN)
+        json_path = hf_hub_download(
+            repo_id=repo_id,
+            filename=json_file_name,
+            repo_type=repo_type,
+            token=HF_API_TOKEN  # Added token for consistency, though login might suffice
+        )
+        with open(json_path, 'r') as f:
+            data = json.load(f)
+        os.remove(json_path) # Clean up downloaded file
+        return data
+    except RepositoryNotFoundError:
+        print(f"Repository {repo_id} not found.")
+        return []
+    except EntryNotFoundError:
+        print(f"JSON file {json_file_name} not found in {repo_id}. Initializing with empty list.")
+        return []
+    except json.JSONDecodeError:
+        print(f"Error decoding JSON from {json_file_name}. Returning empty list.")
+        return []
+    except Exception as e:
+        print(f"An unexpected error occurred while fetching {json_file_name}: {e}")
+        return []
+
+def _upload_json_to_repo(data, repo_id, json_file_name, repo_type="dataset"):
+    """Uploads the JSON data to the specified file in the repo."""
+    try:
+        login(token=HF_API_TOKEN)
+        api = HfApi()
+        # Use a temporary directory specified by TMPDIR or default to system temp
+        temp_dir_for_json = os.getenv("TMPDIR", tempfile.gettempdir())
+        os.makedirs(temp_dir_for_json, exist_ok=True)
+
+        with tempfile.NamedTemporaryFile(mode="w+", delete=False, suffix=".json", dir=temp_dir_for_json) as tmp_file:
+            json.dump(data, tmp_file, indent=2)
+            tmp_file_path = tmp_file.name
+        
+        api.upload_file(
+            path_or_fileobj=tmp_file_path,
+            path_in_repo=json_file_name,
+            repo_id=repo_id,
+            repo_type=repo_type,
+            commit_message=f"Update {json_file_name}"
+        )
+        os.remove(tmp_file_path) # Clean up temporary file
+        return True
+    except Exception as e:
+        print(f"Failed to upload {json_file_name} to {repo_id}: {e}")
+        if 'tmp_file_path' in locals() and os.path.exists(tmp_file_path):
+            os.remove(tmp_file_path) # Ensure cleanup on error too
+        return False
+
+def _find_url_in_json(data, short_url=None, full_url=None):
+    """
+    Searches the JSON data.
+    If short_url is provided, returns the corresponding full_url or None.
+    If full_url is provided, returns the corresponding short_url or None.
+    """
+    if not data: # Handles cases where data might be None or empty
+        return None
+    if short_url:
+        for item in data:
+            if item.get("short_url") == short_url:
+                return item.get("full_url")
+    if full_url:
+        for item in data:
+            if item.get("full_url") == full_url:
+                return item.get("short_url")
+    return None
+
+def _add_url_to_json(data, short_url, full_url):
+    """Adds a new short_url/full_url pair to the data. Returns updated data."""
+    if data is None: 
+        data = []
+    data.append({"short_url": short_url, "full_url": full_url})
+    return data
+
+def gen_full_url(short_url=None, full_url=None, repo_id=None, repo_type="dataset", permalink_viewer_url="surn-3d-viewer.hf.space", json_file="shortener.json"):
+    """
+    Manages short URLs and their corresponding full URLs in a JSON file stored in a Hugging Face repository.
+
+    - If short_url is provided, attempts to retrieve and return the full_url.
+    - If full_url is provided, attempts to retrieve an existing short_url or creates a new one, stores it, and returns the short_url.
+    - If both are provided, checks for consistency or creates a new entry.
+    - If neither is provided, or repo_id is missing, returns an error status.
+
+    Returns:
+        tuple: (status_message, result_url)
+               status_message can be "success", "created", "exists", "error", "not_found".
+               result_url is the relevant URL (short or full) or None if an error occurs or not found.
+    """
+    if not repo_id:
+        return "error_repo_id_missing", None
+    if not short_url and not full_url:
+        return "error_no_input", None
+
+    login(token=HF_API_TOKEN) # Ensure login at the beginning
+    url_data = _get_json_from_repo(repo_id, json_file, repo_type)
+
+    # Case 1: Only short_url provided (lookup full_url)
+    if short_url and not full_url:
+        found_full_url = _find_url_in_json(url_data, short_url=short_url)
+        return ("success_retrieved_full", found_full_url) if found_full_url else ("not_found_short", None)
+
+    # Case 2: Only full_url provided (lookup or create short_url)
+    if full_url and not short_url:
+        existing_short_url = _find_url_in_json(url_data, full_url=full_url)
+        if existing_short_url:
+            return "success_retrieved_short", existing_short_url
+        else:
+            # Create new short_url
+            new_short_id = _generate_short_id()
+            url_data = _add_url_to_json(url_data, new_short_id, full_url)
+            if _upload_json_to_repo(url_data, repo_id, json_file, repo_type):
+                return "created_short", new_short_id 
+            else:
+                return "error_upload", None
+
+    # Case 3: Both short_url and full_url provided
+    if short_url and full_url:
+        found_full_for_short = _find_url_in_json(url_data, short_url=short_url)
+        found_short_for_full = _find_url_in_json(url_data, full_url=full_url)
+
+        if found_full_for_short == full_url: 
+            return "exists_match", short_url 
+        if found_full_for_short is not None and found_full_for_short != full_url: 
+            return "error_conflict_short_exists_different_full", short_url
+        if found_short_for_full is not None and found_short_for_full != short_url:
+            return "error_conflict_full_exists_different_short", found_short_for_full
+        
+        # If short_url is provided and not found, or full_url is provided and not found,
+        # or neither is found, then create a new entry with the provided short_url and full_url.
+        # This effectively allows specifying a custom short_url if it's not already taken.
+        url_data = _add_url_to_json(url_data, short_url, full_url)
+        if _upload_json_to_repo(url_data, repo_id, json_file, repo_type):
+            return "created_specific_pair", short_url
+        else:
+            return "error_upload", None
+                
+    return "error_unhandled_case", None # Should not be reached

utils/version_info.py

@@ -103,6 +103,15 @@ def versions_html():
         </a>
     '''
 
+    # Add a link to the shortener JSON file in the Hugging Face repo
+    from utils.constants import HF_REPO_ID, SHORTENER_JSON_FILE # Import constants
+    shortener_url = f"https://huggingface.co/datasets/{HF_REPO_ID}/resolve/main/{SHORTENER_JSON_FILE}"
+    shortener_link = f'''
+        <a href="{shortener_url}" target="_blank" style="cursor: pointer; text-decoration: underline;">
+            View Shortener JSON
+        </a>
+    '''
+
     v_html = f"""
         version: <a href="https://huggingface.co/spaces/Surn/HexaGrid/commit/{"huggingface" if commit == "<none>" else commit}" target="_blank">{"huggingface" if commit == "<none>" else commit}</a>
         &#x2000;•&#x2000;
@@ -123,6 +132,8 @@ def versions_html():
         gradio: {gr.__version__}
         &#x2000;•&#x2000;
         {toggle_dark_link}
+        &#x2000;•&#x2000;
+        {shortener_link}
         <br>
         Full GPU Info:{get_torch_info()}
         """