Add shortened URL and Open Graph

README.md

@@ -4,7 +4,7 @@ emoji: 👀
 colorFrom: yellow
 colorTo: blue
 sdk: gradio
-sdk_version: 5.29.1
+sdk_version: 5.31.0
 python_version: 3.12.8
 license: apache-2.0
 app_file: app.py

app.py

@@ -5,10 +5,45 @@ import modules.constants as constants
 import modules.version_info as version_info
 import modules.storage as storage
 
+import urllib.request
+from urllib.parse import urlparse, parse_qs, urlencode
 
 user_dir = constants.TMPDIR
 default_folder = "saved_models/3d_model_" + format(random.randint(1, 999999), "06d")
 
+def _resolve_short_id_to_query_params(query_params: dict) -> dict:
+    """
+    Checks for a 'sid' (short ID) in query_params. If found, attempts to resolve
+    it to a full URL and updates query_params with the parameters ('3d', 'hm', 'image')
+    from the resolved URL.
+    """
+    short_id = query_params.get("sid")
+    if short_id:
+        status, full_url_from_shortener = storage.gen_full_url(
+            short_url=short_id,
+            repo_id=constants.HF_REPO_ID,
+            json_file=constants.SHORTENER_JSON_FILE
+        )
+        if status == "success_retrieved_full" and full_url_from_shortener:
+            print(f"Retrieved full URL from short ID '{short_id}': {full_url_from_shortener}")
+            try:
+                parsed_full_url = urlparse(full_url_from_shortener)
+                retrieved_params = parse_qs(parsed_full_url.query)
+                
+                # Update query_params with those from the full_url_from_shortener
+                # The parse_qs function returns lists for values, so get the first element.
+                # If a param is not in the resolved URL, it will be set to None.
+                query_params["3d"] = retrieved_params.get("3d", [None])[0]
+                query_params["hm"] = retrieved_params.get("hm", [None])[0]
+                query_params["image"] = retrieved_params.get("image", [None])[0]
+            except Exception as e:
+                print(f"Error parsing full URL from shortener: {e}")
+                # Proceed with original query_params if parsing fails (i.e., don't overwrite them with Nones here)
+        else:
+            print(f"Failed to retrieve full URL for short ID '{short_id}': {status}")
+            # If sid resolution fails, original query_params (including potentially 3d, hm, image if passed alongside sid) remain.
+    return query_params
+
 def getVersions():
     #return html_versions
     return version_info.versions_html()
@@ -30,8 +65,6 @@ def process_url(url, default_ext=".png"):
     
     # Parse URL to get components
     try:
-        import urllib.request
-        from urllib.parse import urlparse
         
         # Create filename from URL.
         parsed_url = urlparse(url)
@@ -98,7 +131,6 @@ def process_url(url, default_ext=".png"):
         print(f"Error downloading file {url}: {e}")
         return url  # Return original URL if download fails
 
