Create clean Supabase-only TreeTrack implementation

- Add SupabaseFileStorage for image/audio uploads with private buckets
- Create app_supabase.py - clean FastAPI app using only Supabase
- No SQLite complexity, no backup/restore systems
- Direct Postgres + Storage integration
- Signed URLs for private file access
- All functionality preserved with cleaner codebase

app_supabase.py

@@ -0,0 +1,601 @@
+"""
+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"
+    )

supabase_storage.py

@@ -0,0 +1,153 @@
+"""
+Supabase file storage implementation for TreeTrack
+Handles images and audio uploads to private Supabase Storage buckets
+"""
+
+import os
+import uuid
+import logging
+from typing import Dict, Any, Optional
+from pathlib import Path
+from supabase_client import get_supabase_client
+
+logger = logging.getLogger(__name__)
+
+class SupabaseFileStorage:
+    """Supabase Storage implementation for file uploads"""
+    
+    def __init__(self):
+        self.client = get_supabase_client()
+        self.image_bucket = "tree-images"
+        self.audio_bucket = "tree-audios"
+        logger.info("SupabaseFileStorage initialized")
+    
+    def upload_image(self, file_data: bytes, filename: str, category: str) -> Dict[str, Any]:
+        """Upload image to Supabase Storage"""
+        try:
+            # Generate unique filename
+            file_id = str(uuid.uuid4())
+            file_extension = Path(filename).suffix.lower()
+            unique_filename = f"{category.lower()}/{file_id}{file_extension}"
+            
+            # Upload to Supabase Storage
+            result = self.client.storage.from_(self.image_bucket).upload(
+                unique_filename, file_data
+            )
+            
+            if result:
+                logger.info(f"Image uploaded successfully: {unique_filename}")
+                return {
+                    "success": True,
+                    "filename": unique_filename,
+                    "bucket": self.image_bucket,
+                    "category": category,
+                    "size": len(file_data),
+                    "file_id": file_id
+                }
+            else:
+                raise Exception("Upload failed")
+                
+        except Exception as e:
+            logger.error(f"Error uploading image {filename}: {e}")
+            raise Exception(f"Failed to upload image: {str(e)}")
+    
+    def upload_audio(self, file_data: bytes, filename: str) -> Dict[str, Any]:
+        """Upload audio to Supabase Storage"""
+        try:
+            # Generate unique filename
+            file_id = str(uuid.uuid4())
+            file_extension = Path(filename).suffix.lower()
+            unique_filename = f"audio/{file_id}{file_extension}"
+            
+            # Upload to Supabase Storage
+            result = self.client.storage.from_(self.audio_bucket).upload(
+                unique_filename, file_data
+            )
+            
+            if result:
+                logger.info(f"Audio uploaded successfully: {unique_filename}")
+                return {
+                    "success": True,
+                    "filename": unique_filename,
+                    "bucket": self.audio_bucket,
+                    "size": len(file_data),
+                    "file_id": file_id
+                }
+            else:
+                raise Exception("Upload failed")
+                
+        except Exception as e:
+            logger.error(f"Error uploading audio {filename}: {e}")
+            raise Exception(f"Failed to upload audio: {str(e)}")
+    
+    def get_signed_url(self, bucket_name: str, file_path: str, expires_in: int = 3600) -> str:
+        """Generate signed URL for private file access"""
+        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 Exception(f"Failed to generate file URL: {str(e)}")
+    
+    def get_image_url(self, image_path: str, expires_in: int = 3600) -> str:
+        """Get signed URL for image"""
+        return self.get_signed_url(self.image_bucket, image_path, expires_in)
+    
+    def get_audio_url(self, audio_path: str, expires_in: int = 3600) -> str:
+        """Get signed URL for audio"""
+        return self.get_signed_url(self.audio_bucket, audio_path, expires_in)
+    
+    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: {bucket_name}/{file_path}")
+            return True
+        except Exception as e:
+            logger.error(f"Error deleting file {file_path}: {e}")
+            return False
+    
+    def delete_image(self, image_path: str) -> bool:
+        """Delete image from storage"""
+        return self.delete_file(self.image_bucket, image_path)
+    
+    def delete_audio(self, audio_path: str) -> bool:
+        """Delete audio from storage"""
+        return self.delete_file(self.audio_bucket, audio_path)
+    
+    def process_tree_files(self, tree_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Process tree data to add signed URLs for files"""
+        processed_data = tree_data.copy()
+        
+        try:
+            # Process photographs
+            if processed_data.get('photographs'):
+                photos = processed_data['photographs']
+                if isinstance(photos, dict):
+                    for category, file_path in photos.items():
+                        if file_path:
+                            try:
+                                photos[f"{category}_url"] = self.get_image_url(file_path)
+                            except Exception as e:
+                                logger.warning(f"Failed to generate URL for photo {file_path}: {e}")
+            
+            # Process storytelling audio
+            if processed_data.get('storytelling_audio'):
+                audio_path = processed_data['storytelling_audio']
+                try:
+                    processed_data['storytelling_audio_url'] = self.get_audio_url(audio_path)
+                except Exception as e:
+                    logger.warning(f"Failed to generate URL for audio {audio_path}: {e}")
+            
+            return processed_data
+            
+        except Exception as e:
+            logger.error(f"Error processing tree files: {e}")
+            return processed_data