bucket storage

.gitignore

@@ -64,3 +64,4 @@ gradio_cached_examples/
 # __pycache__ in subfolders
 */__pycache__/
 
+bucket.py

api/camera.py

@@ -2,7 +2,7 @@ from fastapi import APIRouter, HTTPException, Query, Body
 from pydantic import BaseModel, Field, validator
 from typing import List, Optional
 from .utils import save_cameras, load_cameras, get_user_file, user_exists
-from .config import UPLOAD_DIR,GCS_UPLOAD_DIR
+from .config import UPLOAD_DIR
 import os
 import shutil
 

api/config.py

@@ -1,12 +1,9 @@
 import os
 import logging
-from zipfile import Path
+from pathlib import Path
 from dotenv import load_dotenv
 from ultralytics import YOLO
-from google.cloud import storage
-import google.auth
 
-# ---------------- ENV ----------------
 load_dotenv(override=True)
 BASE_DIR = os.path.dirname(os.path.abspath(__file__))
 
@@ -25,33 +22,9 @@ ENV = os.getenv("ENV", "DEV").upper()
 logger.info(f"Running in {ENV}")
 
 # ---------------- STORAGE ----------------
-UPLOAD_DIR = os.path.join(BASE_DIR, "user_data")
-os.makedirs(UPLOAD_DIR, exist_ok=True)
-
-STORAGE_BACKEND = "local"
-gcs_client = None
-gcs_bucket = None
-GCS_UPLOAD_DIR = "uploaded_images/"
-
-if ENV == "PROD":
-    STORAGE_BACKEND = os.getenv("PROD_STORAGE_BACKEND", "gcs").lower()
-    GCS_BUCKET_NAME = os.getenv("PROD_GCS_BUCKET_NAME")
-    GCS_KEY_PATH = os.getenv("PROD_GOOGLE_APPLICATION_CREDENTIALS")
-
-    if STORAGE_BACKEND == "gcs":
-        try:
-            if os.getenv("GOOGLE_CLOUD_PROJECT"):
-                creds, project = google.auth.default()
-                gcs_client = storage.Client(credentials=creds, project=project)
-            else:
-                gcs_client = storage.Client.from_service_account_json(GCS_KEY_PATH)
-
-            gcs_bucket = gcs_client.bucket(GCS_BUCKET_NAME)
-            logger.info(f"Connected to GCS bucket: {GCS_BUCKET_NAME}")
-
-        except Exception as e:
-            logger.error(f"GCS connection failed: {e}")
-            STORAGE_BACKEND = "local"
+# Use Hugging Face bucket as UPLOAD_DIR
+UPLOAD_DIR = "codewithRiz/test_bucket"
+STORAGE_BACKEND = "huggingface"  # indicate we are using HF bucket
 
 # ---------------- UPLOAD RULES ----------------
 MIN_IMAGES = 1
@@ -61,10 +34,10 @@ ALLOWED_EXTENSIONS = {"jpg", "jpeg", "png", "webp"}
 # ---------------- YOLO MODELS ----------------
 try:
     logger.info("Loading YOLO models...")
-    DETECT_MODEL = YOLO("api/walidlife_models/detect/deer.pt")
-    BUCK_DOE_MODEL = YOLO("api/walidlife_models/classify/Buck_classificationt.pt", task="classify")
-    BUCK_TYPE_MODEL = YOLO("api/walidlife_models/classify/mules_vs_whitetails.pt", task="classify")
+    DETECT_MODEL = YOLO("api/walidlife_models/detect/deer.onnx")
+    BUCK_DOE_MODEL = YOLO("api/walidlife_models/classify/Buck_classificationt.onnx", task="classify")
+    BUCK_TYPE_MODEL = YOLO("api/walidlife_models/classify/mules_vs_whitetails.onnx", task="classify")
     logger.info("YOLO models loaded")
 except Exception as e:
     logger.error(f"YOLO load failed: {e}")
-    DETECT_MODEL = BUCK_DOE_MODEL = BUCK_TYPE_MODEL = None
+    DETECT_MODEL = BUCK_DOE_MODEL = BUCK_TYPE_MODEL = None

api/detection.py

@@ -50,17 +50,14 @@
 #         "camera": camera_name,
 #         "results": new_results
 #     }
-
-
-
 from fastapi import APIRouter, UploadFile, File, Form, HTTPException
 from pydantic import BaseModel
-from pathlib import Path
 from typing import Optional, List, Literal
 import cv2
 import numpy as np
 import logging
-from .config import UPLOAD_DIR
+import time
+
 from .utils import (
     validate_form,
     process_image,
@@ -68,16 +65,14 @@ from .utils import (
     load_json,
     save_json,
     validate_user_and_camera,
-    extract_metadata
+    extract_metadata,
+    _bucket_key,
 )
 
-
-
 router = APIRouter()
 logger = logging.getLogger(__name__)
 
 
-# ─── existing endpoint
 @router.post("/predict")
 async def predict(
     user_id: str = Form(...),
@@ -86,11 +81,12 @@ async def predict(
 ):
     images = validate_form(user_id, camera_name, images)
     validate_user_and_camera(user_id, camera_name)
-    base = Path(UPLOAD_DIR) / user_id / camera_name
-    base.mkdir(parents=True, exist_ok=True)
-    json_path = base / f"{camera_name}_detections.json"
+
+    json_path = _bucket_key(user_id, camera_name, f"{camera_name}_detections.json")
+
     data = load_json(json_path)
     new_results = []
+
     for file in images:
         raw = await file.read()
         metadata = extract_metadata(raw)
@@ -98,7 +94,11 @@ async def predict(
         img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
         if img is None:
             raise HTTPException(400, f"Invalid image: {file.filename}")
+
+        t0 = time.perf_counter()
         detections = process_image(img)
+        logger.info(f"[{file.filename}] inference: {round((time.perf_counter() - t0) * 1000, 2)}ms")
+
         url = save_image(user_id, camera_name, file.filename, raw)
         record = {
             "filename": file.filename,
@@ -108,139 +108,140 @@ async def predict(
         }
         data.append(record)
         new_results.append(record)
+
     save_json(json_path, data)
+
     return {
         "message": "Images processed successfully",
         "camera": camera_name,
         "results": new_results
     }
-
 # ─────────────────
 # Request Models
 # ─────────────────
 
-class DetectionOperation(BaseModel):
-    action: Literal["add", "update", "delete"]
-    detection_index: Optional[int] = None
-    label: Optional[str] = None
-    bbox: Optional[List[float]] = None  # [x1, y1, x2, y2]
+# class DetectionOperation(BaseModel):
+#     action: Literal["add", "update", "delete"]
+#     detection_index: Optional[int] = None
+#     label: Optional[str] = None
+#     bbox: Optional[List[float]] = None  # [x1, y1, x2, y2]
 
 
-class MultiUpdateRequest(BaseModel):
-    user_id: str
-    camera_name: str
-    image_url: str
-    operations: List[DetectionOperation]
+# class MultiUpdateRequest(BaseModel):
+#     user_id: str
+#     camera_name: str
+#     image_url: str
+#     operations: List[DetectionOperation]
 
 
-# ─────────────────
-# Endpoint
-# ─────────────────
+# # ─────────────────
+# # Endpoint
+# # ─────────────────
 
-@router.post("/modify_detections")
-async def modify_detections(req: MultiUpdateRequest):
-    """
-    Add, update, and delete detections (tags) for a given image.
-    Supports multiple operations in a single request.
-    """
-
-    #  Validate user 
-    user_path = Path(UPLOAD_DIR) / req.user_id
-    if not user_path.exists() or not user_path.is_dir():
-        raise HTTPException(status_code=404, detail="user not found")
-
-    #  Validate camera
-    camera_path = user_path / req.camera_name
-    if not camera_path.exists() or not camera_path.is_dir():
-        raise HTTPException(status_code=404, detail="camera not found")
-
-    # Validate JSON file
-    json_path = camera_path / f"{req.camera_name}_detections.json"
-    if not json_path.exists():
-        raise HTTPException(status_code=404, detail="detections file not found")
-
-    #  Load data 
-    data = load_json(json_path)
+# @router.post("/modify_detections")
+# async def modify_detections(req: MultiUpdateRequest):
+#     """
+#     Add, update, and delete detections (tags) for a given image.
+#     Supports multiple operations in a single request.
+#     """
 
-    #  Find image record
-    target_filename = req.image_url.split("/")[-1].split("?")[0]
-
-    record = None
-    for item in data:
-        stored = item.get("image_url", item.get("filename", ""))
-        stored_filename = stored.split("/")[-1].split("?")[0]
-        if stored_filename == target_filename:
-            record = item
-            break
-
-    if record is None:
-        raise HTTPException(status_code=404, detail="image not found")
-
-    # ── 6. Ensure detections list exists 
-    if "detections" not in record or not isinstance(record["detections"], list):
-        record["detections"] = []
-
-    dets = record["detections"]
-
-    # ── 7. Apply operations safely ──────
-    # NOTE: Reverse delete operations to avoid index shifting issues
-    delete_ops = [op for op in req.operations if op.action == "delete"]
-    other_ops = [op for op in req.operations if op.action != "delete"]
-
-    #  Handle DELETE (reverse order)
-    for op in sorted(delete_ops, key=lambda x: x.detection_index or -1, reverse=True):
-        if op.detection_index is None or op.detection_index >= len(dets):
-            raise HTTPException(
-                status_code=400,
-                detail=f"Invalid delete index {op.detection_index}"
-            )
-        dets.pop(op.detection_index)
-
-    #  Handle ADD + UPDATE
-    for op in other_ops:
-
-        #  ADD
-        if op.action == "add":
-            dets.append({
-                "label": op.label or "Unknown",
-                "confidence": 1.0,
-                "bbox": op.bbox or [],
-                "manually_edited": True
-            })
-
-        #  UPDATE
-        elif op.action == "update":
-            if op.detection_index is None or op.detection_index >= len(dets):
-                raise HTTPException(
-                    status_code=400,
-                    detail=f"Invalid update index {op.detection_index}"
-                )
-
-            if op.label is not None:
-                dets[op.detection_index]["label"] = op.label
-
-            if op.bbox is not None:
-                dets[op.detection_index]["bbox"] = op.bbox
-
-            dets[op.detection_index]["manually_edited"] = True
-
-    # ── 8. Save back ────────────────────
-    save_json(json_path, data)
+#     #  Validate user 
+#     user_path = Path(UPLOAD_DIR) / req.user_id
+#     if not user_path.exists() or not user_path.is_dir():
+#         raise HTTPException(status_code=404, detail="user not found")
 
-    logger.info(
-        "Detections modified | user=%s camera=%s file=%s ops=%d final_count=%d",
-        req.user_id,
-        req.camera_name,
-        target_filename,
-        len(req.operations),
-        len(dets)
-    )
+#     #  Validate camera
+#     camera_path = user_path / req.camera_name
+#     if not camera_path.exists() or not camera_path.is_dir():
+#         raise HTTPException(status_code=404, detail="camera not found")
 
-    # ── 9. Response ─────────────────────
-    return {
-        "success": True,
-        "message": "Detections modified successfully",
-        "filename": target_filename,
-        "total_detections": len(dets),
-        "detections": dets
-    }
+#     # Validate JSON file
+#     json_path = camera_path / f"{req.camera_name}_detections.json"
+#     if not json_path.exists():
+#         raise HTTPException(status_code=404, detail="detections file not found")
+
+#     #  Load data 
+#     data = load_json(json_path)
+
+#     #  Find image record
+#     target_filename = req.image_url.split("/")[-1].split("?")[0]
+
+#     record = None
+#     for item in data:
+#         stored = item.get("image_url", item.get("filename", ""))
+#         stored_filename = stored.split("/")[-1].split("?")[0]
+#         if stored_filename == target_filename:
+#             record = item
+#             break
+
+#     if record is None:
+#         raise HTTPException(status_code=404, detail="image not found")
+
+#     # ── 6. Ensure detections list exists 
+#     if "detections" not in record or not isinstance(record["detections"], list):
+#         record["detections"] = []
+
+#     dets = record["detections"]
+
+#     # ── 7. Apply operations safely ──────
+#     # NOTE: Reverse delete operations to avoid index shifting issues
+#     delete_ops = [op for op in req.operations if op.action == "delete"]
+#     other_ops = [op for op in req.operations if op.action != "delete"]
+
+#     #  Handle DELETE (reverse order)
+#     for op in sorted(delete_ops, key=lambda x: x.detection_index or -1, reverse=True):
+#         if op.detection_index is None or op.detection_index >= len(dets):
+#             raise HTTPException(
+#                 status_code=400,
+#                 detail=f"Invalid delete index {op.detection_index}"
+#             )
+#         dets.pop(op.detection_index)
+
+#     #  Handle ADD + UPDATE
+#     for op in other_ops:
+
+#         #  ADD
+#         if op.action == "add":
+#             dets.append({
+#                 "label": op.label or "Unknown",
+#                 "confidence": 1.0,
+#                 "bbox": op.bbox or [],
+#                 "manually_edited": True
+#             })
+
+#         #  UPDATE
+#         elif op.action == "update":
+#             if op.detection_index is None or op.detection_index >= len(dets):
+#                 raise HTTPException(
+#                     status_code=400,
+#                     detail=f"Invalid update index {op.detection_index}"
+#                 )
+
+#             if op.label is not None:
+#                 dets[op.detection_index]["label"] = op.label
+
+#             if op.bbox is not None:
+#                 dets[op.detection_index]["bbox"] = op.bbox
+
+#             dets[op.detection_index]["manually_edited"] = True
+
+#     # ── 8. Save back ────────────────────
+#     save_json(json_path, data)
+
+#     logger.info(
+#         "Detections modified | user=%s camera=%s file=%s ops=%d final_count=%d",
+#         req.user_id,
+#         req.camera_name,
+#         target_filename,
+#         len(req.operations),
+#         len(dets)
+#     )
+
+#     # ── 9. Response ─────────────────────
+#     return {
+#         "success": True,
+#         "message": "Detections modified successfully",
+#         "filename": target_filename,
+#         "total_detections": len(dets),
+#         "detections": dets
+#     }

api/main.py

@@ -30,8 +30,7 @@ def create_app() -> FastAPI:
     app.add_middleware(
         CORSMiddleware,
         allow_origins=[
-            'https://embroiderywala.myshopify.com',
-            'https://www.daleandcompany.com','http://127.0.0.1:8080','https://a8a2-185-134-22-81.ngrok-free.app'
+            'https://www.daleandcompany.com','http://127.0.0.1:8080'
         ],
         allow_credentials=True,
         allow_methods=["*"],

api/utils.py

@@ -1,5 +1,6 @@
 import os
 import json
+import tempfile
 from pathlib import Path
 from fastapi import HTTPException
 import cv2
@@ -7,6 +8,16 @@ import numpy as np
 from datetime import datetime
 from exif import Image as ExifImage
 from io import BytesIO
+from collections import defaultdict, Counter
+
+# HuggingFace bucket API
+from huggingface_hub import (
+    list_bucket_tree,
+    batch_bucket_files,
+    download_bucket_files,
+    get_bucket_paths_info,
+)
+
 # ---------------- CONFIG IMPORTS ----------------
 from .config import (
     DETECT_MODEL,
@@ -15,14 +26,91 @@ from .config import (
     ALLOWED_EXTENSIONS,
     MIN_IMAGES,
     MAX_IMAGES,
-    UPLOAD_DIR,
-    STORAGE_BACKEND,
-    gcs_bucket,
-    GCS_UPLOAD_DIR,
-    logger
+    UPLOAD_DIR,   # e.g. "codewithRiz/test_bucket"
+    logger,
 )
 
-# ---------------- VALIDATION ----------------
+# ----------------------------------------------------------------
+# BUCKET SETUP
+# All data is stored under:
+#   user_data/<user_id>/cameras.json
+#   user_data/<user_id>/<camera_name>/raw/<filename>
+#   user_data/<user_id>/<camera_name>/<camera_name>_detections.json
+# ----------------------------------------------------------------
+BUCKET_ID       = UPLOAD_DIR      # "namespace/bucket-name"
+BASE_DIR        = "user_data"     # top-level folder inside the bucket
+STORAGE_BACKEND = "huggingface"
+
+
+# ================================================================
+# BUCKET INTERNAL HELPERS  (replace local Path / open / json.load)
+# ================================================================
+
+def _bucket_key(user_id: str, *parts: str) -> str:
+    """Build a bucket key: user_data/<user_id>/<parts...>"""
+    return "/".join([BASE_DIR, user_id, *parts])
+
+
+def _read_bucket_json(key: str):
+    """Download JSON from bucket. Returns parsed object or None on miss."""
+    try:
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".json") as tf:
+            tmp_path = tf.name
+        download_bucket_files(BUCKET_ID, files=[(key, tmp_path)])
+        with open(tmp_path, "r") as f:
+            data = json.load(f)
+        os.unlink(tmp_path)
+        return data
+    except Exception as e:
+        logger.debug(f"_read_bucket_json({key}): {e}")
+        return None
+
+
+def _write_bucket_json(key: str, data):
+    """Serialize data to JSON and upload to bucket at key."""
+    raw_bytes = json.dumps(data, indent=2, default=str).encode("utf-8")
+    batch_bucket_files(BUCKET_ID, add=[(raw_bytes, key)])
+
+
+def _key_exists(key: str) -> bool:
+    """Return True if key exists in the bucket."""
+    try:
+        info = list(get_bucket_paths_info(BUCKET_ID, [key]))
+        return bool(info)
+    except Exception:
+        return False
+
+
+def _list_prefix(prefix: str) -> list:
+    """Return all file items under prefix (recursive)."""
+    try:
+        return [
+            item
+            for item in list_bucket_tree(BUCKET_ID, prefix=prefix, recursive=True)
+            if item.type == "file"
+        ]
+    except Exception:
+        return []
+
+
+# ================================================================
+# ORIGINAL HELPERS  (names unchanged, now return bucket keys)
+# ================================================================
+
+def get_user_folder(user_id: str) -> str:
+    """Return the bucket prefix for user's folder (no creation needed)."""
+    return f"{BASE_DIR}/{user_id}"
+
+
+def get_user_file(user_id: str) -> str:
+    """Return the bucket key for user's cameras.json."""
+    return f"{get_user_folder(user_id)}/cameras.json"
+
+
+# ================================================================
+# VALIDATION
+# ================================================================
+
 def validate_form(user_id, camera_name, images):
     if not user_id or not user_id.strip():
         raise HTTPException(400, "user_id is required")
@@ -44,6 +132,9 @@ def validate_form(user_id, camera_name, images):
     return images
 
 
+# ================================================================
+# EXIF / METADATA
+# ================================================================
 
 def make_json_safe(value):
     """Convert EXIF values to JSON-serializable types"""
@@ -82,11 +173,14 @@ def extract_metadata(image_bytes):
     return metadata
 
 
-# ---------------- IMAGE PROCESSING ----------------
+# ================================================================
+# IMAGE PROCESSING
+# ================================================================
+
 def process_image(image):
     """Run 3-stage detection and classification with dynamic confidence"""
     detections = []
-    results = DETECT_MODEL(image,conf=0.8 ,iou=0.4,agnostic_nms=True)  # Stage 1: Deer detection
+    results = DETECT_MODEL(image, conf=0.8, iou=0.4, agnostic_nms=True)  # Stage 1: Deer detection
     for r in results:
         for box in r.boxes:
             x1, y1, x2, y2 = map(int, box.xyxy[0])
@@ -94,7 +188,7 @@ def process_image(image):
             if crop.size == 0:
                 continue
             # ---------------- Stage 2: Buck/Doe ----------------
-            buck_res = BUCK_DOE_MODEL(crop) 
+            buck_res = BUCK_DOE_MODEL(crop)
             buck_probs = buck_res[0].probs
             top1_idx = buck_probs.top1
             buck_name = buck_res[0].names[top1_idx]
@@ -120,9 +214,10 @@ def process_image(image):
     return detections
 
 
+# ================================================================
+# CAMERA VALIDATION
+# ================================================================
 
-
-# ---------------- CAMERA VALIDATION ----------------
 def validate_user_and_camera(user_id: str, camera_name: str):
     if not user_exists(user_id):
         raise HTTPException(404, "User not found")
@@ -131,110 +226,96 @@ def validate_user_and_camera(user_id: str, camera_name: str):
         raise HTTPException(404, "Camera not registered")
 
 
-# ---------------- IMAGE SAVE ----------------
+# ================================================================
+# IMAGE SAVE
+# ================================================================
+
 def save_image(user_id, camera_name, filename, data):
-    path = BASE_DIR / user_id / camera_name / "raw"
-    path.mkdir(parents=True, exist_ok=True)
-    local_path = path / filename
-    with open(local_path, "wb") as f:
-        f.write(data)
-    if STORAGE_BACKEND == "gcs" and gcs_bucket:
-        blob = gcs_bucket.blob(f"{GCS_UPLOAD_DIR}{user_id}/{camera_name}/{filename}")
-        blob.upload_from_filename(local_path)
-        return blob.public_url
-    return f"/user_data/{user_id}/{camera_name}/raw/{filename}"
-
-
-# ---------------- JSON ----------------
+    key = _bucket_key(user_id, camera_name, "raw", filename)
+    batch_bucket_files(BUCKET_ID, add=[(data, key)])
+    return f"https://huggingface.co/buckets/{BUCKET_ID}/resolve/{key}"
+ 
+ 
+
+# ================================================================
+# JSON
+# ================================================================
+
 def load_json(path):
-    if Path(path).exists():
-        with open(path, "r") as f:
-            return json.load(f)
-    return []
+    """Load JSON from bucket key. Returns [] on miss (same behaviour as before)."""
+    result = _read_bucket_json(path)
+    return result if result is not None else []
 
-def save_json(path, data):
-    with open(path, "w") as f:
-        json.dump(data, f, indent=4)
 
-# ---------------- USER FOLDERS / CAMERAS ----------------
-BASE_DIR = Path(UPLOAD_DIR)
-BASE_DIR.mkdir(exist_ok=True)
+def save_json(path, data):
+    """Save data as JSON to bucket key."""
+    _write_bucket_json(path, data)
 
-def get_user_folder(user_id: str) -> Path:
-    """Return path to user's folder WITHOUT creating it"""
-    return BASE_DIR / f"{user_id}"
 
-def get_user_file(user_id: str) -> Path:
-    """Return path to user's cameras.json WITHOUT creating it"""
-    return get_user_folder(user_id) / "cameras.json"
+# ================================================================
+# USER FOLDERS / CAMERAS
+# ================================================================
 
 def user_exists(user_id: str) -> bool:
-    return get_user_file(user_id).exists()
+    return _key_exists(get_user_file(user_id))
+
 
 def load_cameras(user_id: str) -> list:
     path = get_user_file(user_id)
-    if not path.exists():
-        return []
     try:
-        with open(path, "r") as f:
-            return json.load(f)
-    except json.JSONDecodeError:
+        data = _read_bucket_json(path)
+        return data if isinstance(data, list) else []
+    except Exception:
         return []
 
+
 def save_cameras(user_id: str, cameras: list):
-    # Folder only created when we are saving ( Add Camera)
-    folder = get_user_folder(user_id)
-    folder.mkdir(exist_ok=True)
-    with open(folder / "cameras.json", "w") as f:
-        json.dump(cameras, f, indent=2)
+    # Bucket keys don't need folder creation — just write the file
+    _write_bucket_json(get_user_file(user_id), cameras)
+
 
+# ================================================================
+# DASHBOARD
+# ================================================================
 
-#>>>>>>>>dashboard>>>>>>>>>>>>
 def get_user_dashboard(user_id: str, camera_name: str = None) -> dict:
     """Return analytics for a user or a specific camera"""
-    user_folder = Path(UPLOAD_DIR) / user_id
-    cameras_file = user_folder / "cameras.json"
-    if not cameras_file.exists():
+    cameras_file = get_user_file(user_id)
+    if not _key_exists(cameras_file):
         raise HTTPException(404, f"User {user_id} not found")
-    
+
     try:
-        with open(cameras_file, "r") as f:
-            cameras = json.load(f)
-    except json.JSONDecodeError:
+        cameras = _read_bucket_json(cameras_file) or []
+    except Exception:
         cameras = []
-    
+
     total_cameras = len(cameras)
     total_images = 0
     total_detections = 0
     buck_type_distribution = {}
     buck_doe_distribution = {"Buck": 0, "Doe": 0}
 
-    # New dashboard analytics
-    from collections import defaultdict, Counter
-    from datetime import datetime
-
-    heatmap = defaultdict(lambda: [0]*24)  # day -> 24 hours
+    heatmap = defaultdict(lambda: [0] * 24)   # day -> 24 hours
     deer_per_day = Counter()
     bucks_per_day = Counter()
     does_per_day = Counter()
-    hour_activity = [0]*24  # 0-23 hours
+    hour_activity = [0] * 24                  # 0-23 hours
 
     for cam in cameras:
         cam_name = cam["camera_name"]
         if camera_name and cam_name != camera_name:
             continue
-        
-        raw_folder = user_folder / cam_name / "raw"
-        detections_file = user_folder / cam_name / f"{cam_name}_detections.json"
-        
-        # Count images
-        if raw_folder.exists():
-            total_images += len(list(raw_folder.glob("*.*")))
-        
-        # Count detections and distributions
-        if detections_file.exists():
+
+        # Count images  (replaces raw_folder.glob("*.*"))
+        raw_folder = _bucket_key(user_id, cam_name, "raw")
+        raw_files = _list_prefix(raw_folder)
+        total_images += len(raw_files)
+
+        # Count detections and distributions  (replaces open(detections_file))
+        detections_file = _bucket_key(user_id, cam_name, f"{cam_name}_detections.json")
+        if _key_exists(detections_file):
             try:
-                dets = json.load(open(detections_file, "r"))
+                dets = _read_bucket_json(detections_file) or []
                 for rec in dets:
                     # --- Existing Buck/Doe counts ---
                     for d in rec.get("detections", []):
@@ -247,17 +328,17 @@ def get_user_dashboard(user_id: str, camera_name: str = None) -> dict:
                                 buck_type_distribution[parts[2]] = buck_type_distribution.get(parts[2], 0) + 1
                             else:  # Doe
                                 buck_doe_distribution["Doe"] += 1
-                    
+
                     # --- New analytics using datetime_original ---
                     dt_str = rec.get("metadata", {}).get("exif", {}).get("datetime_original")
                     if dt_str:
                         dt = datetime.strptime(dt_str, "%Y:%m:%d %H:%M:%S")
                         day = dt.date()
                         hour = dt.hour
-                        
+
                         # Heatmap count
                         heatmap[day][hour] += len(rec.get("detections", []))
-                        
+
                         # Count deer, bucks, does per day
                         for d in rec.get("detections", []):
                             label = d.get("label", "")
@@ -267,15 +348,15 @@ def get_user_dashboard(user_id: str, camera_name: str = None) -> dict:
                                 bucks_per_day[day] += 1
                             if "Doe" in label:
                                 does_per_day[day] += 1
-                        
+
                         # Hourly aggregated activity
                         hour_activity[hour] += len(rec.get("detections", []))
-            except json.JSONDecodeError:
+            except Exception:
                 continue
 
     # Average activity by hour (morning/night)
     morning_hours = range(6, 18)
-    night_hours = list(range(0,6)) + list(range(18,24))
+    night_hours = list(range(0, 6)) + list(range(18, 24))
     morning_activity = sum(hour_activity[h] for h in morning_hours) / len(morning_hours)
     night_activity = sum(hour_activity[h] for h in night_hours) / len(night_hours)
 
@@ -293,8 +374,7 @@ def get_user_dashboard(user_id: str, camera_name: str = None) -> dict:
         "bucks_per_day": dict(bucks_per_day),
         "does_per_day": dict(does_per_day),
         "average_activity": {
-            "morning": round(morning_activity,2),
-            "night": round(night_activity,2)
+            "morning": round(morning_activity, 2),
+            "night": round(night_activity, 2)
         }
-    }
-
+    }

api/view_image.py

@@ -1,14 +1,21 @@
 from fastapi import APIRouter, HTTPException, Query, Request
-from pathlib import Path
 import json
-from .config import UPLOAD_DIR
+from .utils import (
+    _bucket_key,
+    _key_exists,
+    _list_prefix,
+    _read_bucket_json,
+    user_exists,
+    BUCKET_ID,
+)
 
 router = APIRouter()
 
+
 @router.get("/view_images")
 def view_images(
-    request: Request, 
-    user_id: str = Query(...), 
+    request: Request,
+    user_id: str = Query(...),
     camera_name: str = Query(...),
     filter_label: str = Query(None, description="Optional filter: Buck, Doe, Mule, Whitetail")
 ):
@@ -17,44 +24,44 @@ def view_images(
     Returns clickable URLs for each image.
     Optionally filter images based on labels (Buck, Doe, Mule, Whitetail).
     """
-    user_folder = Path(UPLOAD_DIR) / user_id
-    if not user_folder.exists():
+    # ── existence checks against the bucket ──────────────────────
+    if not user_exists(user_id):
         raise HTTPException(status_code=404, detail="User not found")
 
-    camera_folder = user_folder / camera_name
-    raw_folder = camera_folder / "raw"
-    detection_file = camera_folder / f"{camera_name}_detections.json"
+    raw_prefix     = _bucket_key(user_id, camera_name, "raw")
+    detection_key  = _bucket_key(user_id, camera_name, f"{camera_name}_detections.json")
 
-    if not raw_folder.exists():
+    raw_files = _list_prefix(raw_prefix)
+    if not raw_files:
         raise HTTPException(status_code=404, detail="Camera raw folder not found")
-    if not detection_file.exists():
+
+    if not _key_exists(detection_key):
         raise HTTPException(status_code=404, detail="Detection JSON not found")
 
-    # Load detection JSON
-    try:
-        with open(detection_file, "r") as f:
-            detections = json.load(f)
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Failed to read detection file: {e}")
+    # ── load detections from bucket ───────────────────────────────
+    detections = _read_bucket_json(detection_key)
+    if detections is None:
+        raise HTTPException(status_code=500, detail="Failed to read detection file")
 
-    # Determine base URL (cloud-safe)
-    base_url = str(request.base_url)
-    if "0.0.0.0" in base_url or "127.0.0.1" in base_url:
-        base_url = base_url.replace("0.0.0.0", "localhost").replace("127.0.0.1", "localhost")
-    if not base_url.endswith("/"):
-        base_url += "/"
+    # ── build a set of filenames that exist in the bucket ─────────
+    existing_filenames = {item.path.split("/")[-1] for item in raw_files}
 
-    # List of labels to filter if provided
+    # ── validate filter label ─────────────────────────────────────
     valid_filters = {"buck", "doe", "mule", "whitetail"}
     filter_lower = filter_label.lower() if filter_label else None
     if filter_lower and filter_lower not in valid_filters:
-        raise HTTPException(status_code=400, detail=f"Invalid filter_label. Must be one of {valid_filters}")
+        raise HTTPException(
+            status_code=400,
+            detail=f"Invalid filter_label. Must be one of {valid_filters}"
+        )
 
+    # ── build response ────────────────────────────────────────────
     images = []
     for item in detections:
-        image_path = raw_folder / item["filename"]
-        if image_path.exists():
-            item["image_url"] = f"{base_url}user_data/{user_id}/{camera_name}/raw/{item['filename']}"
+        filename = item["filename"]
+
+        if filename in existing_filenames:
+            item["image_url"] = f"https://huggingface.co/buckets/{BUCKET_ID}/resolve/{raw_prefix}/{filename}"
         else:
             item["missing"] = True
             item["image_url"] = None
@@ -62,7 +69,7 @@ def view_images(
         # Apply label filter if provided
         if filter_lower:
             filtered_detections = [
-                det for det in item.get("detections", []) 
+                det for det in item.get("detections", [])
                 if any(lbl.lower().find(filter_lower) != -1 for lbl in det["label"].split("|"))
             ]
             if filtered_detections:
@@ -77,4 +84,4 @@ def view_images(
         "camera_name": camera_name,
         "filter_label": filter_label,
         "images": images
-    }
+    }

requirements.txt

@@ -4,7 +4,6 @@ numpy
 pillow
 pyngrok
 python-dotenv
-google-cloud-storage
 gunicorn
 waitress
 fastapi