-
 def load_data(request: gr.Request, model_3d, image_slider):
     """
     Load data from query parameters, download files if needed,
@@ -121,15 +153,19 @@ def load_data(request: gr.Request, model_3d, image_slider):
     # Parse query parameters.
     query_params = dict(request.query_params) if request is not None else {}
     
-    # Extract URLs from query parameters.
+    # Resolve short ID if present
+    query_params = _resolve_short_id_to_query_params(query_params)
+
+    # Extract URLs from query parameters (which may have been updated)
     model_url = query_params.get("3d", None)
     hm_url = query_params.get("hm", None)
     img_url = query_params.get("image", None)
 
-    if model_url is None and hm_url is None and img_url is None:
-        # No URLs provided, return default values.
-        query_params = {}
-    
+    # Check if any relevant parameters are set to decide if we should clear query_params for permalink generation
+    # This logic ensures that if only 'sid' was passed and it resolved, query_params will now contain 3d, hm, image.
+    # If 'sid' was passed but didn't resolve, or no params were passed, then model_url, hm_url, img_url will be None.
+    has_loadable_params = bool(model_url or hm_url or img_url)
+
     # Process the model URL if provided.
     if model_url:
         model_url = process_url(model_url, default_ext=".glb")
@@ -143,25 +179,33 @@ def load_data(request: gr.Request, model_3d, image_slider):
     if hm_url:
         local_hm = process_url(hm_url, default_ext=".png")
         if local_hm:
-            slider_images.append(local_hm)
+            if not slider_images or local_hm != slider_images[0]:
+                if len(slider_images) == 1 and img_url:
+                    slider_images.append(local_hm)
+                else:
+                    slider_images = [local_hm] + slider_images
+                    slider_images = slider_images[:2]
 
     
-    # Set default values if no URLs provided:
-    default_model = getattr(model_3d, "value", model_3d)
-    default_images = getattr(image_slider, "value", image_slider)
+    # Set default values if no URLs provided or processed:
+    default_model_val = getattr(model_3d, "value", model_3d)
+    default_images_val = getattr(image_slider, "value", image_slider)
     
     if not slider_images:
-        slider_images = default_images if not default_images == (None,None) else constants.default_slider_images
+        slider_images = default_images_val if default_images_val and default_images_val != (None, None) else constants.default_slider_images
         
     if not model_url:
-        model_url = default_model if default_model else constants.default_model_3d
+        model_url = default_model_val if default_model_val else constants.default_model_3d
 
-    # If any query parameters were provided, generate a permalink.
+    # If any loadable query parameters were effectively present (either directly or via sid), generate a permalink.
     permalink = ""
-    if query_params:
+    if has_loadable_params:
         try:
-            # Use the helper function defined in storage.py
-            permalink = storage.generate_permalink_from_urls(model_url, hm_url, img_url)
+            permalink_model_url = query_params.get("3d", model_url) 
+            permalink_hm_url = query_params.get("hm", hm_url if len(slider_images) > 1 and hm_url else (slider_images[1] if len(slider_images) > 1 else None) )
+            permalink_img_url = query_params.get("image", img_url if slider_images and img_url else (slider_images[0] if slider_images else None) )
+
+            permalink = storage.generate_permalink_from_urls(permalink_model_url, permalink_hm_url, permalink_img_url)
         except Exception as e:
             print(f"Error generating permalink: {e}")
     
@@ -212,21 +256,70 @@ def process_upload(files, current_model, current_images):
     
     # For the image slider, we expect a list of exactly 2 images.
     # Start with current images (or use defaults if None).
-    if current_images is None or not isinstance(current_images, list):
+    if current_images is None or not isinstance(current_images, list) or len(current_images) == 0:
         new_images = [None, None]
     else:
-        new_images = current_images + [None] * (2 - len(current_images))
-        new_images = new_images[:2]
-    
-    # If at least one image is uploaded, update the corresponding slot(s).
-    for i in range(len(extracted_images)):
-        if i < 2:
-            new_images[i] = extracted_images[i]
-    
+        new_images = current_images[:2]
+        if len(new_images) < 2:
+            new_images.append(None)
+
+    if len(extracted_images) == 1:
+        new_images[0] = extracted_images[0]
+    elif len(extracted_images) == 2:
+        new_images[0] = extracted_images[0]
+        new_images[1] = extracted_images[1]
+        
     return updated_model, new_images
 
+def get_open_graph_meta_tags(query_params):
+    """Generates Open Graph meta tags based on query parameters."""
+    og_title = constants.DEFAULT_OG_TITLE
+    og_description = constants.DEFAULT_OG_DESCRIPTION
+    og_image = constants.DEFAULT_OG_IMAGE_URL
+    og_type = constants.DEFAULT_OG_TYPE
+    og_url = constants.APP_BASE_URL
+
+    img_url_from_query = query_params.get("image")
+    if img_url_from_query:
+        og_image = img_url_from_query
+        
+        model_url_from_query = query_params.get("3d")
+        if model_url_from_query:
+            try:
+                model_filename = os.path.basename(urlparse(model_url_from_query).path)
+                if model_filename:
+                     og_title = f"3D Viewer: {model_filename}"
+                else:
+                    og_title = f"Shared 3D Model" 
+            except Exception:
+                og_title = "Shared 3D Model"
+        else:
+            og_title = "Shared Image"
+    
+    if query_params:
+        filtered_query_params = {k: v for k, v in query_params.items() if v is not None}
+        if filtered_query_params:
+             og_url += "?" + urlencode(filtered_query_params)
+
+    meta_tags = f'''
+        <meta property="og:title" content="{og_title}" />
+        <meta property="og:description" content="{og_description}" />
+        <meta property="og:image" content="{og_image}" />
+        <meta property="og:url" content="{og_url}" />
+        <meta property="og:type" content="{og_type}" />
+        <meta name="twitter:card" content="summary_large_image">
+        <meta name="twitter:title" content="{og_title}">
+        <meta name="twitter:description" content="{og_description}">
+        <meta name="twitter:image" content="{og_image}">
+    '''
+    return meta_tags
+
+placeholder_initial_query_params = {} 
+processed_placeholder_params = _resolve_short_id_to_query_params(placeholder_initial_query_params)
+initial_og_tags = get_open_graph_meta_tags(processed_placeholder_params)
+
 gr.set_static_paths(paths=["images/", "models/", "assets/"])
-with gr.Blocks(css_paths="style_20250503.css", title="3D viewer", theme='Surn/beeuty',delete_cache=(21600,86400), fill_width=True) as viewer3d:
+with gr.Blocks(css_paths="style_20250503.css", title="3D viewer", theme='Surn/beeuty',delete_cache=(21600,86400), fill_width=True, head=initial_og_tags) as viewer3d:
     gr.Markdown("# 3D Model Viewer")
     
     with gr.Row():
@@ -257,7 +350,6 @@ with gr.Blocks(css_paths="style_20250503.css", title="3D viewer", theme='Surn/be
                 )
         
             with gr.Row():
-                # New textbox for folder name.
                 folder_name_box = gr.Textbox(
                     label="Folder Name",
                     value=default_folder,
@@ -282,15 +374,12 @@ with gr.Blocks(css_paths="style_20250503.css", title="3D viewer", theme='Surn/be
     with gr.Row():
         gr.HTML(value=getVersions(), visible=True, elem_id="versions")
     
-    # Use JavaScript to pass the query parameters to your callback.
     viewer3d.load(
         load_data,
         inputs=[model_3d, image_slider],
         outputs=[model_3d, image_slider, permalink],
         scroll_to_output=True
     ).then(
-        # If the returned permalink (link) is non-empty then make the permalink row visible
-        # and disable the permalink button; otherwise, hide the row and enable the button.
         lambda link: (gr.update(visible=True), gr.update(interactive=False))
             if link and len(link) > 0
             else (gr.update(visible=False), gr.update(interactive=True)),
@@ -298,7 +387,6 @@ with gr.Blocks(css_paths="style_20250503.css", title="3D viewer", theme='Surn/be
         outputs=[permalink_row, permalink_button]
     )
 
-    # Process uploaded files to update the Model3D or ImageSlider component.
     upload_btn.upload(
         process_upload, 
         inputs=[upload_btn, model_3d, image_slider],
@@ -307,20 +395,18 @@ with gr.Blocks(css_paths="style_20250503.css", title="3D viewer", theme='Surn/be
         api_name="process_upload",
         show_progress=True
     ).then(
-        # After a successful upload, enable the permalink button.
         lambda m, i: gr.update(interactive=True),
         inputs=[model_3d, image_slider],
         outputs=[permalink_button]
     )
-    # Generate a permalink based on the current model, images, and folder name.
     permalink_button.click(
         lambda model, images, folder: storage.upload_files_to_repo(
-            files=[model] + list(images),
-            repo_id="Surn/Storage",
+            files=[model] + list(images if images else []),
+            repo_id=constants.HF_REPO_ID,
             folder_name=folder,
             create_permalink=True,
             repo_type="dataset"
-        )[1],  # Extract the permalink from the returned tuple if criteria met.
+        )[1],
         inputs=[model_3d, image_slider, folder_name_box],
         outputs=[permalink],
         scroll_to_output=True

modules/constants.py

@@ -34,4 +34,15 @@ default_slider_images = [
             "images/slider/beeuty_545jlbh1_v12_alpha96_300dpi_depth.png"
         ]
 
-default_model_3d = "models/beeuty_545jlbh1_300dpi.glb"
+default_model_3d = "models/beeuty_545jlbh1_300dpi.glb"
+
+# Constants for URL shortener
+HF_REPO_ID = "Surn/Storage"  # Replace with your Hugging Face repository ID
+SHORTENER_JSON_FILE = "shortener.json"  # The name of your JSON file in the repo
+
+# Open Graph Defaults
+APP_BASE_URL = "https://surn-3d-viewer.hf.space" # Replace if your app URL is different
+DEFAULT_OG_TITLE = "3D Viewer"
+DEFAULT_OG_DESCRIPTION = "View and share 3D models and images interactively."
+DEFAULT_OG_IMAGE_URL = APP_BASE_URL + "/gradio_api/file=" + default_slider_images[0]
+DEFAULT_OG_TYPE = "website"

modules/storage.py

@@ -3,7 +3,10 @@ import os
 import urllib.parse
 import tempfile
 import shutil
-from huggingface_hub import login, upload_folder
+import json
+import base64
+from huggingface_hub import login, upload_folder, hf_hub_download, HfApi
+from huggingface_hub.utils import RepositoryNotFoundError, EntryNotFoundError
 from modules.constants import HF_API_TOKEN, upload_file_types, model_extensions, image_extensions
 
 def generate_permalink(valid_files, base_url_external, permalink_viewer_url="surn-3d-viewer.hf.space"):
@@ -125,3 +128,169 @@ def upload_files_to_repo(files, repo_id, folder_name, create_permalink=False, re
 
     # 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()
+        with tempfile.NamedTemporaryFile(mode="w+", delete=False, suffix=".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: # Initialize 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)
+        if found_full_url:
+            return "success_retrieved_full", found_full_url
+        else:
+            return "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()
+            # Construct the short URL using the permalink_viewer_url and the new_short_id as a query parameter or path
+            # For this example, let's assume short URLs are like: https://permalink_viewer_url/?id=new_short_id
+            # This part might need adjustment based on how you want to structure your short URLs.
+            # A common pattern is permalink_viewer_url/new_short_id if the viewer can handle path-based routing.
+            # Or, if the viewer expects a query param like `?short=new_short_id`
+            # For now, let's assume the short_url itself is just the ID, and the full viewer URL is prepended elsewhere if needed.
+            # Or, more directly, the `short_url` parameter to this function *is* the ID.
+            # The request implies `short_url` is the *key* in the JSON.
+            
+            # Let's refine: the `short_url` stored in JSON is the ID. The "shortened URL" returned to user might be different.
+            # The function is `gen_full_url`, implying it can also *generate* a short URL if one doesn't exist for a full_url.
+            
+            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):
+                # The value returned as "shortened_url" should be the ID itself, or a URL constructed with it.
+                # Let's return the ID for now, as the prompt asks for "shortened_url" as output.
+                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 and found_full_for_short == full_url: # Both exist and match
+            return "exists_match", short_url 
+        elif found_short_for_full and found_short_for_full == short_url: # Both exist and match (redundant check, but safe)
+             return "exists_match", short_url
+        elif found_full_for_short and found_full_for_short != full_url: # short_url exists but maps to a different full_url
+            return "error_conflict_short_exists", short_url # Or perhaps update, depending on desired behavior
+        elif found_short_for_full and found_short_for_full != short_url: # full_url exists but maps to a different short_url
+             # This implies the user provided a short_url that is *not* the one already associated with this full_url.
+             # We should probably return the *existing* short_url for that full_url.
+            return "exists_full_maps_to_different_short", found_short_for_full
+        else: # Neither exists, or one exists but not the pair. Create new entry.
+            # Check if the provided short_url is already in use by another full_url
+            if _find_url_in_json(url_data, short_url=short_url) is not None:
+                return "error_conflict_short_id_taken", short_url
+
+            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