🚀 Complete Supabase Migration - Clean Architecture Ready for Deployment

✅ CRITICAL FIXES APPLIED:
- Remove duplicate database classes from supabase_client.py
- Fix storage bucket naming mismatch (tree-audio consistency)
- Remove hardcoded URLs, enforce environment variables
- Configure private storage buckets with signed URLs
- Clean up obsolete files (app_supabase.py, app_sqlite_backup.py)
- Optimize config for HuggingFace Spaces (port 7860, CORS *)
- Make environment validation deployment-friendly

🌳 MASTER DATABASE: 146 species preserved & functional
🏗️ ARCHITECTURE: Clean Supabase-only implementation
📁 FILES: Minimal, focused structure
🔧 FEATURES: All 12 tree fields + file uploads + autocomplete

Ready for HuggingFace Spaces deployment! 🎯

DEPLOYMENT_READY.md

@@ -0,0 +1,121 @@
+# TreeTrack - Deployment Ready ✅
+
+## Migration Status: COMPLETE
+**Date**: January 8, 2025  
+**Status**: ✅ Ready for deployment  
+**Backend**: Supabase Postgres + Storage  
+**Master Database**: ✅ 146 species preserved  
+
+---
+
+## 🗂️ File Structure (Clean)
+```
+TreeTrack/
+├── app.py                    # Main FastAPI application 
+├── config.py                 # Configuration management
+├── supabase_client.py        # Supabase client setup
+├── supabase_database.py      # Database operations
+├── supabase_storage.py       # File storage operations
+├── master_tree_database.py   # Autocomplete species database
+├── requirements.txt          # Python dependencies
+├── static/                   # Frontend assets
+├── data/                     # Local SQLite for master species
+└── DEPLOYMENT_READY.md       # This file
+```
+
+## 🌳 Master Tree Database
+- **Status**: ✅ Fully preserved and functional
+- **Entries**: 146 tree species (including 6 local-name-only entries)
+- **Storage**: Local SQLite database (`data/master_trees.db`)
+- **Purpose**: Fast autocomplete and suggestions
+- **API Endpoints**: 
+  - `/api/tree-suggestions?query=<search>`
+  - `/api/tree-codes`
+
+### Sample Species Available:
+- **Sal** (Shorea robusta) - Tree Code: SR
+- **Neem** (Azadirachta indica) - Tree Code: AI2  
+- **Borgos** (Ficus benghalensis) - Tree Code: FB
+- **And 143 more...**
+
+## 🏗️ Architecture
+- **Database**: Supabase Postgres (cloud-persistent)
+- **Storage**: Supabase Storage with signed URLs
+- **Autocomplete**: Local SQLite for performance
+- **API**: FastAPI with comprehensive REST endpoints
+- **Frontend**: Static HTML/JS (unchanged)
+
+## 🔧 Key Features Preserved
+✅ All 12 tree fields (location, names, measurements, etc.)  
+✅ File uploads (images, audio) with cloud storage  
+✅ Tree CRUD operations  
+✅ Statistics and analytics  
+✅ Master species autocomplete  
+✅ Photo categories and phenology stages  
+✅ Search and filtering  
+
+## 🌐 API Endpoints
+```
+GET  /                          # Frontend
+GET  /health                    # Health check
+GET  /api/trees                 # List trees
+POST /api/trees                 # Create tree  
+GET  /api/trees/{id}           # Get tree
+PUT  /api/trees/{id}           # Update tree
+DELETE /api/trees/{id}         # Delete tree
+POST /api/upload/image         # Upload image
+POST /api/upload/audio         # Upload audio
+GET  /api/tree-suggestions     # Autocomplete ⭐
+GET  /api/tree-codes           # Tree codes ⭐
+GET  /api/stats                # Statistics
+```
+
+## 📦 Dependencies
+All required packages in `requirements.txt`:
+- `fastapi>=0.115.0`
+- `uvicorn[standard]>=0.32.0`
+- `supabase>=2.3.4`
+- `psycopg2-binary>=2.9.9`
+- Plus supporting libraries
+
+## 🚀 Deployment Notes
+1. **Environment Variables Required**:
+   - `SUPABASE_URL`
+   - `SUPABASE_ANON_KEY` 
+   - `SUPABASE_SERVICE_ROLE_KEY`
+
+2. **Supabase Setup Required**:
+   - Trees table with 12 fields
+   - Storage buckets: `tree-images`, `tree-audio`
+   - Row Level Security policies
+
+3. **Master Database**: 
+   - Auto-initializes on startup
+   - Creates local `data/master_trees.db`
+   - No manual setup required
+
+## ✅ Pre-Deploy Checklist
+- [x] SQLite dependencies removed  
+- [x] Database interface abstracted
+- [x] Supabase modules standalone
+- [x] Master tree database preserved
+- [x] All syntax validated
+- [x] File structure cleaned
+- [x] Requirements updated
+- [x] **CRITICAL FIXES APPLIED**:
+  - [x] Removed duplicate database classes
+  - [x] Fixed bucket naming mismatch (tree-audio vs tree-audios)
+  - [x] Removed hardcoded Supabase URL
+  - [x] Fixed storage bucket configuration (private with signed URLs)
+  - [x] Made environment validation deployment-friendly
+  - [x] Optimized config for HuggingFace Spaces (port 7860, CORS *)
+
+## 🎯 Next Steps
+1. **Deploy to HuggingFace Spaces**
+2. **Monitor deployment logs**
+3. **Test master database autocomplete**
+4. **Verify file uploads work**
+5. **Test end-to-end functionality**
+
+---
+**Ready for deployment!** 🚀

app.py

@@ -597,5 +597,5 @@ async def get_version():
 
 if __name__ == "__main__":
     uvicorn.run(
-        "app_supabase:app", host="127.0.0.1", port=8000, reload=True, log_level="info"
+        "app:app", host="127.0.0.1", port=8000, reload=True, log_level="info"
     )

app_sqlite_backup.py

