d5

check_deployed_api.py

@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+"""
+Check if the deployed Hugging Face Space API has the updated code
+"""
+
+import requests
+import sys
+
+def check_deployed_api(api_url):
+    """Check if the deployed API has the health endpoint and shows correct version"""
+    
+    print("=" * 60)
+    print("CHECKING DEPLOYED API")
+    print("=" * 60)
+    print(f"API URL: {api_url}")
+    print()
+    
+    try:
+        # Check health endpoint
+        print("1. Checking /health endpoint...")
+        response = requests.get(f"{api_url}/health", timeout=10)
+        
+        if response.status_code == 200:
+            data = response.json()
+            print("   ✅ API is online!")
+            print(f"   Status: {data.get('status')}")
+            print(f"   Storage: {data.get('storage')}")
+            print(f"   Supabase: {data.get('apis', {}).get('supabase')}")
+            print()
+        else:
+            print(f"   ❌ Health check failed: HTTP {response.status_code}")
+            return False
+        
+        # Check root endpoint for version info
+        print("2. Checking / endpoint for version...")
+        response = requests.get(f"{api_url}/", timeout=10)
+        
+        if response.status_code == 200:
+            data = response.json()
+            print("   ✅ Root endpoint accessible!")
+            print(f"   Message: {data.get('message')}")
+            print(f"   Version: {data.get('version')}")
+            print(f"   Data Storage: {data.get('data_storage')}")
+            print()
+        else:
+            print(f"   ❌ Root endpoint failed: HTTP {response.status_code}")
+        
+        # Try a test submission to see error handling
+        print("3. Testing error handling (this should fail gracefully)...")
+        print("   Sending invalid submission to check error messages...")
+        
+        # This should fail with a proper error message
+        test_data = {
+            'species_name': 'TEST_SPECIES',
+            'location': 'INVALID_LOCATION',  # This should fail validation
+            'species_type': 'plant'
+        }
+        
+        response = requests.post(
+            f"{api_url}/submit-new-species",
+            data=test_data,
+            timeout=10
+        )
+        
+        if response.status_code == 400:
+            error_data = response.json()
+            print("   ✅ Error handling works!")
+            print(f"   Error message: {error_data.get('detail')}")
+            
+            # Check if it's the NEW error message format
+            if "Invalid location" in error_data.get('detail', ''):
+                print("   ✅ NEW CODE DETECTED - Error messages are specific!")
+            else:
+                print("   ⚠️  OLD CODE - Error messages are generic")
+        else:
+            print(f"   Status: {response.status_code}")
+            print(f"   Response: {response.text[:200]}")
+        
+        print()
+        print("=" * 60)
+        print("✅ API CHECK COMPLETE")
+        print("=" * 60)
+        print()
+        print("Next steps:")
+        print("1. If API is online but using old code:")
+        print("   → Restart the Hugging Face Space")
+        print("2. If API is offline:")
+        print("   → Check Hugging Face Space logs for errors")
+        print("3. Test with a real species submission from the frontend")
+        print()
+        
+        return True
+        
+    except requests.exceptions.ConnectionError:
+        print("   ❌ Connection Error - Cannot reach the API")
+        print("   → Check if the Hugging Face Space is running")
+        print("   → Verify the API URL is correct")
+        return False
+    except requests.exceptions.Timeout:
+        print("   ❌ Timeout - API is not responding")
+        print("   → The Space might be starting up (wait 2-3 minutes)")
+        return False
+    except Exception as e:
+        print(f"   ❌ Error: {e}")
+        return False
+
+if __name__ == "__main__":
+    # Default API URL - update this with your actual Hugging Face Space URL
+    api_url = input("Enter your Hugging Face Space API URL (e.g., https://YOUR-USERNAME-YOUR-SPACE.hf.space): ").strip()
+    
+    if not api_url:
+        print("No URL provided. Using example...")
+        api_url = "http://localhost:7860"  # Fallback to local
+    
+    # Remove trailing slash if present
+    api_url = api_url.rstrip('/')
+    
+    check_deployed_api(api_url)

fix_logs_rls.sql

@@ -0,0 +1,26 @@
+-- Fix RLS policy for recognition_logs table
+-- Run this in your Supabase SQL Editor
+
+-- 1. Enable RLS (just in case)
+ALTER TABLE public.recognition_logs ENABLE ROW LEVEL SECURITY;
+
+-- 2. Drop existing policies to cleanly recreate them
+DROP POLICY IF EXISTS "Anyone can log recognitions" ON public.recognition_logs;
+DROP POLICY IF EXISTS "Enable insert for all users" ON public.recognition_logs;
+DROP POLICY IF EXISTS "Enable read for all users" ON public.recognition_logs;
+
+-- 3. Create permissive policies for both INSERT and SELECT
+-- Allow the API (anon/service_role) to insert logs
+CREATE POLICY "Enable insert for all users"
+  ON public.recognition_logs FOR INSERT
+  WITH CHECK (true);
+
+-- Allow reading logs (if needed for dashboard)
+CREATE POLICY "Enable read for all users"
+  ON public.recognition_logs FOR SELECT
+  USING (true);
+
+-- 4. Verify policies
+SELECT tablename, policyname, cmd, diff_key 
+FROM pg_policies 
+WHERE tablename = 'recognition_logs';

