change upload file location

Dockerfile

@@ -27,12 +27,15 @@ RUN mkdir -p static/metadata && \
 ENV PYTHONUNBUFFERED=1
 ENV HOST=0.0.0.0
 ENV PORT=7860
+# Set environment variable for production
+ENV ENV=production
+# These should be set in Hugging Face Space settings
+# ENV HF_USERNAME=your-username
+# ENV HF_TOKEN=your-token  
+# ENV HF_DATASET_REPO=image-uploader-data
 
 # Expose port for Hugging Face Spaces (uses port 7860)
 EXPOSE 7860
 
-# Create volume mount points for persistent data
-VOLUME ["/app/static/uploads", "/app/static/metadata"]
-
 # Run the application
 CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -15,6 +15,10 @@ from starlette.middleware.sessions import SessionMiddleware
 from fastapi.security import OAuth2PasswordRequestForm
 from fastapi.responses import JSONResponse
 import json
+import io
+from huggingface_hub import HfApi, HfFolder, create_repo
+from huggingface_hub.utils import RepositoryNotFoundError
+from huggingface_hub.hf_api import RepoFile
 
 # Create FastAPI app
 app = FastAPI(title="Image Uploader")
@@ -52,6 +56,38 @@ security = HTTPBasic()
 USERNAME = "detomo"
 PASSWORD = "itweek2025"
 
+# Hugging Face Dataset configuration
+HF_USERNAME = os.environ.get("HF_USERNAME", "")  # Set this in Hugging Face Space settings
+HF_TOKEN = os.environ.get("HF_TOKEN", "")  # Set this in Hugging Face Space settings
+DATASET_REPO = os.environ.get("HF_DATASET_REPO", "image-uploader-data")
+IMAGES_PATH = "images"
+METADATA_PATH = "metadata"
+
+# Initialize HfApi
+hf_api = HfApi(token=HF_TOKEN)
+
+# Create or ensure repository exists
+def ensure_repo_exists():
+    try:
+        # Check if repo exists
+        hf_api.repo_info(repo_id=f"{HF_USERNAME}/{DATASET_REPO}", repo_type="dataset")
+    except RepositoryNotFoundError:
+        # Create repo if it doesn't exist
+        create_repo(f"{HF_USERNAME}/{DATASET_REPO}", repo_type="dataset", token=HF_TOKEN)
+        # Initialize metadata
+        metadata = json.dumps({})
+        hf_api.upload_file(
+            path_or_fileobj=io.BytesIO(metadata.encode()),
+            path_in_repo=f"{METADATA_PATH}/image_metadata.json",
+            repo_id=f"{HF_USERNAME}/{DATASET_REPO}",
+            repo_type="dataset",
+            token=HF_TOKEN
+        )
+
+# Initialize repository if in production
+if os.environ.get("ENV", "development") == "production":
+    ensure_repo_exists()
+
 def get_file_extension(filename: str) -> str:
     """Get the file extension from a filename."""
     return os.path.splitext(filename)[1].lower()
@@ -77,13 +113,44 @@ def verify_auth(request: Request):
 
 def get_image_metadata():
     """Get all image metadata including hashtags."""
-    if METADATA_FILE.exists():
+    # In production, get metadata from Hugging Face
+    if os.environ.get("ENV", "development") == "production" and HF_USERNAME:
+        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
+            )
+            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():
         with open(METADATA_FILE, "r") as f:
             return json.load(f)
     return {}
 
 def save_image_metadata(metadata):
     """Save image metadata to the JSON file."""
+    # In production, save to Hugging Face
+    if os.environ.get("ENV", "development") == "production" and HF_USERNAME and HF_TOKEN:
+        try:
+            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 saving metadata to Hugging Face: {e}")
+    
+    # Local development or fallback
     with open(METADATA_FILE, "w") as f:
         json.dump(metadata, f)
 
@@ -111,6 +178,62 @@ 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:
+            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
+            )
+            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:
+            hf_api.delete_file(
+                path_in_repo=f"{IMAGES_PATH}/{filename}",
+                repo_id=f"{HF_USERNAME}/{DATASET_REPO}",
+                repo_type="dataset",
+                token=HF_TOKEN
+            )
+            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 f"https://huggingface.co/datasets/{HF_USERNAME}/{DATASET_REPO}/resolve/main/{IMAGES_PATH}/{filename}"
+    return None
+
+def list_hf_images():
+    """List all images in the Hugging Face repo."""
+    if os.environ.get("ENV", "development") == "production" and HF_USERNAME and HF_TOKEN:
+        try:
+            files = hf_api.list_repo_files(
+                repo_id=f"{HF_USERNAME}/{DATASET_REPO}",
+                repo_type="dataset",
+                token=HF_TOKEN
+            )
+            # Filter only image files in the images directory
+            image_files = [f for f in files if f.startswith(f"{IMAGES_PATH}/")]
+            return [os.path.basename(f) for f in image_files]
+        except Exception as e:
+            print(f"Error listing files from Hugging Face: {e}")
+            return []
+    return []
+
 @app.get("/login", response_class=HTMLResponse)
 async def login_page(request: Request):
     """Render the login page."""