@@ -1,1614 +0,0 @@
-"""
-Enhanced Tree Mapping FastAPI Application
-Implements security, robustness, performance, and best practices improvements
-"""
-
-
-import json
-import logging
-import re
-import shutil
-import sqlite3
-import time
-from contextlib import contextmanager
-from datetime import datetime
-from pathlib import Path
-from typing import Any, Optional
-
-import uvicorn
-from fastapi import FastAPI, HTTPException, Request, status, File, UploadFile, Form
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.middleware.trustedhost import TrustedHostMiddleware
-from fastapi.responses import HTMLResponse, JSONResponse, FileResponse
-from fastapi.staticfiles import StaticFiles
-from pydantic import BaseModel, Field, field_validator, model_validator
-import uuid
-import aiofiles
-import os
-
-from config import get_settings
-from master_tree_database import create_master_tree_database, get_tree_suggestions, get_all_tree_codes
-# Simple file-based persistence - no git/tokens needed
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-    handlers=[logging.FileHandler("app.log"), logging.StreamHandler()],
-)
-logger = logging.getLogger(__name__)
-
-# Log build info to help with cache debugging
-
-build_time = os.environ.get('BUILD_TIME', 'unknown')
-logger.info(f"TreeTrack starting - Build time: {build_time}")
-
-
-# Import configuration
-
-
-# Get configuration settings
-settings = get_settings()
-
-# Initialize FastAPI app with security headers
-app = FastAPI(
-    title="Tree Mapping API",
-    description="Secure API for mapping and tracking trees",
-    version="2.0.0",
-    docs_url="/docs",
-    redoc_url="/redoc",
-)
-
-# CORS middleware - Essential for frontend-backend communication
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=settings.security.cors_origins,
-    allow_credentials=True,
-    allow_methods=["GET", "POST", "PUT", "DELETE"],
-    allow_headers=["*"],
-)
-
-# TrustedHost middleware - Enable for production deployment
-# app.add_middleware(TrustedHostMiddleware, allowed_hosts=settings.security.allowed_hosts)
-
-
-# Security headers middleware - TEMPORARILY DISABLED FOR DEBUGGING
-# @app.middleware("http")
-# async def add_security_headers(request: Request, call_next):
-#     start_time = time.time()
-
-#     try:
-#         response = await call_next(request)
-
-#         # Add security headers
-#         response.headers["X-Content-Type-Options"] = "nosniff"
-#         response.headers["X-Frame-Options"] = "DENY"
-#         response.headers["X-XSS-Protection"] = "1; mode=block"
-#         response.headers["Strict-Transport-Security"] = (
-#             "max-age=31536000; includeSubDomains"
-#         )
-#         response.headers["Content-Security-Policy"] = (
-#             "default-src 'self'; script-src 'self' 'unsafe-inline' https://unpkg.com https://cdn.plot.ly; style-src 'self' 'unsafe-inline' https://unpkg.com; img-src 'self' data: https:; connect-src 'self'
-#         )
-
-#         # Log request
-#         process_time = time.time() - start_time
-#         logger.info(
-#             f"{request.method} {request.url.path} - {response.status_code} - {process_time:.3f}s"
-#         )
-
-#         return response
-#     except Exception as e:
-#         logger.error(f"Request failed: {request.method} {request.url.path} - {e!s}")
-#         raise
-
-
-# Serve static files
-app.mount("/static", StaticFiles(directory="static"), name="static")
-
-# Add cache-busting middleware for development
-@app.middleware("http")
-async def add_cache_headers(request: Request, call_next):
-    response = await call_next(request)
-    
-    # Add cache-control headers for static files to prevent caching issues
-    if request.url.path.startswith("/static/"):
-        response.headers["Cache-Control"] = "no-cache, no-store, must-revalidate"
-        response.headers["Pragma"] = "no-cache"
-        response.headers["Expires"] = "0"
-    
-    return response
-
-
-# Database setup with proper error handling
-def ensure_data_directory():
-    """Ensure data and upload directories exist with proper permissions"""
-    # For HF Spaces, try to use persistent storage, fall back to local
-    base_dirs = ["data"]
-    
-    # Check if we can access persistent storage
-    persistent_available = False
-    try:
-        persistent_test = Path("/tmp/hf_space_test")
-        persistent_test.mkdir(exist_ok=True)
-        persistent_test.rmdir()
-        # If we can write to /tmp, we might have persistent storage
-        logger.info("Persistent storage might be available")
-        persistent_available = True
-    except Exception:
-        logger.info("Using local storage only")
-    
-    # Create local directories
-    directories = ["data", "uploads", "uploads/images", "uploads/audio"]
-    
-    for dir_name in directories:
-        dir_path = Path(dir_name)
-        try:
-            dir_path.mkdir(exist_ok=True, parents=True)
-            # Don't set restrictive permissions in HF Spaces
-            logger.info(f"Directory {dir_name} initialized")
-        except Exception as e:
-            logger.error(f"Failed to create {dir_name} directory: {e}")
-            raise
-
-
-@contextmanager
-def get_db_connection():
-    """Context manager for database connections with proper error handling"""
-    conn = None
-    try:
-        conn = sqlite3.connect(
-            settings.database.db_path,
-            timeout=settings.server.request_timeout,
-            check_same_thread=False,
-        )
-        conn.row_factory = sqlite3.Row
-        # Enable foreign key constraints
-        conn.execute("PRAGMA foreign_keys = ON")
-        
-        # Optimize for concurrent writes (perfect for 2 users)
-        conn.execute("PRAGMA journal_mode = WAL")
-        conn.execute("PRAGMA synchronous = NORMAL")  # Good balance of safety/speed
-        conn.execute("PRAGMA cache_size = 10000")     # 10MB cache for better performance
-        conn.execute("PRAGMA temp_store = MEMORY")    # Use memory for temp tables
-        conn.execute("PRAGMA wal_autocheckpoint = 1000")  # Prevent WAL from growing too large
-        yield conn
-    except sqlite3.Error as e:
-        logger.error(f"Database error: {e}")
-        if conn:
-            conn.rollback()
-        raise
-    except Exception as e:
-        logger.error(f"Unexpected database error: {e}")
-        if conn:
-            conn.rollback()
-        raise
-    finally:
-        if conn:
-            conn.close()
-
-
-def init_db():
-    """Initialize database with enhanced schema and constraints"""
-    ensure_data_directory()
-
-    try:
-        with get_db_connection() as conn:
-            cursor = conn.cursor()
-
-            # Create enhanced trees table with all 12 fields
-            cursor.execute("""
-                CREATE TABLE IF NOT EXISTS trees (
-                    id INTEGER PRIMARY KEY AUTOINCREMENT,
-                    -- 1. Geolocation
-                    latitude REAL NOT NULL CHECK (latitude >= -90 AND latitude <= 90),
-                    longitude REAL NOT NULL CHECK (longitude >= -180 AND longitude <= 180),
-                    
-                    -- 2. Local Name (Assamese)
-                    local_name TEXT CHECK (local_name IS NULL OR length(local_name) <= 200),
-                    
-                    -- 3. Scientific Name
-                    scientific_name TEXT CHECK (scientific_name IS NULL OR length(scientific_name) <= 200),
-                    
-                    -- 4. Common Name
-                    common_name TEXT CHECK (common_name IS NULL OR length(common_name) <= 200),
-                    
-                    -- 5. Tree Code
-                    tree_code TEXT CHECK (tree_code IS NULL OR length(tree_code) <= 20),
-                    
-                    -- 6. Height (in meters)
-                    height REAL CHECK (height IS NULL OR (height > 0 AND height <= 200)),
-                    
-                    -- 7. Width/Girth (in cm)
-                    width REAL CHECK (width IS NULL OR (width > 0 AND width <= 2000)),
-                    
-                    -- 8. Utility (JSON array of selected utilities)
-                    utility TEXT, -- JSON array: ["Religious", "Timber", "Biodiversity", etc.]
-                    
-                    -- 9. Storytelling
-                    storytelling_text TEXT CHECK (storytelling_text IS NULL OR length(storytelling_text) <= 5000),
-                    storytelling_audio TEXT, -- File path to audio recording
-                    
-                    -- 10. Phenology Tracker (JSON array of current stages)
-                    phenology_stages TEXT, -- JSON array: ["New leaves", "Open flowers", etc.]
-                    
-                    -- 11. Photographs (JSON object with categories and file paths)
-                    photographs TEXT, -- JSON: {"leaf": "path1.jpg", "bark": "path2.jpg", etc.}
-                    
-                    -- 12. Notes
-                    notes TEXT CHECK (notes IS NULL OR length(notes) <= 2000),
-                    
-                    -- System fields
-                    timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
-                    created_by TEXT DEFAULT 'system',
-                    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
-                )
-            """)
-
-            # Create indexes for better performance
-            cursor.execute(
-                "CREATE INDEX IF NOT EXISTS idx_trees_location ON trees(latitude, longitude)"
-            )
-            cursor.execute(
-                "CREATE INDEX IF NOT EXISTS idx_trees_scientific_name ON trees(scientific_name)"
-            )
-            cursor.execute(
-                "CREATE INDEX IF NOT EXISTS idx_trees_local_name ON trees(local_name)"
-            )
-            cursor.execute(
-                "CREATE INDEX IF NOT EXISTS idx_trees_tree_code ON trees(tree_code)"
-            )
-            cursor.execute(
-                "CREATE INDEX IF NOT EXISTS idx_trees_timestamp ON trees(timestamp)"
-            )
-
-            # Create trigger to update updated_at timestamp
-            cursor.execute("""
-                CREATE TRIGGER IF NOT EXISTS update_trees_timestamp
-                AFTER UPDATE ON trees
-                BEGIN
-                    UPDATE trees SET updated_at = CURRENT_TIMESTAMP WHERE id = NEW.id;
-                END
-            """)
-
-            conn.commit()
-            logger.info("Database initialized successfully")
-
-    except Exception as e:
-        logger.error(f"Failed to initialize database: {e}")
-        raise
-
-
-import json
-from typing import List, Dict
-
-# Enhanced Pydantic models for comprehensive tree tracking
-class Tree(BaseModel):
-    """Complete tree model with all 12 fields"""
-    id: int
-    # 1. Geolocation
-    latitude: float
-    longitude: float
-    # 2. Local Name (Assamese)
-    local_name: Optional[str] = None
-    # 3. Scientific Name
-    scientific_name: Optional[str] = None
-    # 4. Common Name
-    common_name: Optional[str] = None
-    # 5. Tree Code
-    tree_code: Optional[str] = None
-    # 6. Height (meters)
-    height: Optional[float] = None
-    # 7. Width/Girth (cm)
-    width: Optional[float] = None
-    # 8. Utility (JSON array)
-    utility: Optional[List[str]] = None
-    # 9. Storytelling
-    storytelling_text: Optional[str] = None
-    storytelling_audio: Optional[str] = None
-    # 10. Phenology Tracker (JSON array)
-    phenology_stages: Optional[List[str]] = None
-    # 11. Photographs (JSON object)
-    photographs: Optional[Dict[str, str]] = None
-    # 12. Notes
-    notes: Optional[str] = None
-    # System fields
-    timestamp: str
-    created_by: str = "system"
-    updated_at: Optional[str] = None
-
-
-class TreeCreate(BaseModel):
-    """Model for creating new tree records"""
-    # 1. Geolocation (Required)
-    latitude: float = Field(..., ge=-90, le=90, description="Latitude in decimal degrees")
-    longitude: float = Field(..., ge=-180, le=180, description="Longitude in decimal degrees")
-    # 2. Local Name (Assamese)
-    local_name: Optional[str] = Field(None, max_length=200, description="Local Assamese name")
-    # 3. Scientific Name
-    scientific_name: Optional[str] = Field(None, max_length=200, description="Scientific name (genus species)")
-    # 4. Common Name
-    common_name: Optional[str] = Field(None, max_length=200, description="Common or colloquial name")
-    # 5. Tree Code
-    tree_code: Optional[str] = Field(None, max_length=20, description="Tree reference code (e.g. C.A, A-G1)")
-    # 6. Height
-    height: Optional[float] = Field(None, gt=0, le=200, description="Height in meters")
-    # 7. Width/Girth
-    width: Optional[float] = Field(None, gt=0, le=2000, description="Width/girth in centimeters")
-    # 8. Utility
-    utility: Optional[List[str]] = Field(None, description="Ecological/cultural utilities")
-    # 9. Storytelling
-    storytelling_text: Optional[str] = Field(None, max_length=5000, description="Stories, histories, narratives")
-    storytelling_audio: Optional[str] = Field(None, description="Audio recording file path")
-    # 10. Phenology Tracker
-    phenology_stages: Optional[List[str]] = Field(None, description="Current development stages")
-    # 11. Photographs
-    photographs: Optional[Dict[str, str]] = Field(None, description="Photo categories and file paths")
-    # 12. Notes
-    notes: Optional[str] = Field(None, max_length=2000, description="Additional observations")
-
-    @field_validator("utility", mode='before')
-    @classmethod
-    def validate_utility(cls, v):
-        # Handle JSON string input
-        if isinstance(v, str):
-            try:
-                v = json.loads(v)
-            except json.JSONDecodeError:
-                raise ValueError(f"Invalid JSON string for utility: {v}")
-        
-        if v is not None:
-            valid_utilities = [
-                "Religious", "Timber", "Biodiversity", "Hydrological benefit", 
-                "Faunal interaction", "Food", "Medicine", "Shelter", "Cultural"
-            ]
-            for item in v:
-                if item not in valid_utilities:
-                    raise ValueError(f"Invalid utility: {item}. Must be one of: {valid_utilities}")
-        return v
-
-    @field_validator("phenology_stages", mode='before')
-    @classmethod
-    def validate_phenology(cls, v):
-        # Handle JSON string input
-        if isinstance(v, str):
-            try:
-                v = json.loads(v)
-            except json.JSONDecodeError:
-                raise ValueError(f"Invalid JSON string for phenology_stages: {v}")
-        
-        if v is not None:
-            valid_stages = [
-                "New leaves", "Old leaves", "Open flowers", "Fruiting", 
-                "Ripe fruit", "Recent fruit drop", "Other"
-            ]
-            for stage in v:
-                if stage not in valid_stages:
-                    raise ValueError(f"Invalid phenology stage: {stage}. Must be one of: {valid_stages}")
-        return v
-
-    @field_validator("photographs", mode='before')
-    @classmethod
-    def validate_photographs(cls, v):
-        # Handle JSON string input
-        if isinstance(v, str):
-            try:
-                v = json.loads(v)
-            except json.JSONDecodeError:
-                raise ValueError(f"Invalid JSON string for photographs: {v}")
-        
-        if v is not None:
-            valid_categories = ["Leaf", "Bark", "Fruit", "Seed", "Flower", "Full tree"]
-            for category in v.keys():
-                if category not in valid_categories:
-                    raise ValueError(f"Invalid photo category: {category}. Must be one of: {valid_categories}")
-        return v
-
-
-class TreeUpdate(BaseModel):
-    """Model for updating tree records"""
-    latitude: Optional[float] = Field(None, ge=-90, le=90)
-    longitude: Optional[float] = Field(None, ge=-180, le=180)
-    local_name: Optional[str] = Field(None, max_length=200)
-    scientific_name: Optional[str] = Field(None, max_length=200)
-    common_name: Optional[str] = Field(None, max_length=200)
-    tree_code: Optional[str] = Field(None, max_length=20)
-    height: Optional[float] = Field(None, gt=0, le=200)
-    width: Optional[float] = Field(None, gt=0, le=2000)
-    utility: Optional[List[str]] = None
-    storytelling_text: Optional[str] = Field(None, max_length=5000)
-    storytelling_audio: Optional[str] = None
-    phenology_stages: Optional[List[str]] = None
-    photographs: Optional[Dict[str, str]] = None
-    notes: Optional[str] = Field(None, max_length=2000)
-
-
-class StatsResponse(BaseModel):
-    total_trees: int
-    species_distribution: list[dict[str, Any]]
-    health_distribution: list[dict[str, Any]]
-    average_height: float
-    average_diameter: float
-    last_updated: str
-
-
-# Initialize database on startup and restore if needed
-def initialize_app():
-    """Initialize application with database restoration for persistent storage"""
-    try:
-        # HF Spaces provides /data as a persistent volume that survives container restarts
-        persistent_db_path = Path("/data/trees.db")
-        local_db_path = Path("data/trees.db")
-        
-        # Ensure local directory exists
-        local_db_path.parent.mkdir(parents=True, exist_ok=True)
-        
-        # Try to ensure persistent directory exists (may fail on some systems)
-        try:
-            persistent_db_path.parent.mkdir(parents=True, exist_ok=True)
-            logger.info("Persistent storage directory available at /data")
-        except (PermissionError, OSError) as e:
-            logger.warning(f"Cannot create /data directory: {e}. Using local backup strategy.")
-            # Fallback to local backup strategy only
-            persistent_db_path = None
-        
-        # Check if we have a persistent database in /data (if available)
-        if persistent_db_path and persistent_db_path.exists():
-            logger.info("Found persistent database, copying to local directory...")
-            shutil.copy2(persistent_db_path, local_db_path)
-            with sqlite3.connect(local_db_path) as conn:
-                cursor = conn.cursor()
-                cursor.execute("SELECT COUNT(*) FROM trees")
-                tree_count = cursor.fetchone()[0]
-                logger.info(f"Database restored from persistent storage: {tree_count} trees")
-        else:
-            # Check for backup files in multiple locations
-            backup_locations = [
-                Path("trees_database.db"),  # Root level backup
-                Path("static/trees_database.db"),  # Static backup
-            ]
-            
-            backup_restored = False
-            for backup_path in backup_locations:
-                if backup_path.exists():
-                    logger.info(f"Found backup at {backup_path}, restoring...")
-                    shutil.copy2(backup_path, local_db_path)
-                    # Try to save to persistent storage if available
-                    if persistent_db_path:
-                        try:
-                            shutil.copy2(backup_path, persistent_db_path)
-                        except (PermissionError, OSError):
-                            logger.warning("Cannot write to persistent storage")
-                    backup_restored = True
-                    break
-            
-            if backup_restored:
-                with sqlite3.connect(local_db_path) as conn:
-                    cursor = conn.cursor()
-                    cursor.execute("SELECT COUNT(*) FROM trees")
-                    tree_count = cursor.fetchone()[0]
-                    logger.info(f"Database restored from backup: {tree_count} trees")
-        
-        # Initialize database (creates tables if they don't exist)
-        init_db()
-        
-        # Initial backup to persistent storage (if available)
-        if persistent_db_path:
-            _backup_to_persistent_storage()
-        else:
-            logger.info("Using local backup strategy only (no persistent storage)")
-        
-        # Log current status
-        if local_db_path.exists():
-            with get_db_connection() as conn:
-                cursor = conn.cursor()
-                cursor.execute("SELECT COUNT(*) FROM trees")
-                tree_count = cursor.fetchone()[0]
-                logger.info(f"TreeTrack initialized with {tree_count} trees")
-        
-    except Exception as e:
-        logger.error(f"Application initialization failed: {e}")
-        # Still try to initialize database with empty state
-        init_db()
-
-# Initialize app with restoration capabilities
-initialize_app()
-
-def _backup_to_persistent_storage():
-    """Backup database to HF Spaces persistent /data volume"""
-    try:
-        source_db = Path("data/trees.db")
-        persistent_db = Path("/data/trees.db")
-        
-        if source_db.exists():
-            # Try to ensure /data directory exists
-            try:
-                persistent_db.parent.mkdir(parents=True, exist_ok=True)
-                shutil.copy2(source_db, persistent_db)
-                logger.info(f"Database backed up to persistent storage: {persistent_db}")
-                return True
-            except (PermissionError, OSError) as e:
-                logger.warning(f"Cannot backup to persistent storage: {e}")
-                return False
-    except Exception as e:
-        logger.error(f"Persistent storage backup failed: {e}")
-    return False
-
-def backup_database():
-    """Backup database to accessible locations (HF Spaces compatible)"""
-    try:
-        source_db = Path("data/trees.db")
-        if not source_db.exists():
-            logger.warning("Source database does not exist")
-            return False
-            
-        # 1. MOST IMPORTANT: Backup to persistent storage (/data)
-        _backup_to_persistent_storage()
-        
-        # 2. Copy database to static directory for direct HTTP access
-        static_db = Path("static/trees_database.db")
-        shutil.copy2(source_db, static_db)
-        
-        # 3. Also copy to root level (in case git access works)
-        root_db = Path("trees_database.db")
-        shutil.copy2(source_db, root_db)
-        
-        # 4. Export to CSV in multiple locations
-        static_csv = Path("static/trees_backup.csv")
-        root_csv = Path("trees_backup.csv")
-        _export_trees_to_csv(static_csv)
-        _export_trees_to_csv(root_csv)
-        
-        # 5. Create comprehensive status files
-        static_status = Path("static/database_status.txt")
-        root_status = Path("database_status.txt")
-        tree_count = _create_status_file(static_status, source_db)
-        _create_status_file(root_status, source_db)
-        
-        # 6. Try git commit (may fail in HF Spaces but that's okay)
-        if _is_docker_environment():
-            git_success = _git_commit_backup([root_db, root_csv, root_status], tree_count)
-            if git_success:
-                logger.info(f"Database backed up to all locations including persistent storage: {tree_count} trees")
-            else:
-                logger.info(f"Database backed up to static files and persistent storage: {tree_count} trees")
-        else:
-            logger.info(f"Database backed up locally: {tree_count} trees")
-            
-        return True
-        
-    except Exception as e:
-        logger.error(f"Database backup failed: {e}")
-        return False
-
-
-def _export_trees_to_csv(csv_path: Path):
-    """Export all trees to CSV format"""
-    try:
-        with get_db_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute("""
-                SELECT id, latitude, longitude, local_name, scientific_name, 
-                       common_name, tree_code, height, width, utility, 
-                       storytelling_text, storytelling_audio, phenology_stages, 
-                       photographs, notes, timestamp, created_by, updated_at
-                FROM trees ORDER BY id
-            """)
-            trees = cursor.fetchall()
-            
-        import csv
-        with open(csv_path, 'w', newline='', encoding='utf-8') as csvfile:
-            writer = csv.writer(csvfile)
-            # Header
-            writer.writerow([
-                'id', 'latitude', 'longitude', 'local_name', 'scientific_name',
-                'common_name', 'tree_code', 'height', 'width', 'utility',
-                'storytelling_text', 'storytelling_audio', 'phenology_stages',
-                'photographs', 'notes', 'timestamp', 'created_by', 'updated_at'
-            ])
-            # Data
-            writer.writerows(trees)
-            
-        logger.info(f"CSV backup created: {csv_path}")
-    except Exception as e:
-        logger.error(f"CSV export failed: {e}")
-
-
-def _create_status_file(status_file: Path, source_db: Path) -> int:
-    """Create database status file and return tree count"""
-    try:
-        with get_db_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute("SELECT COUNT(*) FROM trees")
-            tree_count = cursor.fetchone()[0]
-            
-            cursor.execute("SELECT COUNT(DISTINCT scientific_name) FROM trees WHERE scientific_name IS NOT NULL")
-            unique_species = cursor.fetchone()[0]
-            
-            cursor.execute("SELECT MAX(timestamp) FROM trees")
-            last_update = cursor.fetchone()[0] or "Never"
-        
-        with open(status_file, 'w', encoding='utf-8') as f:
-            f.write("=== TreeTrack Database Status ===\n")
-            f.write(f"Last Backup: {datetime.now().strftime('%Y-%m-%d %H:%M:%S UTC')}\n")
-            f.write(f"Environment: {'Docker/HF Spaces' if _is_docker_environment() else 'Development'}\n")
-            f.write(f"Database File: trees_database.db\n")
-            f.write(f"CSV Export: trees_backup.csv\n")
-            f.write(f"Database Size: {source_db.stat().st_size:,} bytes\n")
-            f.write(f"Total Trees: {tree_count:,}\n")
-            f.write(f"Unique Species: {unique_species}\n")
-            f.write(f"Last Tree Added: {last_update}\n")
-            f.write(f"\n=== Usage ===\n")
-            f.write(f"• Download 'trees_database.db' for SQLite access\n")
-            f.write(f"• View 'trees_backup.csv' for spreadsheet format\n")
-            f.write(f"• Auto-backup occurs after each tree operation\n")
-            f.write(f"• Data persists across Docker container restarts\n")
-            
-        return tree_count
-    except Exception as e:
-        logger.error(f"Status file creation failed: {e}")
-        return 0
-
-
-def _is_docker_environment() -> bool:
-    """Check if running in Docker environment (HF Spaces)"""
-    return (
-        os.path.exists('/.dockerenv') or
-        os.getenv('SPACE_ID') is not None or
-        '/app' in os.getcwd()
-    )
-
-
-def _git_commit_file(file_path: Path, message: str) -> bool:
-    """Commit a single file to git repository"""
-    try:
-        import subprocess
-        
-        # Setup git config if needed
-        try:
-            subprocess.run(['git', 'config', 'user.name', 'TreeTrack Bot'], 
-                         check=True, capture_output=True, text=True)
-            subprocess.run(['git', 'config', 'user.email', '[email protected]'], 
-                         check=True, capture_output=True, text=True)
-        except:
-            pass  # Git config might already be set
-        
-        # Add file to git
-        if file_path.exists():
-            subprocess.run(['git', 'add', str(file_path)], check=True)
-        
-        # Check if there are changes to commit
-        result = subprocess.run(['git', 'diff', '--staged', '--quiet'], 
-                              capture_output=True)
-        
-        if result.returncode == 0:  # No changes
-            return True
-        
-        # Commit changes
-        subprocess.run(['git', 'commit', '-m', message], 
-                      check=True, capture_output=True, text=True)
-        
-        logger.info(f"File committed to git: {file_path}")
-        return True
-        
-    except subprocess.CalledProcessError as e:
-        logger.error(f"Git commit failed: {e.stderr if hasattr(e, 'stderr') else str(e)}")
-        return False
-    except Exception as e:
-        logger.error(f"Git backup failed: {e}")
-        return False
-
-
-def _git_commit_backup(files: list, tree_count: int) -> bool:
-    """Commit backup files to git repository using Docker-native approach"""
-    try:
-        import subprocess
-        
-        # Setup git config if needed
-        try:
-            subprocess.run(['git', 'config', 'user.name', 'TreeTrack Bot'], 
-                         check=True, capture_output=True, text=True)
-            subprocess.run(['git', 'config', 'user.email', '[email protected]'], 
-                         check=True, capture_output=True, text=True)
-        except:
-            pass  # Git config might already be set
-        
-        # Add backup files to git
-        for file_path in files:
-            if file_path.exists():
-                subprocess.run(['git', 'add', str(file_path)], check=True)
-        
-        # Check if there are changes to commit
-        result = subprocess.run(['git', 'diff', '--staged', '--quiet'], 
-                              capture_output=True)
-        
-        if result.returncode == 0:  # No changes
-            logger.info("No database changes to commit")
-            return True
-        
-        # Create commit message with tree count and timestamp
-        timestamp = datetime.now().strftime('%Y-%m-%d %H:%M UTC')
-        commit_message = f"TreeTrack Auto-backup: {tree_count:,} trees - {timestamp}"
-        
-        # Commit changes
-        subprocess.run(['git', 'commit', '-m', commit_message], 
-                      check=True, capture_output=True, text=True)
-        
-        logger.info(f"Database backup committed to git: {tree_count} trees")
-        
-        # Note: HF Spaces automatically syncs commits to the repository
-        # No need to explicitly push
-        
-        return True
-        
-    except subprocess.CalledProcessError as e:
-        logger.error(f"Git commit failed: {e.stderr if hasattr(e, 'stderr') else str(e)}")
-        return False
-    except Exception as e:
-        logger.error(f"Git backup failed: {e}")
-        return False
-
-
-# Health check endpoint
-@app.get("/health", tags=["Health"])
-async def health_check():
-    """Health check endpoint"""
-    try:
-        with get_db_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute("SELECT 1")
-            cursor.fetchone()
-
-        return {
-            "status": "healthy",
-            "timestamp": datetime.now().isoformat(),
-            "version": "2.0.0",
-        }
-    except Exception as e:
-        logger.error(f"Health check failed: {e}")
-        raise
-
-
-# API Routes with enhanced error handling
-@app.get("/", response_class=HTMLResponse, tags=["Frontend"])
-async def read_root():
-    """Serve the main application page"""
-    try:
-        with open("static/index.html", encoding="utf-8") as f:
-            content = f.read()
-        return HTMLResponse(content=content)
-    except FileNotFoundError:
-        logger.error("index.html not found")
-        raise
-    except Exception as e:
-        logger.error(f"Error serving frontend: {e}")
-        raise
-
-
-@app.get("/map", response_class=HTMLResponse, tags=["Frontend"])
-@app.get("/static/map.html", response_class=HTMLResponse, tags=["Frontend"])
-async def serve_map():
-    """Serve the map page directly through FastAPI to bypass static caching"""
-    try:
-        with open("static/map.html", encoding="utf-8") as f:
-            content = f.read()
-        # Force no-cache headers
-        response = HTMLResponse(content=content)
-        response.headers["Cache-Control"] = "no-cache, no-store, must-revalidate"
-        response.headers["Pragma"] = "no-cache"
-        response.headers["Expires"] = "0"
-        return response
-    except FileNotFoundError:
-        logger.error("map.html not found")
-        raise HTTPException(status_code=404, detail="Map page not found")
-    except Exception as e:
-        logger.error(f"Error serving map page: {e}")
-        raise
-
-
-@app.get("/debug/file-content", tags=["Debug"])
-async def debug_file_content():
-    """Debug endpoint to show actual file contents"""
-    try:
-        with open("static/map.html", encoding="utf-8") as f:
-            content = f.read()
-        
-        # Extract key indicators
-        has_fire_emoji = "" in content
-        has_v4 = "V4.0" in content
-        has_blue_theme = "#3b82f6" in content
-        has_red_border = "#ff0000" in content
-        
-        return {
-            "file_exists": True,
-            "content_length": len(content),
-            "indicators": {
-                "has_fire_emoji": has_fire_emoji,
-                "has_v4_version": has_v4,
-                "has_blue_theme": has_blue_theme,
-                "has_red_debug_border": has_red_border
-            },
-            "first_200_chars": content[:200],
-            "title_line": next((line.strip() for line in content.split('\n') if '<title>' in line), "not found")
-        }
-    except Exception as e:
-        return {
-            "file_exists": False,
-            "error": str(e)
-        }
-
-
-@app.get("/api/trees", response_model=list[Tree], tags=["Trees"])
-async def get_trees(
-    limit: int = 100,
-    offset: int = 0,
-    species: str = None,
-    health_status: str = None,
-):
-    # Add validation inside the function
-    if limit < 1 or limit > settings.server.max_trees_per_request:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=f"Limit must be between 1 and {settings.server.max_trees_per_request}",
-        )
-    if offset < 0:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail="Offset must be non-negative",
-        )
-    try:
-        with get_db_connection() as conn:
-            cursor = conn.cursor()
-
-            # Build query with optional filters
-            query = "SELECT * FROM trees WHERE 1=1"
-            params = []
-
-            if species:
-                query += " AND species LIKE ?"
-                params.append(f"%{species}%")
-
-            if health_status:
-                query += " AND health_status = ?"
-                params.append(health_status)
-
-            query += " ORDER BY timestamp DESC LIMIT ? OFFSET ?"
-            params.extend([limit, offset])
-
-            cursor.execute(query, params)
-            rows = cursor.fetchall()
-            
-            # Parse JSON fields for each tree
-            trees = []
-            for row in rows:
-                tree_data = dict(row)
-                
-                # Parse JSON fields back to Python objects
-                if tree_data.get('utility'):
-                    try:
-                        tree_data['utility'] = json.loads(tree_data['utility'])
-                    except (json.JSONDecodeError, TypeError):
-                        tree_data['utility'] = None
-                        
-                if tree_data.get('phenology_stages'):
-                    try:
-                        tree_data['phenology_stages'] = json.loads(tree_data['phenology_stages'])
-                    except (json.JSONDecodeError, TypeError):
-                        tree_data['phenology_stages'] = None
-                        
-                if tree_data.get('photographs'):
-                    try:
-                        tree_data['photographs'] = json.loads(tree_data['photographs'])
-                    except (json.JSONDecodeError, TypeError):
-                        tree_data['photographs'] = None
-                        
-                trees.append(tree_data)
-
-            logger.info(f"Retrieved {len(trees)} trees")
-            return trees
-
-    except Exception as e:
-        logger.error(f"Error retrieving trees: {e}")
-        raise
-
-
-@app.post(
-    "/api/trees",
-    response_model=Tree,
-    status_code=status.HTTP_201_CREATED,
-    tags=["Trees"],
-)
-async def create_tree(tree: TreeCreate):
-    """Create a new tree record with all 12 fields"""
-    try:
-        with get_db_connection() as conn:
-            cursor = conn.cursor()
-
-            # Convert lists and dicts to JSON strings for database storage
-            utility_json = json.dumps(tree.utility) if tree.utility else None
-            phenology_json = json.dumps(tree.phenology_stages) if tree.phenology_stages else None
-            photographs_json = json.dumps(tree.photographs) if tree.photographs else None
-
-            cursor.execute(
-                """
-                INSERT INTO trees (
-                    latitude, longitude, local_name, scientific_name, common_name,
-                    tree_code, height, width, utility, storytelling_text,
-                    storytelling_audio, phenology_stages, photographs, notes
-                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-            """,
-                (
-                    tree.latitude,
-                    tree.longitude,
-                    tree.local_name,
-                    tree.scientific_name,
-                    tree.common_name,
-                    tree.tree_code,
-                    tree.height,
-                    tree.width,
-                    utility_json,
-                    tree.storytelling_text,
-                    tree.storytelling_audio,
-                    phenology_json,
-                    photographs_json,
-                    tree.notes,
-                ),
-            )
-
-            tree_id = cursor.lastrowid
-            conn.commit()
-            
-            # Return the created tree with parsed JSON fields
-            cursor.execute("SELECT * FROM trees WHERE id = ?", (tree_id,))
-            row = cursor.fetchone()
-            if not row:
-                raise HTTPException(
-                    status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-                    detail="Failed to retrieve created tree",
-                )
-
-            # Parse JSON fields back to Python objects
-            tree_data = dict(row)
-            if tree_data.get('utility'):
-                tree_data['utility'] = json.loads(tree_data['utility'])
-            if tree_data.get('phenology_stages'):
-                tree_data['phenology_stages'] = json.loads(tree_data['phenology_stages'])
-            if tree_data.get('photographs'):
-                tree_data['photographs'] = json.loads(tree_data['photographs'])
-
-            logger.info(f"Created tree with ID: {tree_id}")
-            
-            # Backup database to visible location
-            backup_database()
-            
-            return tree_data
-
-    except sqlite3.IntegrityError as e:
-        logger.error(f"Database integrity error: {e}")
-        raise
-    except Exception as e:
-        logger.error(f"Error creating tree: {e}")
-        raise
-
-
-@app.get("/api/trees/{tree_id}", response_model=Tree, tags=["Trees"])
-async def get_tree(tree_id: int):
-    """Get a specific tree by ID"""
-    try:
-        with get_db_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute("SELECT * FROM trees WHERE id = ?", (tree_id,))
-            tree = cursor.fetchone()
-
-            if tree is None:
-                raise HTTPException(
-                    status_code=status.HTTP_404_NOT_FOUND,
-                    detail=f"Tree with ID {tree_id} not found",
-                )
-
-            # Parse JSON fields back to Python objects
-            tree_data = dict(tree)
-            if tree_data.get('utility'):
-                try:
-                    tree_data['utility'] = json.loads(tree_data['utility'])
-                except (json.JSONDecodeError, TypeError):
-                    tree_data['utility'] = None
-                    
-            if tree_data.get('phenology_stages'):
-                try:
-                    tree_data['phenology_stages'] = json.loads(tree_data['phenology_stages'])
-                except (json.JSONDecodeError, TypeError):
-                    tree_data['phenology_stages'] = None
-                    
-            if tree_data.get('photographs'):
-                try:
-                    tree_data['photographs'] = json.loads(tree_data['photographs'])
-                except (json.JSONDecodeError, TypeError):
-                    tree_data['photographs'] = None
-
-            return tree_data
-
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"Error retrieving tree {tree_id}: {e}")
-        raise
-
-
-@app.put("/api/trees/{tree_id}", response_model=Tree, tags=["Trees"])
-async def update_tree(tree_id: int, tree_update: TreeUpdate = None):
-    """Update a tree record"""
-    if not tree_update:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST, detail="No update data provided"
-        )
-
-    try:
-        with get_db_connection() as conn:
-            cursor = conn.cursor()
-
-            # Check if tree exists
-            cursor.execute("SELECT id FROM trees WHERE id = ?", (tree_id,))
-            if not cursor.fetchone():
-                raise HTTPException(
-                    status_code=status.HTTP_404_NOT_FOUND,
-                    detail=f"Tree with ID {tree_id} not found",
-                )
-
-            # Build update query dynamically
-            update_fields = []
-            params = []
-
-            for field, value in tree_update.model_dump(exclude_unset=True).items():
-                if value is not None:
-                    update_fields.append(f"{field} = ?")
-                    params.append(value)
-
-            if not update_fields:
-                raise HTTPException(
-                    status_code=status.HTTP_400_BAD_REQUEST,
-                    detail="No valid fields to update",
-                )
-
-            params.append(tree_id)
-            query = f"UPDATE trees SET {', '.join(update_fields)} WHERE id = ?"
-
-            cursor.execute(query, params)
-            conn.commit()
-
-            # Return updated tree
-            cursor.execute("SELECT * FROM trees WHERE id = ?", (tree_id,))
-            updated_tree = cursor.fetchone()
-
-            logger.info(f"Updated tree with ID: {tree_id}")
-            
-            # Backup database to visible location
-            backup_database()
-            
-            return dict(updated_tree)
-
-    except HTTPException:
-        raise
-    except sqlite3.IntegrityError as e:
-        logger.error(f"Database integrity error updating tree {tree_id}: {e}")
-        raise
-    except Exception as e:
-        logger.error(f"Error updating tree {tree_id}: {e}")
-        raise
-
-
-@app.delete("/api/trees/{tree_id}", tags=["Trees"])
-async def delete_tree(tree_id: int):
-    """Delete a tree record"""
-    try:
-        with get_db_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute("DELETE FROM trees WHERE id = ?", (tree_id,))
-
-            if cursor.rowcount == 0:
-                raise HTTPException(
-                    status_code=status.HTTP_404_NOT_FOUND,
-                    detail=f"Tree with ID {tree_id} not found",
-                )
-
-            conn.commit()
-            logger.info(f"Deleted tree with ID: {tree_id}")
-            
-            # Backup database to visible location
-            backup_database()
-
-            return {"message": f"Tree {tree_id} deleted successfully"}
-
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"Error deleting tree {tree_id}: {e}")
-        raise
-
-
-# File Upload Endpoints with persistent storage
-@app.post("/api/upload/image", tags=["Files"])
-async def upload_image(
-    file: UploadFile = File(...),
-    category: str = Form(...)
-):
-    """Upload an image file for tree documentation with git-based persistence"""
-    # Validate file type
-    if not file.content_type or not file.content_type.startswith('image/'):
-        raise HTTPException(
-            status_code=400,
-            detail="File must be an image"
-        )
-    
-    # Validate category
-    valid_categories = ["Leaf", "Bark", "Fruit", "Seed", "Flower", "Full tree"]
-    if category not in valid_categories:
-        raise HTTPException(
-            status_code=400,
-            detail=f"Category must be one of: {valid_categories}"
-        )
-    
-    try:
-        # Generate unique filename
-        file_id = str(uuid.uuid4())
-        file_extension = Path(file.filename).suffix.lower()
-        filename = f"{file_id}{file_extension}"
-        
-        # Save to local uploads directory
-        local_file_path = Path("uploads/images") / filename
-        
-        # Also save to static directory for persistence via git
-        static_file_path = Path("static/uploads/images")
-        static_file_path.mkdir(parents=True, exist_ok=True)
-        persistent_file_path = static_file_path / filename
-        
-        # Read file content once
-        content = await file.read()
-        
-        # Save to both locations
-        async with aiofiles.open(local_file_path, 'wb') as f:
-            await f.write(content)
-        async with aiofiles.open(persistent_file_path, 'wb') as f:
-            await f.write(content)
-        
-        # Commit to git for persistence across container restarts
-        if _is_docker_environment():
-            _git_commit_file(persistent_file_path, f"Add image: {filename} ({category})")
-        
-        logger.info(f"Image uploaded and persisted: {filename}, category: {category}")
-        
-        return {
-            "filename": filename,
-            "file_path": str(local_file_path),
-            "persistent_path": str(persistent_file_path),
-            "category": category,
-            "size": len(content),
-            "content_type": file.content_type
-        }
-        
-    except Exception as e:
-        logger.error(f"Error uploading image: {e}")
-        raise HTTPException(status_code=500, detail="Failed to upload image")
-
-
-@app.post("/api/upload/audio", tags=["Files"])
-async def upload_audio(file: UploadFile = File(...)):
-    """Upload an audio file for storytelling"""
-    # Validate file type
-    if not file.content_type or not file.content_type.startswith('audio/'):
-        raise HTTPException(
-            status_code=400,
-            detail="File must be an audio file"
-        )
-    
-    try:
-        # Generate unique filename
-        file_id = str(uuid.uuid4())
-        file_extension = Path(file.filename).suffix.lower()
-        filename = f"{file_id}{file_extension}"
-        file_path = Path("uploads/audio") / filename
-        
-        # Save file
-        async with aiofiles.open(file_path, 'wb') as f:
-            content = await file.read()
-            await f.write(content)
-        
-        logger.info(f"Audio uploaded: {filename}")
-        
-        return {
-            "filename": filename,
-            "file_path": str(file_path),
-            "size": len(content),
-            "content_type": file.content_type
-        }
-        
-    except Exception as e:
-        logger.error(f"Error uploading audio: {e}")
-        raise HTTPException(status_code=500, detail="Failed to upload audio")
-
-
-@app.get("/api/files/{file_type}/{filename}", tags=["Files"])
-async def get_file(file_type: str, filename: str):
-    """Serve uploaded files"""
-    if file_type not in ["images", "audio"]:
-        raise HTTPException(status_code=400, detail="Invalid file type")
-    
-    file_path = Path(f"uploads/{file_type}/{filename}")
-    
-    if not file_path.exists():
-        raise HTTPException(status_code=404, detail="File not found")
-    
-    return FileResponse(file_path)
-
-
-# Utility endpoints for form data
-@app.get("/api/utilities", tags=["Data"])
-async def get_utilities():
-    """Get list of valid utility options"""
-    return {
-        "utilities": [
-            "Religious", "Timber", "Biodiversity", "Hydrological benefit", 
-            "Faunal interaction", "Food", "Medicine", "Shelter", "Cultural"
-        ]
-    }
-
-
-@app.get("/api/phenology-stages", tags=["Data"])
-async def get_phenology_stages():
-    """Get list of valid phenology stages"""
-    return {
-        "stages": [
-            "New leaves", "Old leaves", "Open flowers", "Fruiting", 
-            "Ripe fruit", "Recent fruit drop", "Other"
-        ]
-    }
-
-
-@app.get("/api/photo-categories", tags=["Data"])
-async def get_photo_categories():
-    """Get list of valid photo categories"""
-    return {
-        "categories": ["Leaf", "Bark", "Fruit", "Seed", "Flower", "Full tree"]
-    }
-
-
-# Auto-suggestion endpoints for master tree database
-@app.get("/api/tree-suggestions", tags=["Data"])
-async def get_tree_suggestions_api(query: str = "", limit: int = 10):
-    """Get auto-suggestions for tree names from master database"""
-    if not query or len(query.strip()) == 0:
-        return {"suggestions": []}
-    
-    try:
-        # Initialize master database if it doesn't exist
-        create_master_tree_database()
-        
-        suggestions = get_tree_suggestions(query.strip(), limit)
-        
-        return {
-            "query": query,
-            "suggestions": suggestions,
-            "count": len(suggestions)
-        }
-        
-    except Exception as e:
-        logger.error(f"Error getting tree suggestions: {e}")
-        return {"suggestions": [], "error": str(e)}
-
-
-@app.get("/api/tree-codes", tags=["Data"])
-async def get_tree_codes_api():
-    """Get all available tree codes from master database"""
-    try:
-        # Initialize master database if it doesn't exist
-        create_master_tree_database()
-        
-        tree_codes = get_all_tree_codes()
-        
-        return {
-            "tree_codes": tree_codes,
-            "count": len(tree_codes)
-        }
-        
-    except Exception as e:
-        logger.error(f"Error getting tree codes: {e}")
-        return {"tree_codes": [], "error": str(e)}
-
-
-@app.get("/api/master-database/status", tags=["System"])
-async def get_master_database_status():
-    """Get status of master tree species database"""
-    try:
-        master_db_path = Path("data/master_trees.db")
-        
-        if not master_db_path.exists():
-            return {
-                "exists": False,
-                "initialized": False,
-                "species_count": 0,
-                "message": "Master database not initialized"
-            }
-        
-        # Check database content
-        import sqlite3
-        conn = sqlite3.connect(master_db_path)
-        cursor = conn.cursor()
-        
-        cursor.execute("SELECT COUNT(*) FROM master_species")
-        species_count = cursor.fetchone()[0]
-        
-        cursor.execute("SELECT COUNT(DISTINCT tree_code) FROM master_species WHERE tree_code != ''")
-        unique_codes = cursor.fetchone()[0]
-        
-        conn.close()
-        
-        return {
-            "exists": True,
-            "initialized": True,
-            "species_count": species_count,
-            "unique_codes": unique_codes,
-            "database_size": master_db_path.stat().st_size,
-            "message": f"Master database contains {species_count} species with {unique_codes} unique codes"
-        }
-        
-    except Exception as e:
-        logger.error(f"Error checking master database status: {e}")
-        return {
-            "exists": False,
-            "initialized": False,
-            "error": str(e)
-        }
-
-
-# Direct file download endpoints
-@app.get("/download/database", tags=["Downloads"])
-async def download_database():
-    """Download the SQLite database file"""
-    db_file = Path("static/trees_database.db")
-    if not db_file.exists():
-        # Try root location
-        db_file = Path("trees_database.db")
-        if not db_file.exists():
-            raise HTTPException(status_code=404, detail="Database file not found")
-    
-    return FileResponse(
-        path=str(db_file),
-        filename="trees_database.db",
-        media_type="application/x-sqlite3"
-    )
-
-@app.get("/download/csv", tags=["Downloads"])
-async def download_csv():
-    """Download the CSV backup file"""
-    csv_file = Path("static/trees_backup.csv")
-    if not csv_file.exists():
-        # Try root location
-        csv_file = Path("trees_backup.csv")
-        if not csv_file.exists():
-            raise HTTPException(status_code=404, detail="CSV file not found")
-    
-    return FileResponse(
-        path=str(csv_file),
-        filename="trees_backup.csv",
-        media_type="text/csv"
-    )
-
-@app.get("/download/status", tags=["Downloads"])
-async def download_status():
-    """Download the status report file"""
-    status_file = Path("static/database_status.txt")
-    if not status_file.exists():
-        # Try root location
-        status_file = Path("database_status.txt")
-        if not status_file.exists():
-            raise HTTPException(status_code=404, detail="Status file not found")
-    
-    return FileResponse(
-        path=str(status_file),
-        filename="database_status.txt",
-        media_type="text/plain"
-    )
-
-@app.get("/api/persistence/status", tags=["System"])
-async def get_persistence_status():
-    """Get database backup system status"""
-    try:
-        # Check if database exists
-        db_path = Path("data/trees.db")
-        backup_path = Path("trees_database.db")
-        
-        if not db_path.exists():
-            return {
-                "enabled": False,
-                "status": "no_database",
-                "message": "No database found yet"
-            }
-        
-        # Get database info
-        with get_db_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute("SELECT COUNT(*) FROM trees")
-            tree_count = cursor.fetchone()[0]
-        
-        return {
-            "enabled": True,
-            "status": "healthy",
-            "stats": {
-                "database_size": db_path.stat().st_size,
-                "total_trees": tree_count,
-                "backup_exists": backup_path.exists(),
-                "last_backup": backup_path.stat().st_mtime if backup_path.exists() else None
-            },
-            "message": f"Database backup system active - {tree_count} trees stored"
-        }
-    except Exception as e:
-        return {
-            "enabled": False,
-            "status": "error",
-            "message": f"Backup system error: {str(e)}"
-        }
-
-
-@app.post("/api/persistence/backup", tags=["System"])
-async def force_backup():
-    """Force an immediate database backup"""
-    success = backup_database()
-    
-    return {
-        "success": success,
-        "message": "Database backed up successfully" if success else "Backup failed",
-        "timestamp": datetime.now().isoformat()
-    }
-
-
-@app.get("/api/stats", response_model=StatsResponse, tags=["Statistics"])
-async def get_stats():
-    """Get comprehensive tree statistics"""
-    try:
-        with get_db_connection() as conn:
-            cursor = conn.cursor()
-
-            # Total trees
-            cursor.execute("SELECT COUNT(*) as total FROM trees")
-            total = cursor.fetchone()[0]
-
-            # Trees by species (limit to top 20)
-            cursor.execute("""
-                SELECT species, COUNT(*) as count
-                FROM trees
-                GROUP BY species
-                ORDER BY count DESC
-                LIMIT 20
-            """)
-            species_stats = [
-                {"species": row[0], "count": row[1]} for row in cursor.fetchall()
-            ]
-
-            # Trees by health status
-            cursor.execute("""
-                SELECT health_status, COUNT(*) as count
-                FROM trees
-                GROUP BY health_status
-                ORDER BY count DESC
-            """)
-            health_stats = [
-                {"status": row[0], "count": row[1]} for row in cursor.fetchall()
-            ]
-
-            # Average measurements
-            cursor.execute("""
-                SELECT
-                    COALESCE(AVG(height), 0) as avg_height,
-                    COALESCE(AVG(diameter), 0) as avg_diameter
-                FROM trees
-                WHERE height IS NOT NULL AND diameter IS NOT NULL
-            """)
-            avg_stats = cursor.fetchone()
-
-            return StatsResponse(
-                total_trees=total,
-                species_distribution=species_stats,
-                health_distribution=health_stats,
-                average_height=round(avg_stats[0], 2) if avg_stats[0] else 0,
-                average_diameter=round(avg_stats[1], 2) if avg_stats[1] else 0,
-                last_updated=datetime.now().isoformat(),
-            )
-
-    except Exception as e:
-        logger.error(f"Error retrieving statistics: {e}")
-        raise
-
-
-# Version management endpoints
-@app.get("/api/version", tags=["System"])
-async def get_version():
-    """Get current application version and asset versions"""
-    try:
-        version_file = Path("version.json")
-        if version_file.exists():
-            async with aiofiles.open(version_file, 'r') as f:
-                content = await f.read()
-                version_data = json.loads(content)
-        else:
-            # Fallback version data
-            version_data = {
-                "version": "3.0",
-                "timestamp": int(time.time()),
-                "build": "development",
-                "commit": "local"
-            }
-        
-        version_data["server_time"] = datetime.now().isoformat()
-        return version_data
-        
-    except Exception as e:
-        logger.error(f"Error reading version: {e}")
-        return {
-            "version": "unknown",
-            "timestamp": int(time.time()),
-            "build": "error",
-            "error": str(e)
-        }
-
-
-@app.post("/api/version/update", tags=["System"])
-async def update_version():
-    """Force update version and clear cache"""
-    try:
-        # Update version timestamp
-        timestamp = int(time.time())
-        version_number = f"3.{timestamp}"
-        
-        version_data = {
-            "version": version_number,
-            "timestamp": timestamp,
-            "build": "development",
-            "commit": "local",
-            "updated_by": "api"
-        }
-        
-        # Write version file
-        version_file = Path("version.json")
-        async with aiofiles.open(version_file, 'w') as f:
-            await f.write(json.dumps(version_data, indent=4))
-            
-        logger.info(f"Version updated to {version_number}")
-        
-        return {
-            "success": True,
-            "message": "Version updated successfully",
-            "new_version": version_number,
-            "timestamp": timestamp,
-            "instructions": [
-                "Clear browser cache: Ctrl+Shift+R (Windows) / Cmd+Shift+R (Mac)",
-                "Or open DevTools > Application > Service Workers > Unregister"
-            ]
-        }
-        
-    except Exception as e:
-        logger.error(f"Error updating version: {e}")
-        return {
-            "success": False,
-            "error": str(e)
-        }
-
-
-# Error handlers for better error responses
-@app.exception_handler(404)
-async def not_found_handler(request: Request, exc: Exception):
-    return JSONResponse(
-        status_code=404,
-        content={"detail": "Resource not found", "path": str(request.url.path)},
-    )
-
-
-@app.exception_handler(500)
-async def internal_error_handler(request: Request, exc: Exception):
-    logger.error(f"Internal server error: {exc}")
-    return JSONResponse(status_code=500, content={"detail": "Internal server error"})
-
-
-if __name__ == "__main__":
-    uvicorn.run(
-        "app:app", host="127.0.0.1", port=8000, reload=True, log_level="info"
-    )

