Add Supabase integration for persistent database and file storage

- Add supabase and psycopg2-binary dependencies
- Create comprehensive Supabase client with database operations
- Support for private storage buckets with signed URLs
- Database operations: create, read, update, delete trees
- File storage: upload images and audio with persistence
- Configuration via environment variables for HF Spaces

requirements.txt

@@ -8,3 +8,5 @@ pandas>=2.3.1
 aiofiles>=24.1.0
 GitPython>=3.1.40
 huggingface-hub>=0.19.0
+supabase>=2.3.4
+psycopg2-binary>=2.9.9

supabase_client.py

@@ -0,0 +1,271 @@
+"""
+Supabase client configuration and database operations for TreeTrack
+"""
+
+import os
+import logging
+from typing import Dict, List, Optional, Any
+from supabase import create_client, Client
+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", "")
+
+# Initialize Supabase client
+supabase: Optional[Client] = None
+
+def get_supabase_client() -> Client:
+    """Get Supabase client instance"""
+    global supabase
+    
+    if supabase is None:
+        if not SUPABASE_ANON_KEY:
+            raise ValueError("SUPABASE_ANON_KEY environment variable is required")
+        
+        supabase = create_client(SUPABASE_URL, SUPABASE_ANON_KEY)
+        logger.info("Supabase client initialized")
+    
+    return supabase
+
+def get_service_client() -> Client:
+    """Get Supabase client with service role (admin) permissions"""
+    if not SUPABASE_SERVICE_ROLE_KEY:
+        raise ValueError("SUPABASE_SERVICE_ROLE_KEY environment variable is required")
+    
+    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():
+    """Create the trees table in Supabase"""
+    client = get_service_client()
+    
+    # SQL to create trees table
+    sql = """
+    CREATE TABLE IF NOT EXISTS trees (
+        id BIGSERIAL PRIMARY KEY,
+        latitude DECIMAL(10, 8) NOT NULL CHECK (latitude >= -90 AND latitude <= 90),
+        longitude DECIMAL(11, 8) NOT NULL CHECK (longitude >= -180 AND longitude <= 180),
+        local_name VARCHAR(200),
+        scientific_name VARCHAR(200),
+        common_name VARCHAR(200),
+        tree_code VARCHAR(20),
+        height DECIMAL(5, 2) CHECK (height > 0 AND height <= 200),
+        width DECIMAL(6, 2) CHECK (width > 0 AND width <= 2000),
+        utility JSONB,
+        storytelling_text TEXT CHECK (LENGTH(storytelling_text) <= 5000),
+        storytelling_audio VARCHAR(500),
+        phenology_stages JSONB,
+        photographs JSONB,
+        notes TEXT CHECK (LENGTH(notes) <= 2000),
+        created_at TIMESTAMPTZ DEFAULT NOW(),
+        updated_at TIMESTAMPTZ DEFAULT NOW(),
+        created_by VARCHAR(100) DEFAULT 'system'
+    );
+    
+    -- Create indexes for better performance
+    CREATE INDEX IF NOT EXISTS idx_trees_location ON trees(latitude, longitude);
+    CREATE INDEX IF NOT EXISTS idx_trees_scientific_name ON trees(scientific_name);
+    CREATE INDEX IF NOT EXISTS idx_trees_local_name ON trees(local_name);
+    CREATE INDEX IF NOT EXISTS idx_trees_tree_code ON trees(tree_code);
+    CREATE INDEX IF NOT EXISTS idx_trees_created_at ON trees(created_at);
+    
+    -- Create updated_at trigger
+    CREATE OR REPLACE FUNCTION update_updated_at_column()
+    RETURNS TRIGGER AS $$
+    BEGIN
+        NEW.updated_at = NOW();
+        RETURN NEW;
+    END;
+    $$ language 'plpgsql';
+    
+    DROP TRIGGER IF EXISTS update_trees_updated_at ON trees;
+    CREATE TRIGGER update_trees_updated_at
+        BEFORE UPDATE ON trees
+        FOR EACH ROW
+        EXECUTE FUNCTION update_updated_at_column();
+    """
+    
+    try:
+        client.rpc('exec_sql', {'sql': sql}).execute()
+        logger.info("Trees table created successfully")
+        return True
+    except Exception as e:
+        logger.error(f"Error creating trees table: {e}")
+        return False
+
+# Storage buckets setup
+def create_storage_buckets():
+    """Create storage buckets for files"""
+    client = get_service_client()
+    
+    buckets = [
+        {"name": "tree-images", "public": True},
+        {"name": "tree-audio", "public": True}
+    ]
+    
+    for bucket in buckets:
+        try:
+            result = client.storage.create_bucket(bucket["name"], {"public": bucket["public"]})
+            logger.info(f"Created storage bucket: {bucket['name']}")
+        except Exception as e:
+            logger.info(f"Bucket {bucket['name']} might already exist: {e}")
+    
+    return True
+
+# Test connection
+def test_supabase_connection() -> bool:
+    """Test Supabase connection"""
+    try:
+        client = get_supabase_client()
+        # Try to query the auth users (should work with anon key)
+        result = 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