@@ -152,7 +275,40 @@ async def home(request: Request, search: Optional[str] = None, tag: Optional[str
     uploaded_images = []
     metadata = get_image_metadata()
     
-    if UPLOAD_DIR.exists():
+    # 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():
         for file in UPLOAD_DIR.iterdir():
             if is_valid_image(get_file_extension(file.name)):
                 image_url = f"/static/uploads/{file.name}"
@@ -226,7 +382,18 @@ async def upload_image(
     # First, check for duplicate filenames
     metadata = get_image_metadata()
     all_files = {}
-    if UPLOAD_DIR.exists():
+    
+    # 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():
         for file in UPLOAD_DIR.iterdir():
             if is_valid_image(get_file_extension(file.name)):
                 # Get original filename from metadata if available
@@ -267,19 +434,31 @@ async def upload_image(
         
         # Generate a unique filename to prevent overwrites
         unique_filename = f"{uuid.uuid4()}{extension}"
-        file_path = UPLOAD_DIR / unique_filename
         
-        # Save the file
-        with file_path.open("wb") as buffer:
-            shutil.copyfileobj(file.file, buffer)
+        # 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 hashtags and original filename
         add_hashtags_to_image(unique_filename, hashtag_list, original_filename)
         
         # For base64 encoding
-        file.file.seek(0)  # Reset file pointer to beginning
-        contents = await file.read()
-        base64_encoded = base64.b64encode(contents).decode("utf-8")
+        base64_encoded = base64.b64encode(file_content).decode("utf-8")
         
         # Determine MIME type
         mime_type = {
@@ -291,13 +470,21 @@ async def upload_image(
             '.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
+        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,
             "original_filename": original_filename,
-            "file_url": f"/static/uploads/{unique_filename}",
-            "full_url": f"{request.base_url}static/uploads/{unique_filename}",
-            "embed_html": f'<img src="{request.base_url}static/uploads/{unique_filename}" alt="{original_filename}" />',
+            "file_url": image_url,
+            "full_url": full_url,
+            "embed_html": f'<img src="{full_url}" alt="{original_filename}" />',
             "base64_data": f"data:{mime_type};base64,{base64_encoded[:20]}...{base64_encoded[-20:]}",
             "base64_embed": f'<img src="data:{mime_type};base64,{base64_encoded}" alt="{original_filename}" />',
             "hashtags": hashtag_list
@@ -352,34 +539,55 @@ async def upload_with_replace(
         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
-            old_file = UPLOAD_DIR / replace_map[file_lower]
-            if old_file.exists():
-                os.remove(old_file)
+            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)
                 
-                # Remove from metadata
-                metadata = get_image_metadata()
-                if replace_map[file_lower] in metadata:
-                    del metadata[replace_map[file_lower]]
-                    save_image_metadata(metadata)
+            # 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}"
-        file_path = UPLOAD_DIR / unique_filename
         
-        # Save the file
-        with file_path.open("wb") as buffer:
-            shutil.copyfileobj(file.file, buffer)
+        # 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 hashtags and original filename
         add_hashtags_to_image(unique_filename, hashtag_list, original_filename)
         
         # For base64 encoding
-        file.file.seek(0)  # Reset file pointer to beginning
-        contents = await file.read()
-        base64_encoded = base64.b64encode(contents).decode("utf-8")
+        base64_encoded = base64.b64encode(file_content).decode("utf-8")
         
         # Determine MIME type
         mime_type = {
@@ -391,13 +599,21 @@ async def upload_with_replace(
             '.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
+        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,
             "original_filename": original_filename,
-            "file_url": f"/static/uploads/{unique_filename}",
-            "full_url": f"{request.base_url}static/uploads/{unique_filename}",
-            "embed_html": f'<img src="{request.base_url}static/uploads/{unique_filename}" alt="{original_filename}" />',
+            "file_url": image_url,
+            "full_url": full_url,
+            "embed_html": f'<img src="{full_url}" alt="{original_filename}" />',
             "base64_data": f"data:{mime_type};base64,{base64_encoded[:20]}...{base64_encoded[-20:]}",
             "base64_embed": f'<img src="data:{mime_type};base64,{base64_encoded}" alt="{original_filename}" />',
             "hashtags": hashtag_list
@@ -415,16 +631,25 @@ async def view_image(request: Request, file_name: str):
     if not authenticate(request):
         return RedirectResponse(url="/login", status_code=status.HTTP_302_FOUND)
     
-    file_path = UPLOAD_DIR / file_name
-    
-    if not file_path.exists():
-        raise HTTPException(status_code=404, detail="Image not found")
-    
     # Mark image as viewed (not new)
     mark_image_as_viewed(file_name)
     
-    image_url = f"/static/uploads/{file_name}"
-    embed_url = f"{request.base_url}static/uploads/{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")
+    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()
@@ -457,10 +682,14 @@ async def update_hashtags(request: Request, file_name: str, hashtags: str = Form
             content={"detail": "Not authenticated"}
         )
     
-    file_path = UPLOAD_DIR / file_name
-    
-    if not file_path.exists():
-        raise HTTPException(status_code=404, detail="Image not found")
+    # Check if file exists
+    if os.environ.get("ENV", "development") == "production" and HF_USERNAME:
+        if file_name not in list_hf_images():
+            raise HTTPException(status_code=404, detail="Image not found")
+    else:
+        file_path = UPLOAD_DIR / file_name
+        if not file_path.exists():
+            raise HTTPException(status_code=404, detail="Image not found")
     
     # Process hashtags
     hashtag_list = []
@@ -483,13 +712,18 @@ async def delete_image(request: Request, file_name: str):
             content={"detail": "Not authenticated"}
         )
     
-    file_path = UPLOAD_DIR / file_name
-    
-    if not file_path.exists():
-        raise HTTPException(status_code=404, detail="Image not found")
-    
-    # Delete the file
-    os.remove(file_path)
+    # 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)
     
     # Remove from metadata
     metadata = get_image_metadata()

requirements.txt

@@ -4,4 +4,5 @@ python-multipart
 jinja2 
 aiofiles
 itsdangerous
-python-jose
+python-jose
+huggingface_hub