app_supabase.py

@@ -1,601 +0,0 @@
-"""
-TreeTrack FastAPI Application - Supabase Edition
-Clean implementation using Supabase Postgres + Storage
-"""
-
-import json
-import logging
-import time
-from datetime import datetime
-from typing import Any, Optional, List, Dict
-
-import uvicorn
-from fastapi import FastAPI, HTTPException, Request, status, File, UploadFile, Form
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import HTMLResponse, JSONResponse, RedirectResponse
-from fastapi.staticfiles import StaticFiles
-from pydantic import BaseModel, Field, field_validator
-import uuid
-import os
-
-# Import our Supabase components
-from supabase_database import SupabaseDatabase
-from supabase_storage import SupabaseFileStorage
-from config import get_settings
-from master_tree_database import create_master_tree_database, get_tree_suggestions, get_all_tree_codes
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-    handlers=[logging.FileHandler("app.log"), logging.StreamHandler()],
-)
-logger = logging.getLogger(__name__)
-
-# Log startup
-build_time = os.environ.get('BUILD_TIME', 'unknown')
-logger.info(f"TreeTrack Supabase Edition starting - Build time: {build_time}")
-
-# Get configuration settings
-settings = get_settings()
-
-# Initialize FastAPI app
-app = FastAPI(
-    title="TreeTrack - Supabase Edition",
-    description="Tree mapping and tracking with persistent cloud storage",
-    version="3.0.0",
-    docs_url="/docs",
-    redoc_url="/redoc",
-)
-
-# CORS middleware
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=settings.security.cors_origins,
-    allow_credentials=True,
-    allow_methods=["GET", "POST", "PUT", "DELETE"],
-    allow_headers=["*"],
-)
-
-# Serve static files
-app.mount("/static", StaticFiles(directory="static"), name="static")
-
-# Initialize Supabase components
-db = SupabaseDatabase()
-storage = SupabaseFileStorage()
-
-# Pydantic models (same as before)
-class Tree(BaseModel):
-    """Complete tree model with all 12 fields"""
-    id: int
-    latitude: float
-    longitude: float
-    local_name: Optional[str] = None
-    scientific_name: Optional[str] = None
-    common_name: Optional[str] = None
-    tree_code: Optional[str] = None
-    height: Optional[float] = None
-    width: Optional[float] = None
-    utility: Optional[List[str]] = None
-    storytelling_text: Optional[str] = None
-    storytelling_audio: Optional[str] = None
-    phenology_stages: Optional[List[str]] = None
-    photographs: Optional[Dict[str, str]] = None
-    notes: Optional[str] = None
-    created_at: str
-    updated_at: Optional[str] = None
-    created_by: str = "system"
-
-
-class TreeCreate(BaseModel):
-    """Model for creating new tree records"""
-    latitude: float = Field(..., ge=-90, le=90, description="Latitude in decimal degrees")
-    longitude: float = Field(..., ge=-180, le=180, description="Longitude in decimal degrees")
-    local_name: Optional[str] = Field(None, max_length=200, description="Local Assamese name")
-    scientific_name: Optional[str] = Field(None, max_length=200, description="Scientific name")
-    common_name: Optional[str] = Field(None, max_length=200, description="Common name")
-    tree_code: Optional[str] = Field(None, max_length=20, description="Tree reference code")
-    height: Optional[float] = Field(None, gt=0, le=200, description="Height in meters")
-    width: Optional[float] = Field(None, gt=0, le=2000, description="Width/girth in centimeters")
-    utility: Optional[List[str]] = Field(None, description="Ecological/cultural utilities")
-    storytelling_text: Optional[str] = Field(None, max_length=5000, description="Stories and narratives")
-    storytelling_audio: Optional[str] = Field(None, description="Audio file path")
-    phenology_stages: Optional[List[str]] = Field(None, description="Current development stages")
-    photographs: Optional[Dict[str, str]] = Field(None, description="Photo categories and paths")
-    notes: Optional[str] = Field(None, max_length=2000, description="Additional observations")
-
-    @field_validator("utility", mode='before')
-    @classmethod
-    def validate_utility(cls, v):
-        if isinstance(v, str):
-            try:
-                v = json.loads(v)
-            except json.JSONDecodeError:
-                raise ValueError(f"Invalid JSON string for utility: {v}")
-        
-        if v is not None:
-            valid_utilities = [
-                "Religious", "Timber", "Biodiversity", "Hydrological benefit", 
-                "Faunal interaction", "Food", "Medicine", "Shelter", "Cultural"
-            ]
-            for item in v:
-                if item not in valid_utilities:
-                    raise ValueError(f"Invalid utility: {item}")
-        return v
-
-    @field_validator("phenology_stages", mode='before')
-    @classmethod
-    def validate_phenology(cls, v):
-        if isinstance(v, str):
-            try:
-                v = json.loads(v)
-            except json.JSONDecodeError:
-                raise ValueError(f"Invalid JSON string for phenology_stages: {v}")
-        
-        if v is not None:
-            valid_stages = [
-                "New leaves", "Old leaves", "Open flowers", "Fruiting", 
-                "Ripe fruit", "Recent fruit drop", "Other"
-            ]
-            for stage in v:
-                if stage not in valid_stages:
-                    raise ValueError(f"Invalid phenology stage: {stage}")
-        return v
-
-    @field_validator("photographs", mode='before')
-    @classmethod
-    def validate_photographs(cls, v):
-        if isinstance(v, str):
-            try:
-                v = json.loads(v)
-            except json.JSONDecodeError:
-                raise ValueError(f"Invalid JSON string for photographs: {v}")
-        
-        if v is not None:
-            valid_categories = ["Leaf", "Bark", "Fruit", "Seed", "Flower", "Full tree"]
-            for category in v.keys():
-                if category not in valid_categories:
-                    raise ValueError(f"Invalid photo category: {category}")
-        return v
-
-
-class TreeUpdate(BaseModel):
-    """Model for updating tree records"""
-    latitude: Optional[float] = Field(None, ge=-90, le=90)
-    longitude: Optional[float] = Field(None, ge=-180, le=180)
-    local_name: Optional[str] = Field(None, max_length=200)
-    scientific_name: Optional[str] = Field(None, max_length=200)
-    common_name: Optional[str] = Field(None, max_length=200)
-    tree_code: Optional[str] = Field(None, max_length=20)
-    height: Optional[float] = Field(None, gt=0, le=200)
-    width: Optional[float] = Field(None, gt=0, le=2000)
-    utility: Optional[List[str]] = None
-    storytelling_text: Optional[str] = Field(None, max_length=5000)
-    storytelling_audio: Optional[str] = None
-    phenology_stages: Optional[List[str]] = None
-    photographs: Optional[Dict[str, str]] = None
-    notes: Optional[str] = Field(None, max_length=2000)
-
-
-# Application startup
-@app.on_event("startup")
-async def startup_event():
-    """Initialize application"""
-    try:
-        # Test Supabase connection
-        if not db.test_connection():
-            logger.error("Failed to connect to Supabase database")
-            raise Exception("Database connection failed")
-        
-        # Initialize database schema
-        db.initialize_database()
-        
-        # Initialize master tree database
-        create_master_tree_database()
-        
-        # Log success
-        tree_count = db.get_tree_count()
-        logger.info(f"TreeTrack Supabase Edition initialized - {tree_count} trees in database")
-        
-    except Exception as e:
-        logger.error(f"Application startup failed: {e}")
-        raise
-
-
-# Health check
-@app.get("/health", tags=["Health"])
-async def health_check():
-    """Health check endpoint"""
-    try:
-        connection_ok = db.test_connection()
-        tree_count = db.get_tree_count() if connection_ok else 0
-        
-        return {
-            "status": "healthy" if connection_ok else "unhealthy",
-            "database": "connected" if connection_ok else "disconnected",
-            "trees": tree_count,
-            "timestamp": datetime.now().isoformat(),
-            "version": "3.0.0",
-        }
-    except Exception as e:
-        logger.error(f"Health check failed: {e}")
-        return {
-            "status": "unhealthy",
-            "error": str(e),
-            "timestamp": datetime.now().isoformat(),
-        }
-
-
-# Frontend routes
-@app.get("/", response_class=HTMLResponse, tags=["Frontend"])
-async def read_root():
-    """Serve the main application page"""
-    try:
-        with open("static/index.html", encoding="utf-8") as f:
-            content = f.read()
-        return HTMLResponse(content=content)
-    except FileNotFoundError:
-        logger.error("index.html not found")
-        raise HTTPException(status_code=404, detail="Frontend not found")
-
-
-@app.get("/map", response_class=HTMLResponse, tags=["Frontend"])
-async def serve_map():
-    """Serve the map page"""
-    return RedirectResponse(url="/static/map.html")
-
-
-# Tree CRUD Operations
-@app.get("/api/trees", response_model=List[Tree], tags=["Trees"])
-async def get_trees(
-    limit: int = 100,
-    offset: int = 0,
-    species: str = None,
-    health_status: str = None,
-):
-    """Get trees with pagination and filters"""
-    if limit < 1 or limit > settings.server.max_trees_per_request:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=f"Limit must be between 1 and {settings.server.max_trees_per_request}",
-        )
-    if offset < 0:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail="Offset must be non-negative",
-        )
-    
-    try:
-        trees = db.get_trees(limit=limit, offset=offset, species=species, health_status=health_status)
-        
-        # Add signed URLs for files
-        processed_trees = []
-        for tree in trees:
-            processed_tree = storage.process_tree_files(tree)
-            processed_trees.append(processed_tree)
-        
-        return processed_trees
-        
-    except Exception as e:
-        logger.error(f"Error retrieving trees: {e}")
-        raise HTTPException(status_code=500, detail="Failed to retrieve trees")
-
-
-@app.post("/api/trees", response_model=Tree, status_code=status.HTTP_201_CREATED, tags=["Trees"])
-async def create_tree(tree: TreeCreate):
-    """Create a new tree record"""
-    try:
-        # Convert to dict for database insertion
-        tree_data = tree.model_dump(exclude_unset=True)
-        
-        # Create tree in database
-        created_tree = db.create_tree(tree_data)
-        
-        # Process files and return with URLs
-        processed_tree = storage.process_tree_files(created_tree)
-        
-        logger.info(f"Created tree with ID: {created_tree.get('id')}")
-        return processed_tree
-        
-    except Exception as e:
-        logger.error(f"Error creating tree: {e}")
-        raise HTTPException(status_code=500, detail="Failed to create tree")
-
-
-@app.get("/api/trees/{tree_id}", response_model=Tree, tags=["Trees"])
-async def get_tree(tree_id: int):
-    """Get a specific tree by ID"""
-    try:
-        tree = db.get_tree(tree_id)
-        
-        if tree is None:
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND,
-                detail=f"Tree with ID {tree_id} not found",
-            )
-        
-        # Process files and return with URLs
-        processed_tree = storage.process_tree_files(tree)
-        return processed_tree
-        
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"Error retrieving tree {tree_id}: {e}")
-        raise HTTPException(status_code=500, detail="Failed to retrieve tree")
-
-
-@app.put("/api/trees/{tree_id}", response_model=Tree, tags=["Trees"])
-async def update_tree(tree_id: int, tree_update: TreeUpdate):
-    """Update a tree record"""
-    try:
-        # Convert to dict for database update
-        update_data = tree_update.model_dump(exclude_unset=True)
-        
-        if not update_data:
-            raise HTTPException(
-                status_code=status.HTTP_400_BAD_REQUEST,
-                detail="No update data provided",
-            )
-        
-        # Update tree in database
-        updated_tree = db.update_tree(tree_id, update_data)
-        
-        # Process files and return with URLs
-        processed_tree = storage.process_tree_files(updated_tree)
-        
-        logger.info(f"Updated tree with ID: {tree_id}")
-        return processed_tree
-        
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"Error updating tree {tree_id}: {e}")
-        raise HTTPException(status_code=500, detail="Failed to update tree")
-
-
-@app.delete("/api/trees/{tree_id}", tags=["Trees"])
-async def delete_tree(tree_id: int):
-    """Delete a tree record"""
-    try:
-        # Get tree data first to clean up files
-        tree = db.get_tree(tree_id)
-        
-        if tree is None:
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND,
-                detail=f"Tree with ID {tree_id} not found",
-            )
-        
-        # Delete tree from database
-        db.delete_tree(tree_id)
-        
-        # Clean up associated files
-        try:
-            if tree.get('photographs'):
-                for file_path in tree['photographs'].values():
-                    if file_path:
-                        storage.delete_image(file_path)
-            
-            if tree.get('storytelling_audio'):
-                storage.delete_audio(tree['storytelling_audio'])
-        except Exception as e:
-            logger.warning(f"Failed to clean up files for tree {tree_id}: {e}")
-        
-        logger.info(f"Deleted tree with ID: {tree_id}")
-        return {"message": f"Tree {tree_id} deleted successfully"}
-        
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"Error deleting tree {tree_id}: {e}")
-        raise HTTPException(status_code=500, detail="Failed to delete tree")
-
-
-# File Upload Endpoints
-@app.post("/api/upload/image", tags=["Files"])
-async def upload_image(
-    file: UploadFile = File(...),
-    category: str = Form(...)
-):
-    """Upload an image file with cloud persistence"""
-    # Validate file type
-    if not file.content_type or not file.content_type.startswith('image/'):
-        raise HTTPException(status_code=400, detail="File must be an image")
-    
-    # Validate category
-    valid_categories = ["Leaf", "Bark", "Fruit", "Seed", "Flower", "Full tree"]
-    if category not in valid_categories:
-        raise HTTPException(
-            status_code=400,
-            detail=f"Category must be one of: {valid_categories}"
-        )
-    
-    try:
-        # Read file content
-        content = await file.read()
-        
-        # Upload to Supabase Storage
-        result = storage.upload_image(content, file.filename, category)
-        
-        logger.info(f"Image uploaded successfully: {result['filename']}")
-        
-        return {
-            "filename": result['filename'],
-            "category": category,
-            "size": result['size'],
-            "content_type": file.content_type,
-            "bucket": result['bucket'],
-            "success": True
-        }
-        
-    except Exception as e:
-        logger.error(f"Error uploading image: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.post("/api/upload/audio", tags=["Files"])
-async def upload_audio(file: UploadFile = File(...)):
-    """Upload an audio file with cloud persistence"""
-    # Validate file type
-    if not file.content_type or not file.content_type.startswith('audio/'):
-        raise HTTPException(status_code=400, detail="File must be an audio file")
-    
-    try:
-        # Read file content
-        content = await file.read()
-        
-        # Upload to Supabase Storage
-        result = storage.upload_audio(content, file.filename)
-        
-        logger.info(f"Audio uploaded successfully: {result['filename']}")
-        
-        return {
-            "filename": result['filename'],
-            "size": result['size'],
-            "content_type": file.content_type,
-            "bucket": result['bucket'],
-            "success": True
-        }
-        
-    except Exception as e:
-        logger.error(f"Error uploading audio: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-# File serving - generate signed URLs on demand
-@app.get("/api/files/image/{file_path:path}", tags=["Files"])
-async def get_image(file_path: str):
-    """Get signed URL for image file"""
-    try:
-        signed_url = storage.get_image_url(file_path, expires_in=3600)  # 1 hour
-        return RedirectResponse(url=signed_url)
-    except Exception as e:
-        logger.error(f"Error getting image URL: {e}")
-        raise HTTPException(status_code=404, detail="Image not found")
-
-
-@app.get("/api/files/audio/{file_path:path}", tags=["Files"])
-async def get_audio(file_path: str):
-    """Get signed URL for audio file"""
-    try:
-        signed_url = storage.get_audio_url(file_path, expires_in=3600)  # 1 hour
-        return RedirectResponse(url=signed_url)
-    except Exception as e:
-        logger.error(f"Error getting audio URL: {e}")
-        raise HTTPException(status_code=404, detail="Audio not found")
-
-
-# Utility endpoints
-@app.get("/api/utilities", tags=["Data"])
-async def get_utilities():
-    """Get list of valid utility options"""
-    return {
-        "utilities": [
-            "Religious", "Timber", "Biodiversity", "Hydrological benefit", 
-            "Faunal interaction", "Food", "Medicine", "Shelter", "Cultural"
-        ]
-    }
-
-
-@app.get("/api/phenology-stages", tags=["Data"])
-async def get_phenology_stages():
-    """Get list of valid phenology stages"""
-    return {
-        "stages": [
-            "New leaves", "Old leaves", "Open flowers", "Fruiting", 
-            "Ripe fruit", "Recent fruit drop", "Other"
-        ]
-    }
-
-
-@app.get("/api/photo-categories", tags=["Data"])
-async def get_photo_categories():
-    """Get list of valid photo categories"""
-    return {
-        "categories": ["Leaf", "Bark", "Fruit", "Seed", "Flower", "Full tree"]
-    }
-
-
-# Statistics
-@app.get("/api/stats", tags=["Statistics"])
-async def get_stats():
-    """Get comprehensive tree statistics"""
-    try:
-        total_trees = db.get_tree_count()
-        species_distribution = db.get_species_distribution(limit=20)
-        health_distribution = db.get_health_distribution()  # Will be empty for now
-        measurements = db.get_average_measurements()
-        
-        return {
-            "total_trees": total_trees,
-            "species_distribution": species_distribution,
-            "health_distribution": health_distribution,
-            "average_height": measurements["average_height"],
-            "average_diameter": measurements["average_diameter"],
-            "last_updated": datetime.now().isoformat(),
-        }
-        
-    except Exception as e:
-        logger.error(f"Error retrieving statistics: {e}")
-        raise HTTPException(status_code=500, detail="Failed to retrieve statistics")
-
-
-# Master tree database suggestions
-@app.get("/api/tree-suggestions", tags=["Data"])
-async def get_tree_suggestions_api(query: str = "", limit: int = 10):
-    """Get auto-suggestions for tree names from master database"""
-    if not query or len(query.strip()) == 0:
-        return {"suggestions": []}
-    
-    try:
-        create_master_tree_database()
-        suggestions = get_tree_suggestions(query.strip(), limit)
-        
-        return {
-            "query": query,
-            "suggestions": suggestions,
-            "count": len(suggestions)
-        }
-        
-    except Exception as e:
-        logger.error(f"Error getting tree suggestions: {e}")
-        return {"suggestions": [], "error": str(e)}
-
-
-@app.get("/api/tree-codes", tags=["Data"])
-async def get_tree_codes_api():
-    """Get all available tree codes from master database"""
-    try:
-        create_master_tree_database()
-        tree_codes = get_all_tree_codes()
-        
-        return {
-            "tree_codes": tree_codes,
-            "count": len(tree_codes)
-        }
-        
-    except Exception as e:
-        logger.error(f"Error getting tree codes: {e}")
-        return {"tree_codes": [], "error": str(e)}
-
-
-# Version info
-@app.get("/api/version", tags=["System"])
-async def get_version():
-    """Get current application version"""
-    return {
-        "version": "3.0.0",
-        "backend": "supabase",
-        "database": "postgres",
-        "storage": "supabase-storage",
-        "timestamp": int(time.time()),
-        "build": build_time,
-        "server_time": datetime.now().isoformat()
-    }
-
-
-if __name__ == "__main__":
-    uvicorn.run(
-        "app_supabase:app", host="127.0.0.1", port=8000, reload=True, log_level="info"
-    )

config.py

@@ -1,204 +1,108 @@
 """
-Configuration management for Tree Mapping Application
-Implements environment-based configuration with validation and security best practices
+Configuration management for TreeTrack - Supabase Edition
+Environment-based configuration for cloud deployment
 """
 
-
 import os
 from functools import lru_cache
 from pathlib import Path
+from typing import List
 
-from pydantic import Field, field_validator, model_validator
+from pydantic import Field, field_validator
 from pydantic_settings import BaseSettings
 
 
-class DatabaseConfig(BaseSettings):
-    """Database configuration settings"""
-
-    # Database settings
-    db_path: str = Field(default="data/trees.db", env="DB_PATH")
-    db_timeout: int = Field(default=30, env="DB_TIMEOUT", ge=1, le=300)
-    db_max_connections: int = Field(default=10, env="DB_MAX_CONNECTIONS", ge=1, le=100)
-    db_backup_enabled: bool = Field(default=True, env="DB_BACKUP_ENABLED")
-    db_backup_interval: int = Field(
-        default=3600, env="DB_BACKUP_INTERVAL", ge=300
-    )  # seconds
-
-    @field_validator("db_path")
-    def validate_db_path(cls, v):
-        """Ensure database path is secure"""
-        path = Path(v)
-
-        # Prevent path traversal attacks
-        if ".." in str(path) or str(path).startswith("/"):
-            raise ValueError("Database path contains invalid characters")
-
-        # Ensure parent directory exists
-        path.parent.mkdir(parents=True, exist_ok=True)
-
-        return str(path)
-
-
 class SecurityConfig(BaseSettings):
     """Security configuration settings"""
-
-    # Security settings
-    secret_key: str = Field(
-        default="dev-secret-key-change-in-production", env="SECRET_KEY"
-    )
-    allowed_hosts: list[str] = Field(
-        default=["localhost", "127.0.0.1"], env="ALLOWED_HOSTS"
-    )
-    cors_origins: list[str] = Field(
-        default=["http://localhost:8000", "http://127.0.0.1:8000"], env="CORS_ORIGINS"
+    
+    # CORS settings for web deployment
+    cors_origins: List[str] = Field(
+        default=["*"], env="CORS_ORIGINS"  # Allow all origins for HuggingFace Spaces
     )
+    
+    # Request limits
     max_request_size: int = Field(
-        default=1048576, env="MAX_REQUEST_SIZE", ge=1024
-    )  # 1MB default
-    rate_limit_requests: int = Field(default=100, env="RATE_LIMIT_REQUESTS", ge=1)
-    rate_limit_window: int = Field(default=60, env="RATE_LIMIT_WINDOW", ge=1)  # seconds
-
-    # Content Security Policy
-    csp_default_src: str = Field(default="'self'", env="CSP_DEFAULT_SRC")
-    csp_script_src: str = Field(
-        default="'self' 'unsafe-inline' https://unpkg.com https://cdn.plot.ly",
-        env="CSP_SCRIPT_SRC",
-    )
-    csp_style_src: str = Field(
-        default="'self' 'unsafe-inline' https://unpkg.com", env="CSP_STYLE_SRC"
-    )
-    csp_img_src: str = Field(default="'self' data: https:", env="CSP_IMG_SRC")
-    csp_connect_src: str = Field(default="'self'", env="CSP_CONNECT_SRC")
-
-    @field_validator("secret_key")
-    def validate_secret_key(cls, v):
-        """Ensure secret key is secure in production"""
-        if v == "dev-secret-key-change-in-production":
-            env = os.getenv("ENVIRONMENT", "development")
-            if env.lower() in ["production", "prod"]:
-                raise ValueError("Must set a secure SECRET_KEY in production")
-
-        if len(v) < 32:
-            raise ValueError("Secret key must be at least 32 characters long")
-
-        return v
-
-    @field_validator("allowed_hosts")
-    def validate_allowed_hosts(cls, v):
-        """Validate allowed hosts format"""
-        for host in v:
-            if not host or ".." in host:
-                raise ValueError(f"Invalid host: {host}")
+        default=10485760, env="MAX_REQUEST_SIZE", ge=1024
+    )  # 10MB default for file uploads
+    
+    @field_validator("cors_origins")
+    def validate_cors_origins(cls, v):
+        """Validate CORS origins"""
+        if isinstance(v, str):
+            # Handle comma-separated string
+            return [origin.strip() for origin in v.split(",") if origin.strip()]
         return v
 
 
 class ServerConfig(BaseSettings):
     """Server configuration settings"""
-
-    # Server settings
-    host: str = Field(default="127.0.0.1", env="HOST")
-    port: int = Field(default=8000, env="PORT", ge=1, le=65535)
-    workers: int = Field(default=1, env="WORKERS", ge=1, le=8)
+    
+    # Server settings - optimized for HuggingFace Spaces
+    host: str = Field(default="0.0.0.0", env="HOST")
+    port: int = Field(default=7860, env="PORT", ge=1, le=65535)  # HF Spaces default
+    workers: int = Field(default=1, env="WORKERS", ge=1, le=4)
     reload: bool = Field(default=False, env="RELOAD")
     debug: bool = Field(default=False, env="DEBUG")
-
+    
     # Request handling
     request_timeout: int = Field(default=30, env="REQUEST_TIMEOUT", ge=1, le=300)
     max_trees_per_request: int = Field(
         default=1000, env="MAX_TREES_PER_REQUEST", ge=1, le=10000
     )
 
-    @field_validator("host")
-    def validate_host(cls, v):
-        """Validate host format"""
-        if not v or v.count(".") > 3:
-            raise ValueError("Invalid host format")
-        return v
 
-
-class LoggingConfig(BaseSettings):
-    """Logging configuration settings"""
-
-    # Logging settings
-    log_level: str = Field(default="INFO", env="LOG_LEVEL")
-    log_file: str = Field(default="logs/app.log", env="LOG_FILE")
-    log_max_size: int = Field(
-        default=10485760, env="LOG_MAX_SIZE", ge=1024
-    )  # 10MB default
-    log_backup_count: int = Field(default=5, env="LOG_BACKUP_COUNT", ge=1, le=20)
-    log_format: str = Field(
-        default="%(asctime)s - %(name)s - %(levelname)s - %(message)s", env="LOG_FORMAT"
-    )
-
-    # Access logging
-    access_log_enabled: bool = Field(default=True, env="ACCESS_LOG_ENABLED")
-    access_log_file: str = Field(default="logs/access.log", env="ACCESS_LOG_FILE")
-
-    @field_validator("log_level")
-    def validate_log_level(cls, v):
-        """Validate log level"""
-        valid_levels = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
-        if v.upper() not in valid_levels:
-            raise ValueError(f"Log level must be one of: {valid_levels}")
-        return v.upper()
-
-    @field_validator("log_file", "access_log_file")
-    def validate_log_file(cls, v):
-        """Ensure log directory exists"""
-        if v:
-            log_path = Path(v)
-            log_path.parent.mkdir(parents=True, exist_ok=True)
+class SupabaseConfig(BaseSettings):
+    """Supabase configuration settings"""
+    
+    # Required Supabase credentials
+    supabase_url: str = Field(env="SUPABASE_URL")
+    supabase_anon_key: str = Field(env="SUPABASE_ANON_KEY") 
+    supabase_service_role_key: str = Field(env="SUPABASE_SERVICE_ROLE_KEY")
+    
+    # Storage bucket names
+    image_bucket: str = Field(default="tree-images", env="IMAGE_BUCKET")
+    audio_bucket: str = Field(default="tree-audio", env="AUDIO_BUCKET")
+    
+    # File URL expiry (in seconds)
+    signed_url_expiry: int = Field(default=3600, env="SIGNED_URL_EXPIRY", ge=300)
+    
+    @field_validator("supabase_url")
+    def validate_supabase_url(cls, v):
+        """Validate Supabase URL format"""
+        if not v or not v.startswith("https://"):
+            raise ValueError("SUPABASE_URL must be a valid HTTPS URL")
+        return v
+    
+    @field_validator("supabase_anon_key", "supabase_service_role_key")
+    def validate_keys(cls, v):
+        """Validate Supabase keys"""
+        if v and len(v) < 50:  # Only validate if provided
+            raise ValueError("Supabase keys must be valid if provided")
         return v
-
-
-class CacheConfig(BaseSettings):
-    """Cache configuration settings"""
-
-    # Cache settings
-    cache_enabled: bool = Field(default=True, env="CACHE_ENABLED")
-    cache_ttl_trees: int = Field(default=300, env="CACHE_TTL_TREES", ge=1)  # 5 minutes
-    cache_ttl_stats: int = Field(default=600, env="CACHE_TTL_STATS", ge=1)  # 10 minutes
-    cache_max_size: int = Field(default=1000, env="CACHE_MAX_SIZE", ge=1)
-
-
-class MonitoringConfig(BaseSettings):
-    """Monitoring and observability configuration"""
-
-    # Monitoring settings
-    metrics_enabled: bool = Field(default=True, env="METRICS_ENABLED")
-    health_check_enabled: bool = Field(default=True, env="HEALTH_CHECK_ENABLED")
-    performance_monitoring: bool = Field(default=True, env="PERFORMANCE_MONITORING")
-
-    # Alerting thresholds
-    error_rate_threshold: float = Field(
-        default=0.05, env="ERROR_RATE_THRESHOLD", ge=0.0, le=1.0
-    )
-    response_time_threshold: float = Field(
-        default=2.0, env="RESPONSE_TIME_THRESHOLD", ge=0.1
-    )
 
 
 class ApplicationConfig(BaseSettings):
     """Main application configuration"""
-
-    # Environment
-    environment: str = Field(default="development", env="ENVIRONMENT")
-    app_name: str = Field(default="Tree Mapping API", env="APP_NAME")
-    app_version: str = Field(default="2.0.0", env="APP_VERSION")
+    
+    # Application metadata
+    app_name: str = Field(default="TreeTrack", env="APP_NAME")
+    app_version: str = Field(default="3.0.0", env="APP_VERSION")
     app_description: str = Field(
-        default="Secure API for mapping and tracking trees", env="APP_DESCRIPTION"
+        default="Tree mapping and tracking with cloud storage", 
+        env="APP_DESCRIPTION"
     )
-
+    environment: str = Field(default="production", env="ENVIRONMENT")
+    
     # Feature flags
     enable_api_docs: bool = Field(default=True, env="ENABLE_API_DOCS")
-    enable_frontend: bool = Field(default=True, env="ENABLE_FRONTEND")
+    enable_frontend: bool = Field(default=True, env="ENABLE_FRONTEND") 
     enable_statistics: bool = Field(default=True, env="ENABLE_STATISTICS")
-
-    # Data validation
-    strict_validation: bool = Field(default=True, env="STRICT_VALIDATION")
+    enable_master_db: bool = Field(default=True, env="ENABLE_MASTER_DB")
+    
+    # Data validation limits
     max_species_length: int = Field(default=200, env="MAX_SPECIES_LENGTH", ge=1, le=500)
     max_notes_length: int = Field(default=2000, env="MAX_NOTES_LENGTH", ge=1, le=10000)
-
+    
     @field_validator("environment")
     def validate_environment(cls, v):
         """Validate environment"""
@@ -207,102 +111,24 @@ class ApplicationConfig(BaseSettings):
             raise ValueError(f"Environment must be one of: {valid_envs}")
         return v.lower()
 
-    class Config:
-        env_file = ".env"
-        env_file_encoding = "utf-8"
-        case_sensitive = False
-
 
 class Settings(BaseSettings):
     """Combined application settings"""
-
+    
     # Sub-configurations
-    database: DatabaseConfig = DatabaseConfig()
     security: SecurityConfig = SecurityConfig()
     server: ServerConfig = ServerConfig()
-    logging: LoggingConfig = LoggingConfig()
-    cache: CacheConfig = CacheConfig()
-    monitoring: MonitoringConfig = MonitoringConfig()
+    supabase: SupabaseConfig = SupabaseConfig()
     app: ApplicationConfig = ApplicationConfig()
-
-    @model_validator(mode="before")
-    def validate_production_settings(cls, values):
-        """Additional validation for production environment"""
-        app_config = values.get("app")
-        security_config = values.get("security")
-        server_config = values.get("server")
-
-        if app_config and app_config.environment == "production":
-            # Production-specific validations
-            if server_config and server_config.debug:
-                raise ValueError("Debug mode must be disabled in production")
-
-            if (
-                security_config
-                and security_config.secret_key == "dev-secret-key-change-in-production"
-            ):
-                raise ValueError("Must set a secure SECRET_KEY in production")
-
-        return values
-
-    def get_database_url(self) -> str:
-        """Get database connection URL"""
-        return f"sqlite:///{self.database.db_path}"
-
-    def get_log_config(self) -> dict:
-        """Get logging configuration dictionary"""
-        return {
-            "version": 1,
-            "disable_existing_loggers": False,
-            "formatters": {
-                "default": {
-                    "format": self.logging.log_format,
-                },
-                "access": {
-                    "format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-                },
-            },
-            "handlers": {
-                "default": {
-                    "formatter": "default",
-                    "class": "logging.handlers.RotatingFileHandler",
-                    "filename": self.logging.log_file,
-                    "maxBytes": self.logging.log_max_size,
-                    "backupCount": self.logging.log_backup_count,
-                }
-                if self.logging.log_file
-                else {
-                    "formatter": "default",
-                    "class": "logging.StreamHandler",
-                },
-                "access": {
-                    "formatter": "access",
-                    "class": "logging.handlers.RotatingFileHandler",
-                    "filename": self.logging.access_log_file,
-                    "maxBytes": self.logging.log_max_size,
-                    "backupCount": self.logging.log_backup_count,
-                }
-                if self.logging.access_log_file and self.logging.access_log_enabled
-                else {
-                    "formatter": "access",
-                    "class": "logging.StreamHandler",
-                },
-            },
-            "loggers": {
-                "": {
-                    "handlers": ["default"],
-                    "level": self.logging.log_level,
-                },
-                "uvicorn.access": {
-                    "handlers": ["access"],
-                    "level": "INFO",
-                    "propagate": False,
-                }
-                if self.logging.access_log_enabled
-                else {},
-            },
-        }
-
+    
+    def is_development(self) -> bool:
+        """Check if running in development mode"""
+        return self.app.environment == "development"
+    
+    def is_production(self) -> bool:
+        """Check if running in production mode"""
+        return self.app.environment == "production"
+    
     def get_cors_config(self) -> dict:
         """Get CORS configuration"""
         return {
@@ -311,25 +137,7 @@ class Settings(BaseSettings):
             "allow_methods": ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
             "allow_headers": ["*"],
         }
-
-    def get_csp_header(self) -> str:
-        """Get Content Security Policy header value"""
-        return (
-            f"default-src {self.security.csp_default_src}; "
-            f"script-src {self.security.csp_script_src}; "
-            f"style-src {self.security.csp_style_src}; "
-            f"img-src {self.security.csp_img_src}; "
-            f"connect-src {self.security.csp_connect_src}"
-        )
-
-    def is_development(self) -> bool:
-        """Check if running in development mode"""
-        return self.app.environment == "development"
-
-    def is_production(self) -> bool:
-        """Check if running in production mode"""
-        return self.app.environment == "production"
-
+    
     class Config:
         env_file = ".env"
         env_file_encoding = "utf-8"
@@ -342,62 +150,28 @@ def get_settings() -> Settings:
     return Settings()
 
 
-def setup_logging(settings: Settings) -> None:
-    """Setup application logging"""
-    import logging.config
-
-    # Ensure log directories exist
-    if settings.logging.log_file:
-        Path(settings.logging.log_file).parent.mkdir(parents=True, exist_ok=True)
+# For backward compatibility - expose individual configs
+def get_security_config():
+    return get_settings().security
 
-    if settings.logging.access_log_file:
-        Path(settings.logging.access_log_file).parent.mkdir(parents=True, exist_ok=True)
+def get_server_config():
+    return get_settings().server
 
-    # Configure logging
-    log_config = settings.get_log_config()
-    logging.config.dictConfig(log_config)
-
-    # Log startup information
-    logger = logging.getLogger(__name__)
-    logger.info(f"Starting {settings.app.app_name} v{settings.app.app_version}")
-    logger.info(f"Environment: {settings.app.environment}")
-    logger.info(f"Log level: {settings.logging.log_level}")
-
-
-def validate_settings() -> Settings:
-    """Validate and return application settings"""
-    try:
-        settings = get_settings()
-
-        # Additional runtime validations
-        if settings.is_production():
-            # Check critical production settings
-            if (
-                not settings.security.secret_key
-                or len(settings.security.secret_key) < 32
-            ):
-                raise ValueError("Production requires a secure SECRET_KEY")
-
-            if settings.server.debug:
-                raise ValueError("Debug mode must be disabled in production")
-
-        return settings
-
-    except Exception as e:
-        print(f"Configuration error: {e}")
-        raise
+def get_supabase_config():
+    return get_settings().supabase
 
 
 if __name__ == "__main__":
     # Test configuration loading
     try:
-        settings = validate_settings()
-        print(" Configuration loaded successfully")
+        settings = get_settings()
+        print("✅ Configuration loaded successfully")
+        print(f"App: {settings.app.app_name} v{settings.app.app_version}")
         print(f"Environment: {settings.app.environment}")
-        print(f"Database: {settings.database.db_path}")
         print(f"Server: {settings.server.host}:{settings.server.port}")
-        print(f"Log level: {settings.logging.log_level}")
-
+        print(f"Supabase URL: {settings.supabase.supabase_url}")
+        print(f"CORS Origins: {settings.security.cors_origins}")
+        
     except Exception as e:
-        print(f" Configuration error: {e}")
+        print(f"❌ Configuration error: {e}")
         exit(1)

supabase_client.py

@@ -10,10 +10,18 @@ from pathlib import Path
 
 logger = logging.getLogger(__name__)
 
-# Supabase configuration
-SUPABASE_URL = os.getenv("SUPABASE_URL", "https://puwgehualigbuxlopnkg.supabase.co")
-SUPABASE_ANON_KEY = os.getenv("SUPABASE_ANON_KEY", "")
-SUPABASE_SERVICE_ROLE_KEY = os.getenv("SUPABASE_SERVICE_ROLE_KEY", "")
+# Supabase configuration - all must be provided via environment variables
+SUPABASE_URL = os.getenv("SUPABASE_URL")
+SUPABASE_ANON_KEY = os.getenv("SUPABASE_ANON_KEY")
+SUPABASE_SERVICE_ROLE_KEY = os.getenv("SUPABASE_SERVICE_ROLE_KEY")
+
+# Validate required environment variables (defer validation to runtime)
+if not SUPABASE_URL:
+    logger.warning("SUPABASE_URL not found - will cause connection failures")
+if not SUPABASE_ANON_KEY:
+    logger.warning("SUPABASE_ANON_KEY not found - will cause connection failures")
+if not SUPABASE_SERVICE_ROLE_KEY:
+    logger.warning("SUPABASE_SERVICE_ROLE_KEY not provided - admin functions will be limited")
 
 # Initialize Supabase client
 supabase: Optional[Client] = None
@@ -38,146 +46,6 @@ def get_service_client() -> Client:
     
     return create_client(SUPABASE_URL, SUPABASE_SERVICE_ROLE_KEY)
 
-# Database operations
-class SupabaseTreeDB:
-    """Supabase database operations for trees"""
-    
-    def __init__(self):
-        self.client = get_supabase_client()
-    
-    def create_tree(self, tree_data: Dict[str, Any]) -> Dict[str, Any]:
-        """Create a new tree record"""
-        try:
-            result = self.client.table('trees').insert(tree_data).execute()
-            if result.data:
-                logger.info(f"Created tree with ID: {result.data[0].get('id')}")
-                return result.data[0]
-            else:
-                raise Exception("No data returned from insert operation")
-        except Exception as e:
-            logger.error(f"Error creating tree: {e}")
-            raise
-    
-    def get_trees(self, limit: int = 100, offset: int = 0) -> List[Dict[str, Any]]:
-        """Get trees with pagination"""
-        try:
-            result = self.client.table('trees') \
-                .select("*") \
-                .order('created_at', desc=True) \
-                .range(offset, offset + limit - 1) \
-                .execute()
-            
-            logger.info(f"Retrieved {len(result.data)} trees")
-            return result.data
-        except Exception as e:
-            logger.error(f"Error retrieving trees: {e}")
-            raise
-    
-    def get_tree(self, tree_id: int) -> Optional[Dict[str, Any]]:
-        """Get a specific tree by ID"""
-        try:
-            result = self.client.table('trees') \
-                .select("*") \
-                .eq('id', tree_id) \
-                .execute()
-            
-            if result.data:
-                return result.data[0]
-            return None
-        except Exception as e:
-            logger.error(f"Error retrieving tree {tree_id}: {e}")
-            raise
-    
-    def update_tree(self, tree_id: int, tree_data: Dict[str, Any]) -> Dict[str, Any]:
-        """Update a tree record"""
-        try:
-            result = self.client.table('trees') \
-                .update(tree_data) \
-                .eq('id', tree_id) \
-                .execute()
-            
-            if result.data:
-                logger.info(f"Updated tree with ID: {tree_id}")
-                return result.data[0]
-            else:
-                raise Exception(f"Tree with ID {tree_id} not found")
-        except Exception as e:
-            logger.error(f"Error updating tree {tree_id}: {e}")
-            raise
-    
-    def delete_tree(self, tree_id: int) -> bool:
-        """Delete a tree record"""
-        try:
-            result = self.client.table('trees') \
-                .delete() \
-                .eq('id', tree_id) \
-                .execute()
-            
-            logger.info(f"Deleted tree with ID: {tree_id}")
-            return True
-        except Exception as e:
-            logger.error(f"Error deleting tree {tree_id}: {e}")
-            raise
-    
-    def get_tree_count(self) -> int:
-        """Get total number of trees"""
-        try:
-            result = self.client.table('trees') \
-                .select("id", count="exact") \
-                .execute()
-            
-            return result.count if result.count is not None else 0
-        except Exception as e:
-            logger.error(f"Error getting tree count: {e}")
-            return 0
-
-# File storage operations
-class SupabaseStorage:
-    """Supabase storage operations for files"""
-    
-    def __init__(self):
-        self.client = get_supabase_client()
-    
-    def upload_file(self, bucket_name: str, file_path: str, file_data: bytes) -> str:
-        """Upload file to Supabase storage (private buckets)"""
-        try:
-            result = self.client.storage.from_(bucket_name).upload(file_path, file_data)
-            
-            if result:
-                # For private buckets, return the file path (we'll generate signed URLs when needed)
-                logger.info(f"File uploaded successfully: {file_path}")
-                return file_path
-            else:
-                raise Exception("Upload failed")
-        except Exception as e:
-            logger.error(f"Error uploading file {file_path}: {e}")
-            raise
-    
-    def delete_file(self, bucket_name: str, file_path: str) -> bool:
-        """Delete file from Supabase storage"""
-        try:
-            result = self.client.storage.from_(bucket_name).remove([file_path])
-            logger.info(f"File deleted: {file_path}")
-            return True
-        except Exception as e:
-            logger.error(f"Error deleting file {file_path}: {e}")
-            return False
-    
-    def get_public_url(self, bucket_name: str, file_path: str) -> str:
-        """Get public URL for a file"""
-        return self.client.storage.from_(bucket_name).get_public_url(file_path)
-    
-    def get_signed_url(self, bucket_name: str, file_path: str, expires_in: int = 3600) -> str:
-        """Get signed URL for private file (expires in seconds, default 1 hour)"""
-        try:
-            result = self.client.storage.from_(bucket_name).create_signed_url(file_path, expires_in)
-            if result and 'signedURL' in result:
-                return result['signedURL']
-            else:
-                raise Exception("Failed to generate signed URL")
-        except Exception as e:
-            logger.error(f"Error generating signed URL for {file_path}: {e}")
-            raise
 
 # Initialize database table (run once)
 def create_trees_table():
@@ -244,8 +112,8 @@ def create_storage_buckets():
     client = get_service_client()
     
     buckets = [
-        {"name": "tree-images", "public": True},
-        {"name": "tree-audio", "public": True}
+        {"name": "tree-images", "public": False},
+        {"name": "tree-audio", "public": False}
     ]
     
     for bucket in buckets:

supabase_database.py

@@ -0,0 +1,231 @@
+"""
+Supabase database implementation for TreeTrack
+Standalone implementation for Supabase Postgres operations
+"""
+
+import json
+import logging
+from typing import Dict, List, Optional, Any
+from supabase_client import get_supabase_client, get_service_client
+
+logger = logging.getLogger(__name__)
+
+
+class SupabaseDatabase:
+    """Supabase implementation of DatabaseInterface"""
+    
+    def __init__(self):
+        self.client = get_supabase_client()
+        logger.info("SupabaseDatabase initialized")
+    
+    def initialize_database(self) -> bool:
+        """Initialize database tables and indexes (already done via SQL)"""
+        # Tables are created via SQL in Supabase dashboard
+        # This just tests that the table exists
+        try:
+            result = self.client.table('trees').select("id").limit(1).execute()
+            logger.info("Trees table verified in Supabase")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to verify trees table: {e}")
+            return False
+    
+    def test_connection(self) -> bool:
+        """Test Supabase connection"""
+        try:
+            result = self.client.table('trees').select("id").limit(1).execute()
+            logger.info("Supabase connection successful")
+            return True
+        except Exception as e:
+            logger.error(f"Supabase connection failed: {e}")
+            return False
+    
+    def create_tree(self, tree_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Create a new tree record"""
+        try:
+            # Supabase handles JSON fields automatically, no need to stringify
+            result = self.client.table('trees').insert(tree_data).execute()
+            
+            if result.data:
+                created_tree = result.data[0]
+                logger.info(f"Created tree with ID: {created_tree.get('id')}")
+                return created_tree
+            else:
+                raise Exception("No data returned from insert operation")
+                
+        except Exception as e:
+            logger.error(f"Error creating tree: {e}")
+            raise
+    
+    def get_trees(self, limit: int = 100, offset: int = 0, 
+                  species: str = None, health_status: str = None) -> List[Dict[str, Any]]:
+        """Get trees with pagination and optional filters"""
+        try:
+            query = self.client.table('trees').select("*")
+            
+            # Apply filters
+            if species:
+                query = query.ilike('scientific_name', f'%{species}%')
+            
+            if health_status:
+                # Note: health_status field doesn't exist in our schema
+                # This is for future compatibility
+                pass
+            
+            # Apply pagination and ordering
+            result = query.order('created_at', desc=True) \
+                         .range(offset, offset + limit - 1) \
+                         .execute()
+            
+            logger.info(f"Retrieved {len(result.data)} trees from Supabase")
+            return result.data
+            
+        except Exception as e:
+            logger.error(f"Error retrieving trees: {e}")
+            raise
+    
+    def get_tree(self, tree_id: int) -> Optional[Dict[str, Any]]:
+        """Get a specific tree by ID"""
+        try:
+            result = self.client.table('trees') \
+                               .select("*") \
+                               .eq('id', tree_id) \
+                               .execute()
+            
+            if result.data:
+                return result.data[0]
+            return None
+            
+        except Exception as e:
+            logger.error(f"Error retrieving tree {tree_id}: {e}")
+            raise
+    
+    def update_tree(self, tree_id: int, tree_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Update a tree record"""
+        try:
+            # Remove id from update data if present
+            update_data = {k: v for k, v in tree_data.items() if k != 'id'}
+            
+            result = self.client.table('trees') \
+                               .update(update_data) \
+                               .eq('id', tree_id) \
+                               .execute()
+            
+            if result.data:
+                updated_tree = result.data[0]
+                logger.info(f"Updated tree with ID: {tree_id}")
+                return updated_tree
+            else:
+                raise Exception(f"Tree with ID {tree_id} not found")
+                
+        except Exception as e:
+            logger.error(f"Error updating tree {tree_id}: {e}")
+            raise
+    
+    def delete_tree(self, tree_id: int) -> bool:
+        """Delete a tree record"""
+        try:
+            result = self.client.table('trees') \
+                               .delete() \
+                               .eq('id', tree_id) \
+                               .execute()
+            
+            logger.info(f"Deleted tree with ID: {tree_id}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Error deleting tree {tree_id}: {e}")
+            raise
+    
+    def get_tree_count(self) -> int:
+        """Get total number of trees"""
+        try:
+            result = self.client.table('trees') \
+                               .select("id", count="exact") \
+                               .execute()
+            
+            return result.count if result.count is not None else 0
+            
+        except Exception as e:
+            logger.error(f"Error getting tree count: {e}")
+            return 0
+    
+    def get_species_distribution(self, limit: int = 20) -> List[Dict[str, Any]]:
+        """Get trees by species distribution"""
+        try:
+            # Use Supabase RPC for complex aggregation
+            # This requires creating a stored procedure in Supabase
+            # For now, we'll do a simple approach
+            
+            result = self.client.table('trees') \
+                               .select("scientific_name") \
+                               .not_.is_('scientific_name', 'null') \
+                               .execute()
+            
+            # Group by species in Python (not optimal but works)
+            species_count = {}
+            for tree in result.data:
+                species = tree.get('scientific_name', 'Unknown')
+                species_count[species] = species_count.get(species, 0) + 1
+            
+            # Convert to list and sort
+            distribution = [
+                {"species": species, "count": count}
+                for species, count in species_count.items()
+            ]
+            distribution.sort(key=lambda x: x['count'], reverse=True)
+            
+            return distribution[:limit]
+            
+        except Exception as e:
+            logger.error(f"Error getting species distribution: {e}")
+            return []
+    
+    def get_health_distribution(self) -> List[Dict[str, Any]]:
+        """Get trees by health status distribution"""
+        try:
+            # Health status field doesn't exist in our current schema
+            # Return empty for compatibility
+            return []
+            
+        except Exception as e:
+            logger.error(f"Error getting health distribution: {e}")
+            return []
+    
+    def get_average_measurements(self) -> Dict[str, float]:
+        """Get average height and diameter"""
+        try:
+            # Note: we have 'width' field, not 'diameter'
+            result = self.client.table('trees') \
+                               .select("height, width") \
+                               .not_.is_('height', 'null') \
+                               .not_.is_('width', 'null') \
+                               .execute()
+            
+            if not result.data:
+                return {"average_height": 0, "average_diameter": 0}
+            
+            heights = [float(tree['height']) for tree in result.data if tree['height']]
+            widths = [float(tree['width']) for tree in result.data if tree['width']]
+            
+            avg_height = sum(heights) / len(heights) if heights else 0
+            avg_width = sum(widths) / len(widths) if widths else 0
+            
+            return {
+                "average_height": round(avg_height, 2),
+                "average_diameter": round(avg_width, 2)  # Using width as diameter
+            }
+            
+        except Exception as e:
+            logger.error(f"Error getting average measurements: {e}")
+            return {"average_height": 0, "average_diameter": 0}
+    
+    def backup_database(self) -> bool:
+        """Backup database (not needed for Supabase - automatically backed up)"""
+        logger.info("Supabase automatically backs up data - no manual backup needed")
+        return True
+    
+    def restore_database(self) -> bool:
+        """Restore database (not needed for Supabase)"""
+        logger.info("Supabase data is persistent - no restore needed")
+        return True

supabase_storage.py

@@ -18,7 +18,7 @@ class SupabaseFileStorage:
     def __init__(self):
         self.client = get_supabase_client()
         self.image_bucket = "tree-images"
-        self.audio_bucket = "tree-audios"
+        self.audio_bucket = "tree-audio"
         logger.info("SupabaseFileStorage initialized")
     
     def upload_image(self, file_data: bytes, filename: str, category: str) -> Dict[str, Any]: