init

.gitattributes

@@ -0,0 +1,3 @@
+api/walidlife_models/*.pt filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,65 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Environment folders
+.env
+.venv/
+venv/
+env/
+ENV/
+
+# IDE / Editor settings
+.vscode/
+.idea/
+*.sublime-project
+*.sublime-workspace
+
+# OS-generated files
+.DS_Store
+Thumbs.db
+
+# Jupyter Notebook checkpoints
+.ipynb_checkpoints
+
+# Logs and temp files
+*.log
+*.tmp
+*.swp
+
+
+
+# Data files
+*.csv
+*.tsv
+*.json
+*.zip
+*.tar
+*.gz
+*.json
+*.pickle
+*.pkl
+# Model files
+*.h5
+*.pth
+*.pt
+*.tflite
+*.onnx
+
+# Audio/video/temp data
+*.wav
+*.mp3
+*.mp4
+*.html
+# Streamlit and Gradio cache
+.streamlit/
+gradio_cached_examples/
+
+# __pycache__ in subfolders
+*/__pycache__/
+
+
+api/uploaded_images/
+api/walidlife_models/
+api/user_data/

Dockerfile

@@ -0,0 +1,51 @@
+# ----------------------------
+# Stage 1: Builder
+# ----------------------------
+FROM python:3.12-slim AS builder
+
+WORKDIR /app
+
+# Install only what is needed for building wheels
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    gcc \
+    libgl1 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy dependencies file
+COPY requirements.txt .
+
+# Install dependencies into a temporary folder
+RUN pip install --upgrade pip && \
+    pip install --prefix=/install --no-cache-dir -r requirements.txt
+
+# Copy source
+COPY . .
+
+# ----------------------------
+# Stage 2: Runtime (minimal size)
+# ----------------------------
+FROM python:3.12-slim
+
+WORKDIR /app
+
+# Install minimal runtime libraries only
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    libgl1 \
+    libglib2.0-0 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy only installed python deps
+COPY --from=builder /install /usr/local
+
+# Copy only application code (not build deps)
+COPY --from=builder /app /app
+
+# Reduce Python overhead
+ENV PYTHONUNBUFFERED=1
+ENV PYTHONDONTWRITEBYTECODE=1
+
+EXPOSE 7860
+
+# Use multiple workers in a lightweight way
+CMD ["uvicorn", "api.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,11 @@
+---
+title: Wildlife Detection App
+emoji: "🦌"
+colorFrom: "blue"
+colorTo: "green"
+sdk: "streamlit"
+sdk_version: "1.25.0"
+python_version: "3.12"
+app_file: app.py
+pinned: false
+---

api/analytics.py

@@ -0,0 +1,27 @@
+from fastapi import APIRouter, Query, HTTPException
+from .utils import get_user_dashboard, validate_user_and_camera
+
+router = APIRouter()
+
+@router.get("/user_dashboard")
+def user_dashboard(
+    user_id: str = Query(..., description="User ID for analytics"),
+    camera_name: str = Query(None, description="Optional camera name to filter")
+):
+    """
+    Return analytics for a user. 
+    If camera_name is provided, validate camera and show stats for that camera only.
+    """
+    try:
+        # Validate camera if specified
+        if camera_name:
+            validate_user_and_camera(user_id, camera_name)
+
+        # Get dashboard (all cameras or specific)
+        dashboard = get_user_dashboard(user_id, camera_name=camera_name)
+        return {"success": True, "dashboard": dashboard}
+
+    except HTTPException as e:
+        raise e
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Internal error: {str(e)}")

api/auth.py

@@ -0,0 +1,10 @@
+from fastapi import APIRouter
+
+router = APIRouter()
+
+@router.get("/status")
+async def status():
+    return {
+        "status": "success",
+        "message": "Auth blueprint active"
+    }

api/camera.py

@@ -0,0 +1,153 @@
+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
+import os
+import shutil
+
+print(" CAMERA API LOADED ")
+
+router = APIRouter(prefix="/camera", tags=["Camera"])
+
+# ================= MODELS =================
+class CameraData(BaseModel):
+    user_id: str = Field(..., min_length=1)
+    camera_name: str = Field(..., min_length=1)
+    camera_loc: Optional[List[float]] = None
+
+    @validator("camera_loc")
+    def validate_loc(cls, loc):
+        if loc is None:
+            return loc
+        if len(loc) != 2:
+            raise ValueError("camera_loc must be [lat, lon]")
+        lat, lon = loc
+        if not (-90 <= lat <= 90):
+            raise ValueError("Latitude must be between -90 and 90")
+        if not (-180 <= lon <= 180):
+            raise ValueError("Longitude must be between -180 and 180")
+        return loc
+
+
+class EditCameraData(BaseModel):
+    user_id: str
+    old_camera_name: str
+    new_camera_name: str
+    new_camera_loc: List[float]
+
+    @validator("new_camera_loc")
+    def validate_loc(cls, loc):
+        if len(loc) != 2:
+            raise ValueError("new_camera_loc must be [lat, lon]")
+        lat, lon = loc
+        if not (-90 <= lat <= 90):
+            raise ValueError("Latitude must be between -90 and 90")
+        if not (-180 <= lon <= 180):
+            raise ValueError("Longitude must be between -180 and 180")
+        return loc
+
+
+# ================= ROUTES =================
+@router.get("/")
+def home():
+    return {
+        "message": "Camera API is Running",
+        "endpoints": [
+            "/camera/add_camera",
+            "/camera/edit_camera",
+            "/camera/delete_camera",
+            "/camera/get_cameras?user_id=<id>"
+        ]
+    }
+
+
+# ---------- GET CAMERAS ----------
+@router.get("/get_cameras")
+def get_cameras(user_id: str = Query(...)):
+    if not user_exists(user_id):
+        raise HTTPException(status_code=404, detail="User not found")
+
+    cameras = load_cameras(user_id)
+    return {"success": True, "user_id": user_id, "cameras": cameras, "count": len(cameras)}
+
+
+# ---------- ADD CAMERA ----------
+@router.post("/add_camera")
+def add_camera(data: CameraData):
+    cameras = load_cameras(data.user_id)
+
+    if len(cameras) >= 2:
+        raise HTTPException(status_code=400, detail="Only 2 cameras allowed")
+
+    for cam in cameras:
+        if cam["camera_name"].lower() == data.camera_name.lower():
+            raise HTTPException(status_code=400, detail="Camera already exists")
+
+    cameras.append({"camera_name": data.camera_name, "camera_loc": data.camera_loc})
+    save_cameras(data.user_id, cameras)
+
+    return {"success": True, "camera": data.camera_name}
+
+@router.put("/edit_camera")
+def edit_camera(data: EditCameraData):
+    if not user_exists(data.user_id):
+        raise HTTPException(status_code=404, detail="User not found")
+
+    cameras = load_cameras(data.user_id)
+
+    # Check if new camera name already exists (case-insensitive)
+    if any(cam["camera_name"].lower() == data.new_camera_name.lower() for cam in cameras):
+        raise HTTPException(status_code=400, detail=f"Camera name '{data.new_camera_name}' already exists")
+
+    camera_found = False
+    for cam in cameras:
+        if cam["camera_name"].lower() == data.old_camera_name.lower():
+            old_name = cam["camera_name"]
+            cam["camera_name"] = data.new_camera_name
+            cam["camera_loc"] = data.new_camera_loc
+            camera_found = True
+
+            # Rename camera folder
+            old_folder = os.path.join(UPLOAD_DIR, data.user_id, old_name)
+            new_folder = os.path.join(UPLOAD_DIR, data.user_id, data.new_camera_name)
+            if os.path.exists(old_folder) and os.path.isdir(old_folder):
+                try:
+                    os.rename(old_folder, new_folder)
+                except Exception as e:
+                    raise HTTPException(status_code=500, detail=f"Failed to rename camera folder: {str(e)}")
+
+                # Rename detection JSON
+                for f in os.listdir(new_folder):
+                    if f.endswith("_detections.json") and f.lower().startswith(old_name.lower()):
+                        old_json = os.path.join(new_folder, f)
+                        new_json_name = f.replace(old_name, data.new_camera_name)
+                        new_json = os.path.join(new_folder, new_json_name)
+                        try:
+                            os.rename(old_json, new_json)
+                        except Exception as e:
+                            raise HTTPException(status_code=500, detail=f"Failed to rename detection JSON: {str(e)}")
+                        break  # Only one detection JSON per camera
+
+            save_cameras(data.user_id, cameras)
+            return {"success": True, "updated": cam}
+
+    if not camera_found:
+        raise HTTPException(status_code=404, detail="Camera not found")
+
+@router.delete("/delete_camera")
+def delete_camera(user_id: str = Query(...), camera_name: str = Query(...)):
+    if not user_exists(user_id):
+        raise HTTPException(status_code=404, detail="User not found")
+    cameras = load_cameras(user_id)
+    new_list = [c for c in cameras if c["camera_name"].lower() != camera_name.lower()]
+    if len(new_list) == len(cameras):
+        raise HTTPException(status_code=404, detail="Camera not found")
+    save_cameras(user_id, new_list)
+    camera_folder = os.path.join(UPLOAD_DIR, user_id, camera_name)
+    if os.path.exists(camera_folder) and os.path.isdir(camera_folder):
+        try:
+            shutil.rmtree(camera_folder)
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Failed to delete camera folder: {str(e)}")
+    return {"success": True, "deleted": camera_name}

api/config.py

@@ -0,0 +1,69 @@
+import os
+import logging
+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__))
+
+# ---------------- LOGGER ----------------
+LOG_FILE = os.path.join(BASE_DIR, "api.log")
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(message)s",
+    handlers=[logging.FileHandler(LOG_FILE), logging.StreamHandler()]
+)
+
+logger = logging.getLogger("WildlifeLogger")
+
+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"
+
+# ---------------- UPLOAD RULES ----------------
+MIN_IMAGES = 1
+MAX_IMAGES = 1000
+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")
+    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

