model download resolve

Dockerfile

@@ -2,12 +2,12 @@ FROM python:3.9-slim
 
 WORKDIR /app
 
-# Create a user-writable cache directory
+# Create user-writable cache and temp directories
 ENV HF_HOME=/app/.cache
-ENV TRANSFORMERS_CACHE=/app/.cache/huggingface
 ENV TORCH_HOME=/app/.cache/torch
-RUN mkdir -p /app/.cache/huggingface /app/.cache/torch
-RUN chmod -R 777 /app/.cache
+ENV TMPDIR=/app/tmp
+RUN mkdir -p /app/.cache/huggingface /app/.cache/torch /app/tmp
+RUN chmod -R 777 /app/.cache /app/tmp
 
 # Copy requirements first for better caching
 COPY requirements.txt .
@@ -24,6 +24,7 @@ RUN chmod -R 777 uploads models
 # Set environment variables
 ENV PYTHONPATH=/app
 ENV PORT=7860
+ENV PYTHONUNBUFFERED=1
 
 # Expose the port
 EXPOSE 7860

app/services/model_service.py

@@ -43,25 +43,74 @@ class ModelService:
         """Download the model from Hugging Face Hub if not present locally"""
         try:
             # Create the directory if it doesn't exist
-            os.makedirs(os.path.dirname(settings.MODEL_PATH), exist_ok=True)
+            model_dir = os.path.dirname(settings.MODEL_PATH)
+            os.makedirs(model_dir, exist_ok=True)
             
-            logger.info(f"Downloading model from {settings.HF_MODEL_REPO} to {settings.MODEL_PATH}")
+            # Log environment info for debugging
+            logger.info(f"HF_HOME: {os.environ.get('HF_HOME')}")
+            logger.info(f"TMPDIR: {os.environ.get('TMPDIR')}")
+            logger.info(f"Current working directory: {os.getcwd()}")
+            logger.info(f"Model directory: {model_dir}")
+            logger.info(f"Model path: {settings.MODEL_PATH}")
             
-            # Download the model file from Hugging Face
-            hf_hub_download(
-                repo_id=settings.HF_MODEL_REPO,
-                filename=settings.HF_MODEL_FILENAME,
-                local_dir=os.path.dirname(settings.MODEL_PATH),
-                local_dir_use_symlinks=False
-            )
+            # Set up a temporary directory within our writable space
+            tmp_dir = os.environ.get("TMPDIR", "/app/tmp")
+            os.makedirs(tmp_dir, exist_ok=True)
+            logger.info(f"Using temporary directory: {tmp_dir}")
             
-            # Rename the downloaded file to match the expected path if needed
-            downloaded_path = os.path.join(os.path.dirname(settings.MODEL_PATH), settings.HF_MODEL_FILENAME)
-            if downloaded_path != settings.MODEL_PATH:
-                os.rename(downloaded_path, settings.MODEL_PATH)
+            # Use a simpler approach to download the file
+            try:                
+                # Try to download directly to the final location
+                logger.info(f"Downloading from {settings.HF_MODEL_REPO}/{settings.HF_MODEL_FILENAME}")
+                downloaded_path = hf_hub_download(
+                    repo_id=settings.HF_MODEL_REPO,
+                    filename=settings.HF_MODEL_FILENAME,
+                    local_dir=model_dir,
+                    local_dir_use_symlinks=False,
+                    cache_dir=os.environ.get("HF_HOME"),
+                    force_download=True
+                )
+                
+                logger.info(f"Model downloaded to: {downloaded_path}")
+                
+                # If needed, copy the file to the expected location
+                if downloaded_path != settings.MODEL_PATH:
+                    import shutil
+                    logger.info(f"Copying from {downloaded_path} to {settings.MODEL_PATH}")
+                    shutil.copy2(downloaded_path, settings.MODEL_PATH)
+                
+                logger.info(f"Model download successful")
+                return True
+                
+            except Exception as download_error:
+                logger.error(f"Error during Hugging Face Hub download: {download_error}")
+                
+                # Fallback method: direct download using requests
+                logger.info("Trying fallback method with direct HTTP download")
+                import requests
+                from huggingface_hub.utils import build_hf_headers
+                
+                # Get Hugging Face token from settings
+                token = settings.HUGGINGFACE_TOKEN
+                
+                # Build proper URL for the model file
+                url = f"https://huggingface.co/{settings.HF_MODEL_REPO}/resolve/main/{settings.HF_MODEL_FILENAME}"
+                logger.info(f"Downloading from URL: {url}")
+                
+                # Download with proper headers
+                headers = build_hf_headers(token=token)
+                response = requests.get(url, headers=headers, stream=True)
+                response.raise_for_status()
+                
+                # Write the file in chunks to avoid memory issues
+                logger.info(f"Writing downloaded content to {settings.MODEL_PATH}")
+                with open(settings.MODEL_PATH, 'wb') as f:
+                    for chunk in response.iter_content(chunk_size=8192):
+                        f.write(chunk)
+                
+                logger.info(f"Model downloaded successfully using fallback method")
+                return True
                 
-            logger.info(f"Model downloaded successfully to {settings.MODEL_PATH}")
-            return True
         except Exception as e:
             logger.error(f"Error downloading model from Hugging Face Hub: {e}")
             return False