final space code ready

app/backend/hub.py

@@ -1,13 +1,93 @@
+# # /app/backend/hub.py
+# import os
+# import logging
+# from typing import Optional, Dict
+# from pathlib import Path
+
+# from huggingface_hub import HfApi, upload_folder, Repository, create_repo
+
+# logger = logging.getLogger(__name__)
+# logger.addHandler(logging.NullHandler())
+
+# def get_hf_api(token: Optional[str] = None) -> Optional[HfApi]:
+#     """Initializes HfApi using a provided token or the environment secret."""
+#     token_to_use = token or os.getenv("HF_TOKEN")
+#     if token_to_use:
+#         return HfApi(token=token_to_use)
+#     return None
+
+# def get_user_info(token: Optional[str] = None) -> Optional[Dict]:
+#     """Fetches user info from the Hub (returns None if unauthenticated)."""
+#     api = get_hf_api(token)
+#     if api:
+#         try:
+#             return api.whoami()
+#         except Exception as e:
+#             # print(f"Failed to authenticate with Hugging Face Hub: {e}")
+#             logger.warning("Failed to authenticate with Hugging Face Hub: %s", e)
+#             return None
+#     return None
+
+
+# def push_dataset_to_hub(folder_path: str, repo_name: str, namespace: str, private: bool, commit_message: str, token: Optional[str] = None):
+#     """
+#     Push the contents of folder_path to the Hugging Face datasets repo `namespace/repo_name`.
+#     Uses token param if provided, otherwise falls back to HF_TOKEN from environment/.env.
+#     """
+#     api = get_hf_api(token)
+#     if not api:
+#         raise ConnectionError("Hugging Face token not found. Provide token or set HF_TOKEN in environment or .env file.")
+
+#     repo_id = f"{namespace}/{repo_name}"
+
+#     # create repo if not exists
+#     try:
+#         api.create_repo(name=repo_name, token=token or os.getenv("HF_TOKEN"), repo_type="dataset", private=private, namespace=namespace)
+#         logger.info(f"Created repo {repo_id} (or it already exists)")
+#     except Exception as e:
+#         logger.info(f"Repo create warning (may already exist): {e}")
+
+#     # upload entire folder (recursively) using upload_folder helper
+#     try:
+#         upload_folder(
+#             folder_path=folder_path,
+#             path_in_repo="",
+#             repo_id=repo_id,
+#             token=token or os.getenv("HF_TOKEN"),
+#             repo_type="dataset",
+#             commit_message=commit_message,
+#         )
+#         logger.info(f"Uploaded folder to {repo_id} from {folder_path}")
+#     except Exception as e:
+#         logger.exception(f"upload_folder failed for {folder_path} -> {repo_id}: {e}")
+#         raise
+
 # /app/backend/hub.py
 import os
 import logging
 from typing import Optional, Dict
 from pathlib import Path
 
-from huggingface_hub import HfApi, upload_folder, Repository, create_repo
+# third-party
+from huggingface_hub import HfApi, upload_folder, create_repo
+
+# dotenv helper to load .env when running locally
+from dotenv import load_dotenv
 
+# explicit logger for this module
 logger = logging.getLogger(__name__)
-logger.addHandler(logging.NullHandler())
+
+# Attempt to load .env from the project root (two levels up: app/backend -> project root)
+try:
+    env_path = Path(__file__).resolve().parents[2] / ".env"
+    if env_path.exists():
+        load_dotenv(dotenv_path=env_path)
+        logger.info(f"Loaded .env from {env_path}")
+    else:
+        # Try default load (cwd) as a fallback
+        load_dotenv()
+except Exception as e:
+    logger.debug(f"Could not load .env automatically: {e}")
 
 def get_hf_api(token: Optional[str] = None) -> Optional[HfApi]:
     """Initializes HfApi using a provided token or the environment secret."""
@@ -16,48 +96,54 @@ def get_hf_api(token: Optional[str] = None) -> Optional[HfApi]:
         return HfApi(token=token_to_use)
     return None
 