api/detection.py

@@ -0,0 +1,50 @@
+from fastapi import APIRouter, UploadFile, File, Form, HTTPException
+from pathlib import Path
+import cv2
+import numpy as np
+
+from .config import UPLOAD_DIR
+from .utils import (
+    validate_form,
+    process_image,
+    save_image,
+    load_json,
+    save_json,
+    validate_user_and_camera
+)
+
+router = APIRouter()
+@router.post("/predict")
+async def predict(
+    user_id: str = Form(...),
+    camera_name: str = Form(...),
+    images: list[UploadFile] = File(...)
+):
+    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"
+    data = load_json(json_path)
+    new_results = []
+    for file in images:
+        raw = await file.read()
+        nparr = np.frombuffer(raw, np.uint8)
+        img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+        if img is None:
+            raise HTTPException(400, f"Invalid image: {file.filename}")
+        detections = process_image(img)
+        url = save_image(user_id, camera_name, file.filename, raw)
+        record = {
+            "filename": file.filename,
+            "image_url": url,
+            "detections": detections
+        }
+        data.append(record)
+        new_results.append(record)
+    save_json(json_path, data)
+    return {
+        "message": "Images processed successfully",
+        "camera": camera_name,
+        "results": new_results
+    }

api/main.py

@@ -0,0 +1,73 @@
+# main.py
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+import logging
+from pathlib import Path
+
+# ----------------- Import Routers -----------------
+from .detection import router as detection_router
+from .auth import router as auth_router
+from .camera import router as camera_router  # Camera router
+from .config import UPLOAD_DIR  # Folder where images are saved
+from .analytics import router as analytics_router
+from .view_image import router as view_images_router
+# ---------------- Logging Setup -----------------
+logger = logging.getLogger("ServerLogger")
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s"
+)
+
+# Ensure UPLOAD_DIR exists
+Path(UPLOAD_DIR).mkdir(parents=True, exist_ok=True)
+
+# ---------------- Create App -----------------
+def create_app() -> FastAPI:
+    app = FastAPI(title="Wildlife Detection & Camera API Server")
+
+    # ---- CORS Configuration ----
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=[
+            'https://embroiderywala.myshopify.com',
+            'https://www.daleandcompany.com','http://127.0.0.1:8080'
+        ],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    # ---- Mount static folder for uploaded images ----
+    app.mount("/user_data", StaticFiles(directory=UPLOAD_DIR), name="user_data")
+    logger.info(f"Static folder mounted at /user_data -> {UPLOAD_DIR}")
+
+    # ---- Include Routers ----
+    app.include_router(auth_router, prefix="/auth", tags=["Auth"])
+    app.include_router(camera_router, prefix="/api", tags=["Camera"])
+    app.include_router(detection_router, prefix="/api/detection", tags=["Detection"])
+    app.include_router(analytics_router,prefix="/api", tags=["Analytics"])
+    app.include_router(view_images_router, prefix="/api", tags=["Images"])
+
+    # ---- Health Check / Startup Event ----
+    @app.on_event("startup")
+    async def startup_check():
+        logger.info("Server started successfully. All routers are active.")
+
+    # ---- Root Endpoint ----
+    @app.get("/")
+    def root():
+        return {
+            "message": "Wildlife Detection & Camera API Server is Running",
+            "routes": {
+                "auth": "/auth/...",
+                "camera": "/api/camera/...",
+                "detection": "/api/detection/...",
+                "analytics": "/api/analytics/..."
+
+            }
+        }
+
+    return app
+
+app = create_app()

api/utils.py

@@ -0,0 +1,219 @@
+import os
+import json
+from pathlib import Path
+from fastapi import HTTPException
+import cv2
+import numpy as np
+
+# ---------------- CONFIG IMPORTS ----------------
+from .config import (
+    DETECT_MODEL,
+    BUCK_DOE_MODEL,
+    BUCK_TYPE_MODEL,
+    ALLOWED_EXTENSIONS,
+    MIN_IMAGES,
+    MAX_IMAGES,
+    UPLOAD_DIR,
+    STORAGE_BACKEND,
+    gcs_bucket,
+    GCS_UPLOAD_DIR,
+    logger
+)
+
+# ---------------- 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")
+
+    if not camera_name or not camera_name.strip():
+        raise HTTPException(400, "camera_name is required")
+
+    if not images or len(images) == 0:
+        raise HTTPException(400, "At least one image is required")
+
+    images = [f for f in images if f.filename and f.filename.strip()]
+
+    if len(images) < MIN_IMAGES:
+        raise HTTPException(400, f"At least {MIN_IMAGES} image(s) required")
+
+    if len(images) > MAX_IMAGES:
+        raise HTTPException(400, f"Maximum {MAX_IMAGES} images allowed")
+
+    for f in images:
+        if "." not in f.filename:
+            raise HTTPException(400, f"Invalid file: {f.filename}")
+
+        ext = f.filename.rsplit(".", 1)[1].lower()
+        if ext not in ALLOWED_EXTENSIONS:
+            raise HTTPException(400, f"Invalid file type: {f.filename}")
+
+    return images
+
+# ---------------- IMAGE PROCESSING ----------------
+def process_image(image):
+    """Run detection and classification on an image"""
+    detections = []
+    results = DETECT_MODEL(image)
+
+    for r in results:
+        for box in r.boxes:
+            x1, y1, x2, y2 = map(int, box.xyxy[0])
+            crop = image[y1:y2, x1:x2]
+            if crop.size == 0:
+                continue
+
+            buck_res = BUCK_DOE_MODEL(crop)
+            buck_name = buck_res[0].names[buck_res[0].probs.top1]
+
+            if buck_name.lower() == "buck":
+                type_res = BUCK_TYPE_MODEL(crop)
+                type_name = type_res[0].names[type_res[0].probs.top1]
+                label = f"Deer | Buck | {type_name}"
+            else:
+                label = "Deer | Doe"
+
+            detections.append({
+                "label": label,
+                "bbox": [x1, y1, x2, y2]
+            })
+
+    return detections
+
+
+
+# ---------------- 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")
+
+    cameras = load_cameras(user_id)
+
+    if not any(c["camera_name"] == camera_name for c in cameras):
+        raise HTTPException(404, "Camera not registered")
+
+
+# ---------------- 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 ----------------
+def load_json(path):
+    if Path(path).exists():
+        with open(path, "r") as f:
+            return json.load(f)
+    return []
+
+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 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"
+
+def user_exists(user_id: str) -> bool:
+    return get_user_file(user_id).exists()
+
+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:
+        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)
+
+
+
+#>>>>>>>>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():
+        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 = []
+
+    total_cameras = len(cameras)
+    total_images = 0
+    total_detections = 0
+    buck_type_distribution = {}
+    buck_doe_distribution = {"Buck": 0, "Doe": 0}
+
+    for cam in cameras:
+        cam_name = cam["camera_name"]
+
+        # Skip cameras if a specific one is selected
+        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():
+            try:
+                dets = json.load(open(detections_file, "r"))
+                for rec in dets:
+                    for d in rec.get("detections", []):
+                        total_detections += 1
+                        label = d.get("label", "")
+                        if "|" in label:
+                            parts = [p.strip() for p in label.split("|")]
+                            if len(parts) == 3:  # Buck with type
+                                buck_doe_distribution["Buck"] += 1
+                                buck_type_distribution[parts[2]] = buck_type_distribution.get(parts[2], 0) + 1
+                            else:  # Doe
+                                buck_doe_distribution["Doe"] += 1
+            except json.JSONDecodeError:
+                continue
+    return {
+        "user_id": user_id,
+        "selected_camera": camera_name,
+        "total_cameras": total_cameras,
+        "images_uploaded": total_images,
+        "total_detections": total_detections,
+        "buck_type_distribution": buck_type_distribution,
+        "buck_doe_distribution": buck_doe_distribution
+    }

