Align HuggingFace API usage with official docs pattern

src/api/app.py

@@ -1416,15 +1416,24 @@ async def export_to_huggingface(request: HuggingFaceExportRequest):
         
         # Fetch user's HuggingFace token from hf_tokens table (not user_profiles)
         logger.info(f"[HF Export] Fetching HF token from hf_tokens table...")
-        result = supabase.table("hf_tokens").select(
-            "huggingface_token, huggingface_username"
-        ).eq("user_id", request.user_id).single().execute()
-        
-        if not result.data:
-            raise HTTPException(status_code=404, detail="HuggingFace not connected. Please connect in Settings first.")
-        
-        hf_token = result.data.get("huggingface_token")
-        hf_username = result.data.get("huggingface_username")
+        try:
+            result = supabase.table("hf_tokens").select(
+                "huggingface_token, huggingface_username"
+            ).eq("user_id", request.user_id).execute()
+            
+            logger.info(f"[HF Export] Query result: {result.data}")
+            
+            if not result.data or len(result.data) == 0:
+                raise HTTPException(status_code=404, detail="HuggingFace not connected. Please connect in Settings first.")
+            
+            row = result.data[0]
+            hf_token = row.get("huggingface_token")
+            hf_username = row.get("huggingface_username")
+        except HTTPException:
+            raise
+        except Exception as e:
+            logger.error(f"[HF Export] Supabase query error: {e}")
+            raise HTTPException(status_code=500, detail=f"Database error: {str(e)}")
         
         if not hf_token:
             raise HTTPException(
@@ -1433,9 +1442,19 @@ async def export_to_huggingface(request: HuggingFaceExportRequest):
             )
         
         # Import HuggingFace storage service
-        from src.storage.huggingface_storage import HuggingFaceStorage
+        try:
+            from src.storage.huggingface_storage import HuggingFaceStorage
+            logger.info(f"[HF Export] HuggingFaceStorage imported successfully")
+        except ImportError as e:
+            logger.error(f"[HF Export] Failed to import HuggingFaceStorage: {e}")
+            raise HTTPException(status_code=500, detail=f"Server error: {str(e)}")
         
-        hf_service = HuggingFaceStorage(hf_token=hf_token)
+        try:
+            hf_service = HuggingFaceStorage(hf_token=hf_token)
+            logger.info(f"[HF Export] HuggingFaceStorage initialized for user: {hf_username}")
+        except Exception as e:
+            logger.error(f"[HF Export] Failed to initialize HuggingFaceStorage: {e}")
+            raise HTTPException(status_code=500, detail=f"HuggingFace error: {str(e)}")
         
         # Collect all session assets
         uploaded_files = []
@@ -1496,7 +1515,7 @@ async def export_to_huggingface(request: HuggingFaceExportRequest):
                     logger.error(f"[HF Export] Model upload error: {e}")
                     errors.append(f"Model {Path(model_file).name}: {str(e)}")
         