+# def get_user_info(token: Optional[str] = None) -> Optional[Dict]:
+#     """Fetches user info from the Hub."""
+#     api = get_hf_api(token)
+#     if api:
+#         try:
+#             return api.whoami()
+#         except Exception as e:
+#             logger.warning(f"Failed to authenticate with Hugging Face Hub: {e}")
+#             return None
+#     return None
+
 def get_user_info(token: Optional[str] = None) -> Optional[Dict]:
-    """Fetches user info from the Hub (returns None if unauthenticated)."""
     api = get_hf_api(token)
-    if api:
-        try:
-            return api.whoami()
-        except Exception as e:
-            # print(f"Failed to authenticate with Hugging Face Hub: {e}")
-            logger.warning("Failed to authenticate with Hugging Face Hub: %s", e)
-            return None
-    return None
-
+    if not api:
+        logger.warning("Hugging Face authentication not available. Please check HF_TOKEN.")
+        return None
+    try:
+        return api.whoami()
+    except Exception as e:
+        logger.warning(f"Failed to authenticate with Hugging Face Hub: {e}")
+        return None
 
-def push_dataset_to_hub(folder_path: str, repo_name: str, namespace: str, private: bool, commit_message: str, token: Optional[str] = None):
+def push_dataset_to_hub(folder_path: str, repo_name: str, namespace: str, private: bool, commit_message: str, token: str):
     """
-    Push the contents of folder_path to the Hugging Face datasets repo `namespace/repo_name`.
-    Uses token param if provided, otherwise falls back to HF_TOKEN from environment/.env.
+    Push the folder at folder_path to the Hugging Face datasets repo `namespace/repo_name`.
+    This uploads everything in folder_path (including README.md, manifest.csv, images/, annotations/).
     """
-    api = get_hf_api(token)
-    if not api:
-        raise ConnectionError("Hugging Face token not found. Provide token or set HF_TOKEN in environment or .env file.")
-
+    api = HfApi(token=token)
     repo_id = f"{namespace}/{repo_name}"
 
     # create repo if not exists
     try:
-        api.create_repo(name=repo_name, token=token or os.getenv("HF_TOKEN"), repo_type="dataset", private=private, namespace=namespace)
-        logger.info(f"Created repo {repo_id} (or it already exists)")
+        api.create_repo(name=repo_name, token=token, repo_type="dataset", private=private, namespace=namespace)
+        logger.info(f"Created repo {repo_id}")
     except Exception as e:
         logger.info(f"Repo create warning (may already exist): {e}")
 
-    # upload entire folder (recursively) using upload_folder helper
+    # upload entire folder (recursively) using upload_folder
     try:
         upload_folder(
             folder_path=folder_path,
             path_in_repo="",
             repo_id=repo_id,
-            token=token or os.getenv("HF_TOKEN"),
+            token=token,
             repo_type="dataset",
             commit_message=commit_message,
         )
         logger.info(f"Uploaded folder to {repo_id} from {folder_path}")
     except Exception as e:
         logger.exception(f"upload_folder failed for {folder_path} -> {repo_id}: {e}")
-        raise
+        raise

app/backend/main.py

@@ -17,6 +17,27 @@ from fastapi.middleware.cors import CORSMiddleware
 from starlette.staticfiles import StaticFiles
 from fastapi.exceptions import RequestValidationError
 