api/view_image.py

@@ -0,0 +1,80 @@
+from fastapi import APIRouter, HTTPException, Query, Request
+from pathlib import Path
+import json
+from .config import UPLOAD_DIR
+
+router = APIRouter()
+
+@router.get("/view_images")
+def view_images(
+    request: Request, 
+    user_id: str = Query(...), 
+    camera_name: str = Query(...),
+    filter_label: str = Query(None, description="Optional filter: Buck, Doe, Mule, Whitetail")
+):
+    """
+    Get images and detection info for a user's camera.
+    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():
+        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"
+
+    if not raw_folder.exists():
+        raise HTTPException(status_code=404, detail="Camera raw folder not found")
+    if not detection_file.exists():
+        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}")
+
+    # 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 += "/"
+
+    # List of labels to filter if provided
+    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}")
+
+    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']}"
+        else:
+            item["missing"] = True
+            item["image_url"] = None
+
+        # Apply label filter if provided
+        if filter_lower:
+            filtered_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:
+                item["detections"] = filtered_detections
+                images.append(item)
+        else:
+            images.append(item)
+
+    return {
+        "success": True,
+        "user_id": user_id,
+        "camera_name": camera_name,
+        "filter_label": filter_label,
+        "images": images
+    }

app.py

@@ -0,0 +1,26 @@
+import warnings
+warnings.filterwarnings("ignore", message="Corrupt JPEG data")
+
+import os
+from dotenv import load_dotenv
+from pyngrok import ngrok
+import uvicorn
+
+load_dotenv()
+NGROK_AUTH_TOKEN = os.getenv("NGROK_AUTH_TOKEN")
+
+if NGROK_AUTH_TOKEN:
+    ngrok.set_auth_token(NGROK_AUTH_TOKEN)
+
+
+
+# if __name__ == "__main__":
+
+#     #     # Run FastAPI
+#     uvicorn.run(
+#         "api.main:app",
+#         host="0.0.0.0",
+#         port=7860,
+#         reload=True,
+#         log_level="info"
+#     )

dockerignore

@@ -0,0 +1,24 @@
+# Ignore virtual environments
+venv/
+env/
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+
+# Ignore Git and IDE files
+.git
+.gitignore
+.DS_Store
+.vscode/
+.idea/
+
+# Ignore local data folders
+api/uploaded_images/
+others/
+
+# Ignore temporary or log files
+*.log
+*.tmp
+*.bak
+*.html

requirements.txt

@@ -0,0 +1,12 @@
+ultralytics
+opencv-python
+numpy
+pillow
+pyngrok
+python-dotenv
+google-cloud-storage
+gunicorn
+waitress
+fastapi
+uvicorn
+python-multipart