-        # Upload visualizations (HTML plots) - use upload_report for HTML files
+        # Upload visualizations (HTML plots) - use generic file upload
         plot_patterns = [
             session_outputs_dir / "*.html",
             global_outputs_dir / "*.html",
@@ -1512,11 +1531,10 @@ async def export_to_huggingface(request: HuggingFaceExportRequest):
                     continue
                 try:
                     logger.info(f"[HF Export] Uploading HTML plot: {plot_file}")
-                    result = hf_service.upload_report(
-                        report_path=plot_file,
+                    result = hf_service.upload_generic_file(
+                        file_path=plot_file,
                         session_id=request.session_id,
-                        report_name=Path(plot_file).stem,
-                        compress=False  # Don't compress HTML plots for direct viewing
+                        subfolder="plots"
                     )
                     if result.get("success"):
                         uploaded_files.append({"type": "plot", "name": Path(plot_file).name, "url": result.get("url")})
@@ -1526,7 +1544,7 @@ async def export_to_huggingface(request: HuggingFaceExportRequest):
                     logger.error(f"[HF Export] Plot upload error: {e}")
                     errors.append(f"Plot {Path(plot_file).name}: {str(e)}")
         
-        # Upload PNG images - use upload_report with no compression
+        # Upload PNG images - use generic file upload
         image_patterns = [
             session_outputs_dir / "*.png",
             global_outputs_dir / "*.png",
@@ -1539,11 +1557,10 @@ async def export_to_huggingface(request: HuggingFaceExportRequest):
             for image_file in glob.glob(str(pattern)):
                 try:
                     logger.info(f"[HF Export] Uploading image: {image_file}")
-                    result = hf_service.upload_report(
-                        report_path=image_file,
+                    result = hf_service.upload_generic_file(
+                        file_path=image_file,
                         session_id=request.session_id,
-                        report_name=Path(image_file).stem,
-                        compress=False
+                        subfolder="images"
                     )
                     if result.get("success"):
                         uploaded_files.append({"type": "image", "name": Path(image_file).name, "url": result.get("url")})
@@ -1554,11 +1571,22 @@ async def export_to_huggingface(request: HuggingFaceExportRequest):
                     errors.append(f"Image {Path(image_file).name}: {str(e)}")
         
         if not uploaded_files and errors:
+            logger.error(f"[HF Export] All uploads failed: {errors}")
             raise HTTPException(
                 status_code=500, 
                 detail=f"Export failed: {'; '.join(errors)}"
             )
         
+        if not uploaded_files and not errors:
+            logger.info(f"[HF Export] No files found to export")
+            return JSONResponse({
+                "success": True,
+                "uploaded_files": [],
+                "errors": None,
+                "message": "No files found to export. Run some analysis first to generate outputs."
+            })
+        
+        logger.info(f"[HF Export] Export completed: {len(uploaded_files)} files uploaded, {len(errors)} errors")
         return JSONResponse({
             "success": True,
             "uploaded_files": uploaded_files,

src/storage/huggingface_storage.py

@@ -22,7 +22,7 @@ logger = logging.getLogger(__name__)
 
 # Optional: huggingface_hub for HF operations
 try:
-    from huggingface_hub import HfApi, HfFolder, create_repo, upload_file, upload_folder
+    from huggingface_hub import HfApi, upload_folder
     from huggingface_hub.utils import RepositoryNotFoundError
     HF_AVAILABLE = True
 except ImportError:
@@ -106,11 +106,11 @@ class HuggingFaceStorage:
             logger.info(f"Repo {repo_id} exists")
         except RepositoryNotFoundError:
             logger.info(f"Creating repo {repo_id}")
-            create_repo(
+            self.api.create_repo(
                 repo_id=repo_id,
                 repo_type=repo_kind,
                 private=True,  # Default to private
-                token=self.token
+                exist_ok=True  # Don't fail if already exists
             )
         
         return repo_id
@@ -156,13 +156,12 @@ class HuggingFaceStorage:
         path_in_repo = f"datasets/{session_id}/{file_name}"
         
         try:
-            result = upload_file(
+            result = self.api.upload_file(
                 path_or_fileobj=upload_path,
                 path_in_repo=path_in_repo,
                 repo_id=repo_id,
                 repo_type="dataset",
-                token=self.token,
-                commit_message=f"Add dataset: {file_name}"
+                                commit_message=f"Add dataset: {file_name}"
             )
             
             # Upload metadata if provided
@@ -177,13 +176,12 @@ class HuggingFaceStorage:
                     }, tmp)
                     tmp.flush()
                     
-                    upload_file(
+                    self.api.upload_file(
                         path_or_fileobj=tmp.name,
                         path_in_repo=metadata_path,
                         repo_id=repo_id,
                         repo_type="dataset",
-                        token=self.token,
-                        commit_message=f"Add metadata for {file_name}"
+                                                commit_message=f"Add metadata for {file_name}"
                     )
             
             file_size = os.path.getsize(upload_path)
@@ -244,13 +242,12 @@ class HuggingFaceStorage:
         
         try:
             # Upload the model file
-            upload_file(
+            self.api.upload_file(
                 path_or_fileobj=model_path,
                 path_in_repo=f"{path_in_repo}/{model_file_name}",
                 repo_id=repo_id,
                 repo_type="model",
-                token=self.token,
-                commit_message=f"Add model: {model_name}"
+                                commit_message=f"Add model: {model_name}"
             )
             
             # Create and upload model card
@@ -266,13 +263,12 @@ class HuggingFaceStorage:
                 tmp.write(model_card)
                 tmp.flush()
                 
-                upload_file(
+                self.api.upload_file(
                     path_or_fileobj=tmp.name,
                     path_in_repo=f"{path_in_repo}/README.md",
                     repo_id=repo_id,
                     repo_type="model",
-                    token=self.token,
-                    commit_message=f"Add model card for {model_name}"
+                                        commit_message=f"Add model card for {model_name}"
                 )
             
             # Upload config
@@ -291,13 +287,12 @@ class HuggingFaceStorage:
                 json.dump(config, tmp, indent=2)
                 tmp.flush()
                 
-                upload_file(
+                self.api.upload_file(
                     path_or_fileobj=tmp.name,
                     path_in_repo=f"{path_in_repo}/config.json",
                     repo_id=repo_id,
                     repo_type="model",
-                    token=self.token,
-                    commit_message=f"Add config for {model_name}"
+                                        commit_message=f"Add config for {model_name}"
                 )
             
             return {
@@ -353,13 +348,12 @@ class HuggingFaceStorage:
                 tmp.write(plot_json)
                 tmp.flush()
                 
-                upload_file(
+                self.api.upload_file(
                     path_or_fileobj=tmp.name,
                     path_in_repo=path_in_repo,
                     repo_id=repo_id,
                     repo_type="dataset",
-                    token=self.token,
-                    commit_message=f"Add plot: {plot_name}"
+                                        commit_message=f"Add plot: {plot_name}"
                 )
             
             return {
@@ -416,13 +410,12 @@ class HuggingFaceStorage:
         path_in_repo = f"reports/{session_id}/{file_name}"
         
         try:
-            upload_file(
+            self.api.upload_file(
                 path_or_fileobj=upload_path,
                 path_in_repo=path_in_repo,
                 repo_id=repo_id,
                 repo_type="dataset",
-                token=self.token,
-                commit_message=f"Add report: {report_name}"
+                                commit_message=f"Add report: {report_name}"
             )
             
             file_size = os.path.getsize(upload_path)
@@ -450,6 +443,55 @@ class HuggingFaceStorage:
                 except:
                     pass
     
+    def upload_generic_file(
+        self,
+        file_path: str,
+        session_id: str,
+        subfolder: str = "files"
+    ) -> Dict[str, Any]:
+        """
+        Upload any file to user's HuggingFace outputs repo.
+        
+        Args:
+            file_path: Local path to the file
+            session_id: Session ID
+            subfolder: Subfolder within outputs (e.g., "plots", "images", "files")
+        
+        Returns:
+            Dict with upload info
+        """
+        repo_id = self._ensure_repo_exists("outputs", "dataset")
+        
+        file_name = Path(file_path).name
+        path_in_repo = f"{subfolder}/{session_id}/{file_name}"
+        
+        try:
+            self.api.upload_file(
+                path_or_fileobj=file_path,
+                path_in_repo=path_in_repo,
+                repo_id=repo_id,
+                repo_type="dataset",
+                                commit_message=f"Add {subfolder}: {file_name}"
+            )
+            
+            file_size = os.path.getsize(file_path)
+            
+            return {
+                "success": True,
+                "repo_id": repo_id,
+                "path": path_in_repo,
+                "url": f"https://huggingface.co/datasets/{repo_id}/blob/main/{path_in_repo}",
+                "download_url": f"https://huggingface.co/datasets/{repo_id}/resolve/main/{path_in_repo}",
+                "size_bytes": file_size
+            }
+            
+        except Exception as e:
+            logger.error(f"Failed to upload file: {e}")
+            return {
+                "success": False,
+                "error": str(e)
+            }
+
     def list_user_files(
         self,
         session_id: Optional[str] = None,