+
+from pathlib import Path
+from dotenv import load_dotenv
+import os
+import logging
+
+# Attempt to load .env from repo root (two levels up: app/backend -> project root)
+env_path = Path(__file__).resolve().parents[2] / ".env"
+if env_path.exists():
+    load_dotenv(dotenv_path=env_path)
+    logging.getLogger(__name__).info(f"Loaded .env from {env_path}; HF_TOKEN present? {'yes' if os.getenv('HF_TOKEN') else 'no'}")
+else:
+    # fallback to default load (cwd)
+    load_dotenv()
+    logging.getLogger(__name__).info(f"Loaded .env from cwd; HF_TOKEN present? {'yes' if os.getenv('HF_TOKEN') else 'no'}")
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+logger.info(f"ENV HF_TOKEN present? {'yes' if os.getenv('HF_TOKEN') else 'no'}")
+
+
 from .schemas import *
 from .storage import (
     create_new_session, get_session_path, save_session_config,

app/backend/storage.py

@@ -79,75 +79,6 @@ def extract_zip(zip_file_path: Path, extract_to: Path) -> List[str]:
             image_filenames.append(sanitized_id)
     return image_filenames
 
-# def move_labeled_file(session_id: str, image_id: str, variety: str, disease: str) -> Tuple[Path, Path]:
-    # """Moves a labeled image to its final structured directory and returns the new paths.
-# 
-    #  NOTE: this function updates metadata.processed_path to a RELATIVE path inside the final dataset
-    # (images/<variety>/<disease>/<image_id>) and writes a per-image annotation JSON that excludes
-    # original_path, mask_path and status (as requested).
-    # """
-    # config = load_session_config(session_id)
-    # if image_id not in config.image_metadata:
-        # raise FileNotFoundError(f"Image id {image_id} not found in session config")
-    # metadata = config.image_metadata[image_id]
-# 
-    # final_dataset_slug = "tulasi-curated-dataset"
-    # final_base_path = OUTPUT_DIR / final_dataset_slug
-    # final_image_dir = final_base_path / "images" / variety / disease
-    # final_mask_dir = final_base_path / "masks"
-    # final_annotations_dir = final_base_path / "annotations"
-# 
-    # final_image_dir.mkdir(parents=True, exist_ok=True)
-    # final_annotations_dir.mkdir(parents=True, exist_ok=True)
-# 
-    # Prefer processed image if present, otherwise fall back to original
-    # source_path_str = metadata.processed_path or metadata.original_path
-    # source_path = Path(source_path_str)
-    # 
-    # Resolve relative paths (relative to session)
-    # if not source_path.is_absolute():
-        # source_path = get_session_path(session_id) / source_path
-# 
-    # if not source_path.exists():
-        # raise FileNotFoundError(f"Source image file not found: {source_path}")
-# 
-    # final_image_path = final_image_dir / image_id
-    # use copy2 to preserve timestamps/metadata
-    # shutil.copy2(source_path, final_image_path)
-# 
-    # Update metadata to point to relative paths inside final dataset
-    # metadata.processed_path =  str(final_image_path)
-    # Update metadata to point to relative path inside final dataset (so HF can resolve it)
-    # metadata.processed_path = str(Path("images") / variety / disease / image_id)
-# 
-    # save_session_config(session_id, config)
-# 
-    # Write a per-image annotation sidecar in final dataset WITHOUT original_path/mask_path/status
-    # try:
-        # produce a plain dict (compat for pydantic v2 / v1)
-        # if hasattr(metadata, "model_dump"):
-            # meta_dict = metadata.model_dump()
-        # elif hasattr(metadata, "dict"):
-            # meta_dict = metadata.dict()
-        # else:
-            # meta_dict = dict(metadata)
-# 
-        # remove unwanted fields
-        # meta_dict.pop("original_path", None)
-        # meta_dict.pop("mask_path", None)
-        # meta_dict.pop("status", None)
-    # 
-        # write a per-image annotation sidecar in final dataset
-        # with open(final_annotations_dir / f"{Path(image_id).stem}.json", "w", encoding="utf-8") as f:
-            # f.write(metadata.model_dump_json(indent=2))
-            # json.dump(meta_dict, f, indent=2, ensure_ascii=False)
-    # except Exception:
-        # best-effort writing annotation — don't fail the labeling step if this fails
-        # pass
-        # 
-    # return final_base_path, final_image_path
-
-
 def move_labeled_file(session_id: str, image_id: str, variety: str, disease: str) -> Tuple[Path, Path]:
     """Moves a labeled image to its final structured directory and returns the new paths.