change permission

Dockerfile

@@ -10,7 +10,7 @@ RUN apt-get update && \
 
 # Create a non-root user to run the application
 RUN useradd -m appuser && \
-    mkdir -p /home/appuser/app /home/appuser/.cache && \
+    mkdir -p /home/appuser/app /home/appuser/.cache /home/appuser/.image_uploader && \
     chown -R appuser:appuser /home/appuser
 
 # Copy requirements first to leverage Docker cache
@@ -22,7 +22,9 @@ COPY . .
 
 # Create upload directory with proper permissions
 RUN mkdir -p static/uploads static/metadata && \
-    chmod -R 777 static
+    chmod -R 777 static && \
+    mkdir -p /tmp/.image_uploader && \
+    chmod -R 777 /tmp/.image_uploader
 
 # Set environment variables for Hugging Face
 ENV PYTHONUNBUFFERED=1
@@ -47,6 +49,12 @@ RUN --mount=type=secret,id=HF_TOKEN,mode=0444,required=true \
     echo "Hugging Face credentials not set, skipping image download."; \
     fi
 
+# Set proper ownership for all files
+RUN chown -R appuser:appuser /app
+
+# Switch to non-root user
+USER appuser
+
 # Expose port for Hugging Face Spaces (uses port 7860)
 EXPOSE 7860
 

app.py

@@ -39,10 +39,22 @@ METADATA_DIR = Path("static/metadata")
 METADATA_DIR.mkdir(parents=True, exist_ok=True)
 METADATA_FILE = METADATA_DIR / "image_metadata.json"
 
+# Alternative metadata location with guaranteed write permissions
+HOME_DIR = Path(os.environ.get("HOME", "/tmp"))
+ALT_METADATA_DIR = HOME_DIR / ".image_uploader"
+ALT_METADATA_DIR.mkdir(parents=True, exist_ok=True)
+ALT_METADATA_FILE = ALT_METADATA_DIR / "image_metadata.json"
+
 # Initialize metadata file if it doesn't exist
-if not METADATA_FILE.exists():
-    with open(METADATA_FILE, "w") as f:
-        json.dump({}, f)
+if not METADATA_FILE.exists() and not ALT_METADATA_FILE.exists():
+    try:
+        with open(METADATA_FILE, "w") as f:
+            json.dump({}, f)
+        print(f"Initialized metadata file at {METADATA_FILE}")
+    except PermissionError:
+        with open(ALT_METADATA_FILE, "w") as f:
+            json.dump({}, f)
+        print(f"Initialized metadata file at alternative location: {ALT_METADATA_FILE}")
 
 # Mount static directory
 app.mount("/static", StaticFiles(directory="static"), name="static")
@@ -138,44 +150,78 @@ def verify_auth(request: Request):
         )
     return True
 
