change methodology to save file

.gitignore

@@ -0,0 +1,44 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+ENV/
+.env
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Logs
+*.log
+
+# Image uploads and metadata - keep directories but ignore content
+static/uploads/*
+!static/uploads/.gitkeep
+static/metadata/*
+!static/metadata/.gitkeep
+
+# Hugging Face
+.huggingface/ 

Dockerfile

@@ -35,6 +35,15 @@ ENV ENV=production
 # ENV HF_TOKEN=your-token  
 # ENV HF_DATASET_REPO=image-uploader-data
 
+# Add script to download images from Hugging Face during build
+COPY download_images.py .
+RUN if [ -n "$HF_USERNAME" ] && [ -n "$HF_TOKEN" ] && [ -n "$HF_DATASET_REPO" ]; then \
+    echo "Downloading images from Hugging Face dataset..." && \
+    python download_images.py; \
+    else \
+    echo "Hugging Face credentials not set, skipping image download."; \
+    fi
+
 # Expose port for Hugging Face Spaces (uses port 7860)
 EXPOSE 7860
 

app.py

@@ -63,6 +63,9 @@ HF_TOKEN = os.environ.get("HF_TOKEN", "")  # Set this in Hugging Face Space sett
 DATASET_REPO = os.environ.get("HF_DATASET_REPO", "image-uploader-data")
 IMAGES_PATH = "images"
 METADATA_PATH = "metadata"
+SPACE_NAME = os.environ.get(
+    "HF_SPACE_NAME", ""
+)  # Add this environment variable for the Space name
 
 # Set HF cache directory to a writable location
 # This is necessary for Hugging Face Spaces which has permission issues with the default cache location
@@ -136,34 +139,45 @@ def verify_auth(request: Request):
     return True
 
 def get_image_metadata():
-    """Get all image metadata including hashtags."""
-    # In production, get metadata from Hugging Face
-    if os.environ.get("ENV", "development") == "production" and HF_USERNAME and HF_TOKEN:
-        try:
-            print(f"Fetching metadata from Hugging Face repository {HF_USERNAME}/{DATASET_REPO}")
-            metadata_file = hf_api.hf_hub_download(
-                repo_id=f"{HF_USERNAME}/{DATASET_REPO}",
-                filename=f"{METADATA_PATH}/image_metadata.json",
-                repo_type="dataset",
-                token=HF_TOKEN,
-                local_dir=os.path.join(tempfile.gettempdir(), "hf_downloads")
-            )
-            print(f"Metadata downloaded to {metadata_file}")
-            with open(metadata_file, "r") as f:
-                return json.load(f)
-        except Exception as e:
-            print(f"Error fetching metadata from Hugging Face: {e}")
-            # Return empty dict if failed
-            return {}
-    # Local development fallback
-    elif METADATA_FILE.exists():
+    """Get all image metadata including hashtags from local storage and sync with HF if needed."""
+    if METADATA_FILE.exists():
         with open(METADATA_FILE, "r") as f:
-            return json.load(f)
+            metadata = json.load(f)
+
+        # In production, sync metadata to Hugging Face if it exists locally but not on HF
+        if (
+            os.environ.get("ENV", "development") == "production"
+            and HF_USERNAME
+            and HF_TOKEN
+        ):
+            try:
+                # Only upload if there are changes (we'd need to implement a proper change tracking mechanism)
+                # For now, we'll upload every time to ensure consistency
+                metadata_str = json.dumps(metadata)
+                hf_api.upload_file(
+                    path_or_fileobj=io.BytesIO(metadata_str.encode()),
+                    path_in_repo=f"{METADATA_PATH}/image_metadata.json",
+                    repo_id=f"{HF_USERNAME}/{DATASET_REPO}",
+                    repo_type="dataset",
+                    token=HF_TOKEN,
+                )
+            except Exception as e:
+                print(f"Error syncing metadata to Hugging Face: {e}")
+
+        return metadata
+
+    # If metadata file doesn't exist locally, create it
+    with open(METADATA_FILE, "w") as f:
+        json.dump({}, f)
     return {}
 
 def save_image_metadata(metadata):
-    """Save image metadata to the JSON file."""
-    # In production, save to Hugging Face
+    """Save image metadata to the local JSON file and sync with HF."""
+    # Always save locally first
+    with open(METADATA_FILE, "w") as f:
+        json.dump(metadata, f)
+
+    # In production, also save to Hugging Face
     if os.environ.get("ENV", "development") == "production" and HF_USERNAME and HF_TOKEN:
         try:
             print(f"Saving metadata to Hugging Face repository {HF_USERNAME}/{DATASET_REPO}")
@@ -175,16 +189,9 @@ def save_image_metadata(metadata):
                 repo_type="dataset",
                 token=HF_TOKEN
             )
-            print(f"Metadata saved successfully")
+            print(f"Metadata saved successfully to Hugging Face")
         except Exception as e:
             print(f"Error saving metadata to Hugging Face: {e}")
-            # Still save locally as fallback
-            with open(METADATA_FILE, "w") as f:
-                json.dump(metadata, f)
-    else:
-        # Local development or fallback
-        with open(METADATA_FILE, "w") as f:
-            json.dump(metadata, f)
 
 def add_hashtags_to_image(filename, hashtags, original_filename=None):
     """Add hashtags to an image."""
@@ -210,46 +217,12 @@ def mark_image_as_viewed(filename):
         metadata[filename]["is_new"] = False
         save_image_metadata(metadata)
 
-def upload_to_hf(file_content, filename):
-    """Upload a file to Hugging Face Dataset Repository."""
-    if os.environ.get("ENV", "development") == "production" and HF_USERNAME and HF_TOKEN:
-        try:
-            print(f"Uploading file {filename} to Hugging Face repository {HF_USERNAME}/{DATASET_REPO}")
-            hf_api.upload_file(
-                path_or_fileobj=io.BytesIO(file_content),
-                path_in_repo=f"{IMAGES_PATH}/{filename}",
-                repo_id=f"{HF_USERNAME}/{DATASET_REPO}",
-                repo_type="dataset",
-                token=HF_TOKEN
-            )
-            print(f"File {filename} uploaded successfully")
-            return True
-        except Exception as e:
-            print(f"Error uploading to Hugging Face: {e}")
-            return False
-    return False
-
-def delete_from_hf(filename):
-    """Delete a file from Hugging Face Dataset Repository."""
-    if os.environ.get("ENV", "development") == "production" and HF_USERNAME and HF_TOKEN:
-        try:
-            print(f"Deleting file {filename} from Hugging Face repository {HF_USERNAME}/{DATASET_REPO}")
-            hf_api.delete_file(
-                path_in_repo=f"{IMAGES_PATH}/{filename}",
-                repo_id=f"{HF_USERNAME}/{DATASET_REPO}",
-                repo_type="dataset",
-                token=HF_TOKEN
-            )
-            print(f"File {filename} deleted successfully")
-            return True
-        except Exception as e:
-            print(f"Error deleting from Hugging Face: {e}")
-            return False
-    return False
-
 def get_hf_image_url(filename):
     """Get the URL for an image in the Hugging Face repo."""
-    if HF_USERNAME:
+    # Return the direct Space URL if available, otherwise use dataset URL
+    if SPACE_NAME and HF_USERNAME:
+        return f"https://{HF_USERNAME}-{SPACE_NAME}.hf.space/static/uploads/{filename}"
+    elif HF_USERNAME:
         return f"https://huggingface.co/datasets/{HF_USERNAME}/{DATASET_REPO}/resolve/main/{IMAGES_PATH}/{filename}"
     return None
 
@@ -309,81 +282,61 @@ async def home(request: Request, search: Optional[str] = None, tag: Optional[str
     # Check if user is authenticated
     if not authenticate(request):
         return RedirectResponse(url="/login", status_code=status.HTTP_302_FOUND)
-    
+
     # Get all uploaded images and their metadata
     uploaded_images = []
     metadata = get_image_metadata()
-    
-    # In production environment, get images from Hugging Face
-    if os.environ.get("ENV", "development") == "production" and HF_USERNAME:
-        hf_images = list_hf_images()
-        
-        for file_name in hf_images:
-            # Get hashtags from metadata if available
-            hashtags = []
-            is_new = False
-            original_filename = file_name
-            
-            if file_name in metadata:
-                hashtags = metadata[file_name].get("hashtags", [])
-                is_new = metadata[file_name].get("is_new", False)
-                original_filename = metadata[file_name].get("original_filename", file_name)
-            
-            # If searching/filtering, check if this image should be included
-            if search and search.lower() not in original_filename.lower() and not any(search.lower() in tag.lower() for tag in hashtags):
-                continue
-                
-            if tag and tag not in hashtags:
-                continue
-            
-            image_url = get_hf_image_url(file_name)
-            
-            uploaded_images.append({
-                "name": file_name,
-                "url": image_url,
-                "embed_url": image_url,
-                "hashtags": hashtags,
-                "is_new": is_new,
-                "original_filename": original_filename
-            })
-    # Local development fallback
-    elif UPLOAD_DIR.exists():
+
+    if UPLOAD_DIR.exists():
         for file in UPLOAD_DIR.iterdir():
             if is_valid_image(get_file_extension(file.name)):
-                image_url = f"/static/uploads/{file.name}"
-                
                 # Get hashtags from metadata if available
                 hashtags = []
                 is_new = False
                 original_filename = file.name
-                
+
                 if file.name in metadata:
                     hashtags = metadata[file.name].get("hashtags", [])
                     is_new = metadata[file.name].get("is_new", False)
                     original_filename = metadata[file.name].get("original_filename", file.name)
-                
+
                 # If searching/filtering, check if this image should be included
                 if search and search.lower() not in original_filename.lower() and not any(search.lower() in tag.lower() for tag in hashtags):
                     continue
-                    
+
                 if tag and tag not in hashtags:
                     continue
-                
-                uploaded_images.append({
-                    "name": file.name,
-                    "url": image_url,
-                    "embed_url": f"{request.base_url}static/uploads/{file.name}",
-                    "hashtags": hashtags,
-                    "is_new": is_new,
-                    "original_filename": original_filename
-                })
-    
+
+                # Local URL for display
+                image_url = f"/static/uploads/{file.name}"
+
+                # Full URL for embedding (use Space URL in production if available)
+                if (
+                    SPACE_NAME
+                    and HF_USERNAME
+                    and os.environ.get("ENV", "development") == "production"
+                ):
+                    embed_url = f"https://{HF_USERNAME}-{SPACE_NAME}.hf.space/static/uploads/{file.name}"
+                else:
+                    embed_url = f"{request.base_url}static/uploads/{file.name}"
+
+                uploaded_images.append(
+                    {
+                        "name": file.name,
+                        "url": image_url,
+                        "embed_url": embed_url,
+                        "hashtags": hashtags,
+                        "is_new": is_new,
+                        "original_filename": original_filename,
+                    }
+                )
+
     # Get all unique hashtags for the filter dropdown
     all_hashtags = set()
     for img_data in metadata.values():
         if "hashtags" in img_data:
             all_hashtags.update(img_data["hashtags"])
-    
+
     return templates.TemplateResponse(
         "index.html", 
         {
@@ -395,6 +348,86 @@ async def home(request: Request, search: Optional[str] = None, tag: Optional[str
         }
     )
 
+
+def upload_to_hf_and_local(file_content, filename):
+    """Upload a file to both Hugging Face Dataset Repository and local storage."""
+    local_success = False
+    hf_success = False
+
+    # Save locally first
+    try:
+        file_path = UPLOAD_DIR / filename
+        with file_path.open("wb") as buffer:
+            buffer.write(file_content)
+        local_success = True
+        print(f"File {filename} saved locally")
+    except Exception as e:
+        print(f"Error saving file locally: {e}")
+
+    # Then upload to Hugging Face if in production
+    if (
+        os.environ.get("ENV", "development") == "production"
+        and HF_USERNAME
+        and HF_TOKEN
+    ):
+        try:
+            print(
+                f"Uploading file {filename} to Hugging Face repository {HF_USERNAME}/{DATASET_REPO}"
+            )
+            hf_api.upload_file(
+                path_or_fileobj=io.BytesIO(file_content),
+                path_in_repo=f"{IMAGES_PATH}/{filename}",
+                repo_id=f"{HF_USERNAME}/{DATASET_REPO}",
+                repo_type="dataset",
+                token=HF_TOKEN,
+            )
+            print(f"File {filename} uploaded successfully to Hugging Face")
+            hf_success = True
+        except Exception as e:
+            print(f"Error uploading to Hugging Face: {e}")
+
+    return local_success or hf_success
+
+
+def delete_from_hf_and_local(filename):
+    """Delete a file from both Hugging Face Dataset Repository and local storage."""
+    local_success = False
+    hf_success = False
+
+    # Delete locally first
+    file_path = UPLOAD_DIR / filename
+    if file_path.exists():
+        try:
+            os.remove(file_path)
+            local_success = True
+            print(f"File {filename} deleted locally")
+        except Exception as e:
+            print(f"Error deleting file locally: {e}")
+
+    # Then delete from Hugging Face if in production
+    if (
+        os.environ.get("ENV", "development") == "production"
+        and HF_USERNAME
+        and HF_TOKEN
+    ):
+        try:
+            print(
+                f"Deleting file {filename} from Hugging Face repository {HF_USERNAME}/{DATASET_REPO}"
+            )
+            hf_api.delete_file(
+                path_in_repo=f"{IMAGES_PATH}/{filename}",
+                repo_id=f"{HF_USERNAME}/{DATASET_REPO}",
+                repo_type="dataset",
+                token=HF_TOKEN,
+            )
+            print(f"File {filename} deleted successfully from Hugging Face")
+            hf_success = True
+        except Exception as e:
+            print(f"Error deleting from Hugging Face: {e}")
+
+    return local_success or hf_success
+
+
 @app.post("/upload/")
 async def upload_image(
     request: Request, 
@@ -408,31 +441,22 @@ async def upload_image(
             status_code=status.HTTP_401_UNAUTHORIZED,
             content={"detail": "Not authenticated"}
         )
-    
+
     # Process hashtags into a list
     hashtag_list = []
     if hashtags:
         # Split by spaces or commas and remove empty strings/whitespace
         hashtag_list = [tag.strip() for tag in hashtags.replace(',', ' ').split() if tag.strip()]
-    
+
     results = []
     duplicates = []
-    
+
     # First, check for duplicate filenames
     metadata = get_image_metadata()
     all_files = {}
-    
-    # In production, check for duplicates in Hugging Face repo
-    if os.environ.get("ENV", "development") == "production" and HF_USERNAME:
-        hf_images = list_hf_images()
-        for filename in hf_images:
-            # Get original filename from metadata if available
-            original_name = filename
-            if filename in metadata and "original_filename" in metadata[filename]:
-                original_name = metadata[filename]["original_filename"]
-            all_files[original_name.lower()] = filename
-    # Local development fallback
-    elif UPLOAD_DIR.exists():
+
+    # Check for duplicates in local storage first (should include HF images that were downloaded during build)
+    if UPLOAD_DIR.exists():
         for file in UPLOAD_DIR.iterdir():
             if is_valid_image(get_file_extension(file.name)):
                 # Get original filename from metadata if available
@@ -440,7 +464,7 @@ async def upload_image(
                 if file.name in metadata and "original_filename" in metadata[file.name]:
                     original_name = metadata[file.name]["original_filename"]
                 all_files[original_name.lower()] = file.name
-    
+
     # Check for duplicates in current upload batch
     for file in files:
         file_lower = file.filename.lower()
@@ -451,7 +475,7 @@ async def upload_image(
                 "existing_file": all_files[file_lower],
                 "original_name": file.filename
             })
-    
+
     # If we found duplicates, return them to the frontend for confirmation
     if duplicates:
         return {
@@ -460,45 +484,36 @@ async def upload_image(
             "message": "Duplicate filenames detected",
             "action_required": "confirm_replace"
         }
-    
+
     # No duplicates, proceed with upload
     for file in files:
         # Check if the file is an image
         extension = get_file_extension(file.filename)
         if not is_valid_image(extension):
             continue  # Skip non-image files
-        
+
         # Preserve original filename in metadata but make it safe for filesystem
         original_filename = file.filename
-        
+
         # Generate a unique filename to prevent overwrites
         unique_filename = f"{uuid.uuid4()}{extension}"
-        
+
         # Read file content for upload
         file.file.seek(0)
         file_content = await file.read()
-        
-        # Save file based on environment
-        if os.environ.get("ENV", "development") == "production" and HF_USERNAME and HF_TOKEN:
-            # Upload to Hugging Face
-            upload_success = upload_to_hf(file_content, unique_filename)
-            if not upload_success:
-                # Fallback to local storage if HF upload fails
-                file_path = UPLOAD_DIR / unique_filename
-                with file_path.open("wb") as buffer:
-                    buffer.write(file_content)
-        else:
-            # Local development storage
-            file_path = UPLOAD_DIR / unique_filename
-            with file_path.open("wb") as buffer:
-                buffer.write(file_content)
-        
+
+        # Save file to both local storage and Hugging Face
+        upload_success = upload_to_hf_and_local(file_content, unique_filename)
+
+        if not upload_success:
+            continue  # Skip to next file if upload failed
+
         # Save hashtags and original filename
         add_hashtags_to_image(unique_filename, hashtag_list, original_filename)
-        
+
         # For base64 encoding
         base64_encoded = base64.b64encode(file_content).decode("utf-8")
-        
+
         # Determine MIME type
         mime_type = {
             '.jpg': 'image/jpeg',
@@ -508,15 +523,20 @@ async def upload_image(
             '.bmp': 'image/bmp',
             '.webp': 'image/webp'
         }.get(extension, 'application/octet-stream')
-        
-        # Get appropriate image URL based on environment
-        if os.environ.get("ENV", "development") == "production" and HF_USERNAME:
-            image_url = get_hf_image_url(unique_filename)
-            full_url = image_url
+
+        # Get direct image URL using Space URL if available
+        image_url = f"/static/uploads/{unique_filename}"  # Local URL
+
+        # Full URL for embedding
+        if (
+            SPACE_NAME
+            and HF_USERNAME
+            and os.environ.get("ENV", "development") == "production"
+        ):
+            full_url = f"https://{HF_USERNAME}-{SPACE_NAME}.hf.space/static/uploads/{unique_filename}"
         else:
-            image_url = f"/static/uploads/{unique_filename}"
             full_url = f"{request.base_url}static/uploads/{unique_filename}"
-        
+
         results.append({
             "success": True,
             "file_name": unique_filename,
@@ -528,7 +548,7 @@ async def upload_image(
             "base64_embed": f'<img src="data:{mime_type};base64,{base64_encoded}" alt="{original_filename}" />',
             "hashtags": hashtag_list
         })
-    
+
     if len(results) == 1:
         return results[0]
     else:
@@ -548,13 +568,13 @@ async def upload_with_replace(
             status_code=status.HTTP_401_UNAUTHORIZED,
             content={"detail": "Not authenticated"}
         )
-    
+
     # Process hashtags into a list
     hashtag_list = []
     if hashtags:
         # Split by spaces or commas and remove empty strings/whitespace
         hashtag_list = [tag.strip() for tag in hashtags.replace(',', ' ').split() if tag.strip()]
-    
+
     # Parse the replacement files JSON
     files_to_replace = []
     if replace_files:
@@ -562,72 +582,53 @@ async def upload_with_replace(
             files_to_replace = json.loads(replace_files)
         except json.JSONDecodeError:
             files_to_replace = []
-    
+
     # Create a map of original names to replacement decisions
     replace_map = {item["original_name"].lower(): item["existing_file"] for item in files_to_replace}
-    
+
     results = []
-    
+
     for file in files:
         # Check if the file is an image
         extension = get_file_extension(file.filename)
         if not is_valid_image(extension):
             continue  # Skip non-image files
-        
+
         # Preserve original filename in metadata
         original_filename = file.filename
         file_lower = original_filename.lower()
-        
+
         # Read file content
         file.file.seek(0)
         file_content = await file.read()
-        
+
         # Check if this file should replace an existing one
         if file_lower in replace_map:
-            # Delete the old file
+            # Delete the old file from both local storage and Hugging Face
             old_filename = replace_map[file_lower]
-            
-            if os.environ.get("ENV", "development") == "production" and HF_USERNAME and HF_TOKEN:
-                # Delete from Hugging Face
-                delete_success = delete_from_hf(old_filename)
-                if not delete_success:
-                    raise HTTPException(status_code=404, detail="Image not found or could not be deleted")
-            else:
-                # Delete from local storage
-                old_file = UPLOAD_DIR / old_filename
-                if old_file.exists():
-                    os.remove(old_file)
-                
+            delete_from_hf_and_local(old_filename)
+
             # Remove from metadata
             metadata = get_image_metadata()
             if old_filename in metadata:
                 del metadata[old_filename]
                 save_image_metadata(metadata)
-        
+
         # Generate a unique filename to prevent overwrites
         unique_filename = f"{uuid.uuid4()}{extension}"
-        
-        # Save file based on environment
-        if os.environ.get("ENV", "development") == "production" and HF_USERNAME and HF_TOKEN:
-            # Upload to Hugging Face
-            upload_success = upload_to_hf(file_content, unique_filename)
-            if not upload_success:
-                # Fallback to local storage if HF upload fails
-                file_path = UPLOAD_DIR / unique_filename
-                with file_path.open("wb") as buffer:
-                    buffer.write(file_content)
-        else:
-            # Local development storage
-            file_path = UPLOAD_DIR / unique_filename
-            with file_path.open("wb") as buffer:
-                buffer.write(file_content)
-        
+
+        # Upload to both local storage and Hugging Face
+        upload_success = upload_to_hf_and_local(file_content, unique_filename)
+
+        if not upload_success:
+            continue  # Skip to next file if upload failed
+
         # Save hashtags and original filename
         add_hashtags_to_image(unique_filename, hashtag_list, original_filename)
-        
+
         # For base64 encoding
         base64_encoded = base64.b64encode(file_content).decode("utf-8")
-        
+
         # Determine MIME type
         mime_type = {
             '.jpg': 'image/jpeg',
@@ -637,15 +638,20 @@ async def upload_with_replace(
             '.bmp': 'image/bmp',
             '.webp': 'image/webp'
         }.get(extension, 'application/octet-stream')
-        
-        # Get appropriate image URL based on environment
-        if os.environ.get("ENV", "development") == "production" and HF_USERNAME:
-            image_url = get_hf_image_url(unique_filename)
-            full_url = image_url
+
+        # Get direct image URL using Space URL if available
+        image_url = f"/static/uploads/{unique_filename}"  # Local URL
+
+        # Full URL for embedding
+        if (
+            SPACE_NAME
+            and HF_USERNAME
+            and os.environ.get("ENV", "development") == "production"
+        ):
+            full_url = f"https://{HF_USERNAME}-{SPACE_NAME}.hf.space/static/uploads/{unique_filename}"
         else:
-            image_url = f"/static/uploads/{unique_filename}"
             full_url = f"{request.base_url}static/uploads/{unique_filename}"
-        
+
         results.append({
             "success": True,
             "file_name": unique_filename,
@@ -657,7 +663,7 @@ async def upload_with_replace(
             "base64_embed": f'<img src="data:{mime_type};base64,{base64_encoded}" alt="{original_filename}" />',
             "hashtags": hashtag_list
         })
-    
+
     if len(results) == 1:
         return results[0]
     else:
@@ -669,36 +675,39 @@ async def view_image(request: Request, file_name: str):
     # Check if user is authenticated
     if not authenticate(request):
         return RedirectResponse(url="/login", status_code=status.HTTP_302_FOUND)
-    
+
     # Mark image as viewed (not new)
     mark_image_as_viewed(file_name)
-    
-    # Determine image URL based on environment
-    if os.environ.get("ENV", "development") == "production" and HF_USERNAME:
-        image_url = get_hf_image_url(file_name)
-        embed_url = image_url
-        
-        # Check if file exists in Hugging Face
-        if not image_url or file_name not in list_hf_images():
-            raise HTTPException(status_code=404, detail="Image not found")
+
+    # Check if file exists locally (should always be the case now)
+    file_path = UPLOAD_DIR / file_name
+    if not file_path.exists():
+        raise HTTPException(status_code=404, detail="Image not found")
+
+    # Local URL for rendering in template
+    image_url = f"/static/uploads/{file_name}"
+
+    # Full URL for embedding
+    if (
+        SPACE_NAME
+        and HF_USERNAME
+        and os.environ.get("ENV", "development") == "production"
+    ):
+        embed_url = (
+            f"https://{HF_USERNAME}-{SPACE_NAME}.hf.space/static/uploads/{file_name}"
+        )
     else:
-        # Check local file
-        file_path = UPLOAD_DIR / file_name
-        if not file_path.exists():
-            raise HTTPException(status_code=404, detail="Image not found")
-            
-        image_url = f"/static/uploads/{file_name}"
         embed_url = f"{request.base_url}static/uploads/{file_name}"
-    
+
     # Get metadata
     metadata = get_image_metadata()
     hashtags = []
     original_filename = file_name
-    
+
     if file_name in metadata:
         hashtags = metadata[file_name].get("hashtags", [])
         original_filename = metadata[file_name].get("original_filename", file_name)
-    
+
     return templates.TemplateResponse(
         "view.html", 
         {
@@ -750,26 +759,21 @@ async def delete_image(request: Request, file_name: str):
             status_code=status.HTTP_401_UNAUTHORIZED,
             content={"detail": "Not authenticated"}
         )
-    
-    # Delete file based on environment
-    if os.environ.get("ENV", "development") == "production" and HF_USERNAME and HF_TOKEN:
-        # Delete from Hugging Face
-        delete_success = delete_from_hf(file_name)
-        if not delete_success:
-            raise HTTPException(status_code=404, detail="Image not found or could not be deleted")
-    else:
-        # Delete from local storage
-        file_path = UPLOAD_DIR / file_name
-        if not file_path.exists():
-            raise HTTPException(status_code=404, detail="Image not found")
-        os.remove(file_path)
-    
+
+    # Delete from both local storage and Hugging Face
+    delete_success = delete_from_hf_and_local(file_name)
+
+    if not delete_success:
+        raise HTTPException(
+            status_code=404, detail="Image not found or could not be deleted"
+        )
+
     # Remove from metadata
     metadata = get_image_metadata()
     if file_name in metadata:
         del metadata[file_name]
         save_image_metadata(metadata)
-    
+
     return {"success": True, "message": f"Image {file_name} has been deleted"}
 
 # Health check endpoint for Hugging Face Spaces
@@ -777,9 +781,42 @@ async def delete_image(request: Request, file_name: str):
 async def health_check():
     return {"status": "ok"}
 
+
+@app.on_event("startup")
+async def startup_event():
+    """Run on application startup to ensure configuration is correct."""
+    global SPACE_NAME
+
+    # Try to extract Space name from HF_SPACE_ID if not explicitly set
+    if not SPACE_NAME and "HF_SPACE_ID" in os.environ:
+        space_id = os.environ.get("HF_SPACE_ID", "")
+        if space_id and "/" in space_id:
+            # HF_SPACE_ID is in format username/space-name
+            SPACE_NAME = space_id.split("/")[1]
+            print(f"Extracted Space name from HF_SPACE_ID: {SPACE_NAME}")
+
+    # Log configuration
+    if os.environ.get("ENV", "development") == "production":
+        if HF_USERNAME and HF_TOKEN and DATASET_REPO:
+            print(f"Running in production mode with Hugging Face integration:")
+            print(f"  - Username: {HF_USERNAME}")
+            print(f"  - Dataset: {DATASET_REPO}")
+            if SPACE_NAME:
+                print(f"  - Space: {SPACE_NAME}")
+                print(f"  - Space URL: https://{HF_USERNAME}-{SPACE_NAME}.hf.space")
+            else:
+                print("  - Space name not set. Direct URLs will use dataset links.")
+        else:
+            print(
+                "Warning: Running in production mode but Hugging Face credentials not fully configured."
+            )
+    else:
+        print("Running in development mode. Local storage will be used.")
+
+
 if __name__ == "__main__":
     # For local development
     uvicorn.run("app:app", host="127.0.0.1", port=8000, reload=True)
     
     # For production/Hugging Face (uncomment when deploying)
-    # uvicorn.run("app:app", host="0.0.0.0", port=7860)
+    # uvicorn.run("app:app", host="0.0.0.0", port=7860)

download_images.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+import os
+import json
+import io
+import tempfile
+from pathlib import Path
+from huggingface_hub import HfApi, HfFolder, hf_hub_download
+
+print("Starting image download from Hugging Face dataset")
+
+# Get environment variables
+HF_USERNAME = os.environ.get("HF_USERNAME", "")
+HF_TOKEN = os.environ.get("HF_TOKEN", "")
+DATASET_REPO = os.environ.get("HF_DATASET_REPO", "image-uploader-data")
+
+# Set HF cache directory to a writable location
+os.environ["HF_HOME"] = os.path.join(tempfile.gettempdir(), "huggingface")
+os.environ["HUGGINGFACE_HUB_CACHE"] = os.path.join(
+    tempfile.gettempdir(), "huggingface", "hub"
+)
+os.makedirs(os.environ["HF_HOME"], exist_ok=True)
+os.makedirs(os.environ["HUGGINGFACE_HUB_CACHE"], exist_ok=True)
+
+# Constants
+IMAGES_PATH = "images"
+METADATA_PATH = "metadata"
+UPLOAD_DIR = Path("static/uploads")
+METADATA_DIR = Path("static/metadata")
+METADATA_FILE = METADATA_DIR / "image_metadata.json"
+
+# Create directories if they don't exist
+UPLOAD_DIR.mkdir(parents=True, exist_ok=True)
+METADATA_DIR.mkdir(parents=True, exist_ok=True)
+
+# Initialize HfApi
+hf_api = HfApi(token=HF_TOKEN)
+
+try:
+    # Check if repo exists
+    print(f"Checking if repository {HF_USERNAME}/{DATASET_REPO} exists")
+    hf_api.repo_info(repo_id=f"{HF_USERNAME}/{DATASET_REPO}", repo_type="dataset")
+
+    # Download metadata first
+    print(f"Downloading metadata from {HF_USERNAME}/{DATASET_REPO}")
+    try:
+        metadata_file = hf_api.hf_hub_download(
+            repo_id=f"{HF_USERNAME}/{DATASET_REPO}",
+            filename=f"{METADATA_PATH}/image_metadata.json",
+            repo_type="dataset",
+            token=HF_TOKEN,
+            local_dir=os.path.join(tempfile.gettempdir(), "hf_downloads"),
+        )
+
+        print(f"Metadata downloaded to {metadata_file}")
+        with open(metadata_file, "r") as f:
+            metadata = json.load(f)
+
+        # Save metadata locally
+        with open(METADATA_FILE, "w") as f:
+            json.dump(metadata, f)
+    except Exception as e:
+        print(f"Error downloading metadata: {e}")
+        metadata = {}
+        # Initialize metadata file if it doesn't exist
+        with open(METADATA_FILE, "w") as f:
+            json.dump({}, f)
+
+    # List all files in the dataset
+    print("Listing files in the dataset")
+    files = hf_api.list_repo_files(
+        repo_id=f"{HF_USERNAME}/{DATASET_REPO}", repo_type="dataset", token=HF_TOKEN
+    )
+
+    # Filter only image files
+    image_files = [f for f in files if f.startswith(f"{IMAGES_PATH}/")]
+    print(f"Found {len(image_files)} images")
+
+    # Download each image
+    for image_file in image_files:
+        try:
+            filename = os.path.basename(image_file)
+            print(f"Downloading {filename}")
+
+            # Download file
+            download_path = hf_api.hf_hub_download(
+                repo_id=f"{HF_USERNAME}/{DATASET_REPO}",
+                filename=image_file,
+                repo_type="dataset",
+                token=HF_TOKEN,
+                local_dir=os.path.join(tempfile.gettempdir(), "hf_downloads"),
+            )
+
+            # Copy to uploads directory
+            destination = UPLOAD_DIR / filename
+            with open(download_path, "rb") as src, open(destination, "wb") as dst:
+                dst.write(src.read())
+
+            print(f"Saved {filename} to {destination}")
+        except Exception as e:
+            print(f"Error downloading {image_file}: {e}")
+
+    print("Image download completed")
+
+except Exception as e:
+    print(f"Error: {e}")
+    print("Creating empty metadata file")
+    with open(METADATA_FILE, "w") as f:
+        json.dump({}, f)

static/metadata/.gitkeep

@@ -0,0 +1 @@
+ 

static/uploads/.gitkeep

@@ -0,0 +1 @@
+