test_live_insert.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+"""
+Test script to simulate what happens when the API tries to insert a species
+This will help us see the ACTUAL error from Supabase
+"""
+
+import os
+from dotenv import load_dotenv
+from supabase import create_client, Client
+
+# Load environment variables
+load_dotenv()
+
+SUPABASE_URL = os.getenv("SUPABASE_URL", "")
+SUPABASE_KEY = os.getenv("SUPABASE_KEY", "")
+
+def test_insert_with_validation():
+    """Test inserting a species with proper response validation"""
+    
+    if not SUPABASE_URL or not SUPABASE_KEY:
+        print("❌ ERROR: SUPABASE_URL or SUPABASE_KEY not found in .env file")
+        return
+    
+    try:
+        # Initialize Supabase client
+        supabase: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
+        
+        # Test data - similar to what the API would send
+        species_data = {
+            "sno": 88888,
+            "species_name": "Test Plant Species",
+            "species_type": "plant",
+            "location": "QSC",
+            "latitude": 12.92000,
+            "longitude": 80.12100,
+            "added_by": "test_user",
+            "notes": "Testing insert validation"
+        }
+        
+        print("=" * 60)
+        print("TESTING SPECIES INSERT WITH VALIDATION")
+        print("=" * 60)
+        print(f"\n[DEBUG] Attempting to insert species data:")
+        print(f"  Species: {species_data['species_name']}")
+        print(f"  Location: {species_data['location']}")
+        print(f"  Type: {species_data['species_type']}")
+        print()
+        
+        # This is what the API does
+        response = supabase.table("species").insert(species_data).execute()
+        
+        print(f"[DEBUG] Response received:")
+        print(f"  response.data: {response.data}")
+        print(f"  response.count: {response.count}")
+        print(f"  Type: {type(response.data)}")
+        print(f"  Length: {len(response.data) if response.data else 'None'}")
+        print()
+        
+        # Check if the insert was successful (NEW VALIDATION)
+        if not response.data or len(response.data) == 0:
+            print("❌ [ERROR] Insert failed - no data returned!")
+            print(f"   Full response: {response}")
+            print()
+            print("🔍 DIAGNOSIS:")
+            print("   The insert was called but Supabase returned no data.")
+            print("   This usually means:")
+            print("   1. RLS policy blocked the insert (permission denied)")
+            print("   2. A constraint was violated (duplicate key)")
+            print("   3. The insert was rolled back due to an error")
+            return False
+        
+        print(f"✅ [INFO] Successfully saved {species_data['species_name']} to Supabase")
+        print(f"[DEBUG] Insert response: {response.data}")
+        print()
+        
+        # Verify by reading it back
+        inserted_id = response.data[0].get('id')
+        print(f"[VERIFY] Reading back inserted record (ID: {inserted_id})...")
+        verify = supabase.table("species").select("*").eq("id", inserted_id).execute()
+        
+        if verify.data and len(verify.data) > 0:
+            print("✅ Verification successful - data exists in database!")
+            print(f"   Data: {verify.data[0]}")
+        else:
+            print("❌ Verification FAILED - data not found!")
+            return False
+        
+        # Clean up
+        print()
+        print("[CLEANUP] Deleting test record...")
+        supabase.table("species").delete().eq("id", inserted_id).execute()
+        print("✅ Test record deleted")
+        print()
+        
+        print("=" * 60)
+        print("✅ TEST PASSED - Insert validation is working!")
+        print("=" * 60)
+        return True
+        
+    except Exception as e:
+        print()
+        print("=" * 60)
+        print("❌ EXCEPTION CAUGHT")
+        print("=" * 60)
+        print(f"Error type: {type(e).__name__}")
+        print(f"Error message: {str(e)}")
+        print()
+        
+        error_str = str(e).lower()
+        
+        if "duplicate key" in error_str or "unique constraint" in error_str:
+            print("🔍 DIAGNOSIS: Duplicate Key Violation")
+            print("   A species with this name already exists at this location.")
+            print("   Solution: The API should return HTTP 409 with a clear message.")
+        elif "permission denied" in error_str or "policy" in error_str or "rls" in error_str:
+            print("🔍 DIAGNOSIS: Row Level Security (RLS) Policy Issue")
+            print("   The RLS policy is blocking the insert.")
+            print("   Solution: Run fix_species_insert.sql in Supabase SQL Editor")
+        elif "violates not-null constraint" in error_str:
+            print("🔍 DIAGNOSIS: Missing Required Field")
+            print("   A required field is missing from the insert data.")
+        else:
+            print("🔍 DIAGNOSIS: Unknown Error")
+            print("   Check the error message above for details.")
+        
+        print()
+        return False
+
+if __name__ == "__main__":
+    test_insert_with_validation()

verify_remote_species.py

@@ -0,0 +1,42 @@
+import requests
+import json
+
+API_URL = "https://greennai-greenai.hf.space"
+
+def check_species_exists(species_name, location):
+    print(f"Checking if '{species_name}' exists in '{location}'...")
+    
+    # We can't query the DB directly via API, but we can try to add it again
+    # If it exists, it should return 409 Conflict
+    
+    payload = {
+        "species_name": species_name,
+        "location": location,
+        "species_type": "plant",
+        "user_id": "test_script"
+    }
+    
+    try:
+        response = requests.post(f"{API_URL}/submit-new-species", json=payload)
+        
+        print(f"Status Code: {response.status_code}")
+        print(f"Response: {response.text}")
+        
+        if response.status_code == 409:
+            print("✅ SUCCESS: The API knows this species exists (Duplicate Error)")
+            return True
+        elif response.status_code == 200:
+            print("❌ FAILURE: The API added it again (It didn't know it existed)")
+            return False
+        else:
+            print(f"⚠️ UNEXPECTED: {response.status_code}")
+            return False
+            
+    except Exception as e:
+        print(f"Error: {e}")
+        return False
+
+# Test with the species you mentioned
+check_species_exists("Ocimum gratissimum (African basil)", "QSC")
+check_species_exists("Ocimum gratissimum", "QSC")
+check_species_exists("African basil", "QSC")