+
+def get_metadata_file():
+    """Get the appropriate metadata file based on write permissions."""
+    # Try to write to the primary location
+    try:
+        if not METADATA_FILE.exists():
+            with open(METADATA_FILE, "w") as f:
+                json.dump({}, f)
+        # Test write permission
+        os.access(METADATA_FILE, os.W_OK)
+        return METADATA_FILE
+    except (PermissionError, OSError):
+        print(
+            f"Warning: Cannot write to {METADATA_FILE}, using alternative location: {ALT_METADATA_FILE}"
+        )
+        if not ALT_METADATA_FILE.exists():
+            with open(ALT_METADATA_FILE, "w") as f:
+                json.dump({}, f)
+        return ALT_METADATA_FILE
+
+
 def get_image_metadata():
     """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:
-            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}")
+    metadata_file = get_metadata_file()
 
-        return metadata
+    if metadata_file.exists():
+        try:
+            with open(metadata_file, "r") as 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
+        except Exception as e:
+            print(f"Error reading metadata file: {e}")
+            return {}
 
     # If metadata file doesn't exist locally, create it
-    with open(METADATA_FILE, "w") as f:
+    with open(metadata_file, "w") as f:
         json.dump({}, f)
     return {}
 
 def save_image_metadata(metadata):
     """Save image metadata to the local JSON file and sync with HF."""
+    metadata_file = get_metadata_file()
+
     # Always save locally first
-    with open(METADATA_FILE, "w") as f:
-        json.dump(metadata, f)
+    try:
+        with open(metadata_file, "w") as f:
+            json.dump(metadata, f)
+        print(f"Metadata saved to {metadata_file}")
+    except Exception as e:
+        print(f"Error saving metadata locally: {e}")
+        # In case of a file error, we'll still try to save to HF
 
     # In production, also save to Hugging Face
     if os.environ.get("ENV", "development") == "production" and HF_USERNAME and HF_TOKEN:

download_images.py

@@ -40,10 +40,34 @@ UPLOAD_DIR = Path("static/uploads")
 METADATA_DIR = Path("static/metadata")
 METADATA_FILE = METADATA_DIR / "image_metadata.json"
 
+# Alternative metadata location with guaranteed write permissions
+HOME_DIR = Path(os.environ.get("HOME", "/tmp"))
+ALT_METADATA_DIR = HOME_DIR / ".image_uploader"
+ALT_METADATA_DIR.mkdir(parents=True, exist_ok=True)
+ALT_METADATA_FILE = ALT_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)
 
+
+# Function to get the appropriate metadata file
+def get_metadata_file():
+    # Try to write to the primary location
+    try:
+        if not METADATA_FILE.exists():
+            with open(METADATA_FILE, "w") as f:
+                json.dump({}, f)
+        # Test write permission
+        if os.access(METADATA_FILE, os.W_OK):
+            return METADATA_FILE
+        raise PermissionError(f"No write permission for {METADATA_FILE}")
+    except (PermissionError, OSError) as e:
+        print(f"Warning: Cannot use {METADATA_FILE}: {e}")
+        print(f"Using alternative location: {ALT_METADATA_FILE}")
+        return ALT_METADATA_FILE
+
+
 # Initialize HfApi
 hf_api = HfApi(token=HF_TOKEN)
 
@@ -56,7 +80,7 @@ try:
     # Download metadata first
     print(f"Downloading metadata from {HF_USERNAME}/{DATASET_REPO}")
     try:
-        metadata_file = hf_api.hf_hub_download(
+        metadata_file_path = hf_api.hf_hub_download(
             repo_id=f"{HF_USERNAME}/{DATASET_REPO}",
             filename=f"{METADATA_PATH}/image_metadata.json",
             repo_type="dataset",
@@ -64,21 +88,24 @@ try:
             local_dir=os.path.join(tempfile.gettempdir(), "hf_downloads"),
         )
 
-        print(f"Metadata downloaded to {metadata_file}")
-        with open(metadata_file, "r") as f:
+        print(f"Metadata downloaded to {metadata_file_path}")
+        with open(metadata_file_path, "r") as f:
             metadata = json.load(f)
 
-        # Save metadata locally
-        with open(METADATA_FILE, "w") as f:
+        # Save metadata locally to the appropriate file
+        save_path = get_metadata_file()
+        with open(save_path, "w") as f:
             json.dump(metadata, f)
-            print(f"Metadata saved to {METADATA_FILE}")
+            print(f"Metadata saved to {save_path}")
     except Exception as e:
         print(f"Error downloading metadata: {e}")
         print("Creating empty metadata file")
         metadata = {}
-        # Initialize metadata file if it doesn't exist
-        with open(METADATA_FILE, "w") as f:
+        # Initialize metadata file
+        save_path = get_metadata_file()
+        with open(save_path, "w") as f:
             json.dump({}, f)
+            print(f"Created empty metadata file at {save_path}")
 
     # List all files in the dataset
     print("Listing files in the dataset")
@@ -123,5 +150,7 @@ try:
 except Exception as e:
     print(f"Error: {e}")
     print("Creating empty metadata file")
-    with open(METADATA_FILE, "w") as f:
+    save_path = get_metadata_file()
+    with open(save_path, "w") as f:
         json.dump({}, f)
+        print(f"Created empty metadata file at {save_path}")