geomind-ai 1.0.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

geomind/__init__.py

@@ -3,9 +3,9 @@ GeoMind - Geospatial AI Agent
 
 """
 
-__version__ = "1.0.0"
-__author__ = "Harsh Shinde"
+__version__ = "1.0.1"
+__author__ = "Harsh Shinde, Rajat Shinde"
 
 from .agent import GeoMindAgent
 
-__all__ = ["GeoMindAgent"]
+__all__ = ["GeoMindAgent"]

geomind/agent.py

@@ -6,12 +6,15 @@ queries about satellite imagery and execute the appropriate tools.
 """
 
 import json
-from typing import Optional
+import re
+from typing import Optional, Callable, Any
 from datetime import datetime
 
 from openai import OpenAI
 
-from .config import OPENROUTER_API_KEY, OPENROUTER_API_URL, OPENROUTER_MODEL
+from .config import (
+    OPENROUTER_API_KEY, OPENROUTER_API_URL, OPENROUTER_MODEL
+)
 from .tools import (
     geocode_location,
     get_bbox_from_location,
@@ -48,12 +51,12 @@ TOOLS = [
                 "properties": {
                     "place_name": {
                         "type": "string",
-                        "description": "The name of the place to geocode (e.g., 'New York City', 'Paris, France')",
+                        "description": "The name of the place to geocode (e.g., 'New York City', 'Paris, France')"
                     }
                 },
-                "required": ["place_name"],
-            },
-        },
+                "required": ["place_name"]
+            }
+        }
     },
     {
         "type": "function",
@@ -65,16 +68,16 @@ TOOLS = [
                 "properties": {
                     "place_name": {
                         "type": "string",
-                        "description": "The name of the place",
+                        "description": "The name of the place"
                     },
                     "buffer_km": {
                         "type": "number",
-                        "description": "Buffer distance in kilometers (default: 10)",
-                    },
+                        "description": "Buffer distance in kilometers (default: 10)"
+                    }
                 },
-                "required": ["place_name"],
-            },
-        },
+                "required": ["place_name"]
+            }
+        }
     },
     {
         "type": "function",
@@ -87,28 +90,28 @@ TOOLS = [
                     "bbox": {
                         "type": "array",
                         "items": {"type": "number"},
-                        "description": "Bounding box as [min_lon, min_lat, max_lon, max_lat]",
+                        "description": "Bounding box as [min_lon, min_lat, max_lon, max_lat]"
                     },
                     "start_date": {
                         "type": "string",
-                        "description": "Start date in YYYY-MM-DD format",
+                        "description": "Start date in YYYY-MM-DD format"
                     },
                     "end_date": {
                         "type": "string",
-                        "description": "End date in YYYY-MM-DD format",
+                        "description": "End date in YYYY-MM-DD format"
                     },
                     "max_cloud_cover": {
                         "type": "number",
-                        "description": "Maximum cloud cover percentage (0-100)",
+                        "description": "Maximum cloud cover percentage (0-100)"
                     },
                     "max_items": {
                         "type": "integer",
-                        "description": "Maximum number of results",
-                    },
+                        "description": "Maximum number of results"
+                    }
                 },
-                "required": [],
-            },
-        },
+                "required": []
+            }
+        }
     },
     {
         "type": "function",
@@ -120,24 +123,24 @@ TOOLS = [
                 "properties": {
                     "location_name": {
                         "type": "string",
-                        "description": "Name of the location to search",
+                        "description": "Name of the location to search"
                     },
                     "days": {
                         "type": "integer",
-                        "description": "Number of days to look back (default: 7)",
+                        "description": "Number of days to look back (default: 7)"
                     },
                     "max_cloud_cover": {
                         "type": "number",
-                        "description": "Maximum cloud cover percentage",
+                        "description": "Maximum cloud cover percentage"
                     },
                     "max_items": {
                         "type": "integer",
-                        "description": "Maximum number of results",
-                    },
+                        "description": "Maximum number of results"
+                    }
                 },
-                "required": [],
-            },
-        },
+                "required": []
+            }
+        }
     },
     {
         "type": "function",
@@ -147,11 +150,14 @@ TOOLS = [
             "parameters": {
                 "type": "object",
                 "properties": {
-                    "item_id": {"type": "string", "description": "The STAC item ID"}
+                    "item_id": {
+                        "type": "string",
+                        "description": "The STAC item ID"
+                    }
                 },
-                "required": ["item_id"],
-            },
-        },
+                "required": ["item_id"]
+            }
+        }
     },
     {
         "type": "function",
@@ -163,20 +169,20 @@ TOOLS = [
                 "properties": {
                     "zarr_url": {
                         "type": "string",
-                        "description": "URL to the SR_10m Zarr asset from a STAC item",
+                        "description": "URL to the SR_10m Zarr asset from a STAC item"
                     },
                     "output_path": {
                         "type": "string",
-                        "description": "Optional path to save the output image",
+                        "description": "Optional path to save the output image"
                     },
                     "subset_size": {
                         "type": "integer",
-                        "description": "Size to subset the image (default: 1000 pixels)",
-                    },
+                        "description": "Size to subset the image (default: 1000 pixels)"
+                    }
                 },
-                "required": ["zarr_url"],
-            },
-        },
+                "required": ["zarr_url"]
+            }
+        }
     },
     {
         "type": "function",
@@ -188,20 +194,20 @@ TOOLS = [
                 "properties": {
                     "zarr_url": {
                         "type": "string",
-                        "description": "URL to the SR_10m Zarr asset",
+                        "description": "URL to the SR_10m Zarr asset"
                     },
                     "output_path": {
                         "type": "string",
-                        "description": "Optional path to save the NDVI image",
+                        "description": "Optional path to save the NDVI image"
                     },
                     "subset_size": {
                         "type": "integer",
-                        "description": "Size to subset the image",
-                    },
+                        "description": "Size to subset the image"
+                    }
                 },
-                "required": ["zarr_url"],
-            },
-        },
+                "required": ["zarr_url"]
+            }
+        }
     },
     {
         "type": "function",
@@ -213,67 +219,65 @@ TOOLS = [
                 "properties": {
                     "zarr_url": {
                         "type": "string",
-                        "description": "URL to the Zarr asset",
+                        "description": "URL to the Zarr asset"
                     },
                     "bands": {
                         "type": "array",
                         "items": {"type": "string"},
-                        "description": "List of band names to analyze",
-                    },
+                        "description": "List of band names to analyze"
+                    }
                 },
-                "required": ["zarr_url"],
-            },
-        },
-    },
+                "required": ["zarr_url"]
+            }
+        }
+    }
 ]
 
 
 class GeoMindAgent:
     """
     GeoMind - An AI agent for geospatial analysis with Sentinel-2 imagery.
-
+    
     Uses OpenRouter API for access to multiple AI models.
     """
-
-    def __init__(self, model: Optional[str] = None, api_key: Optional[str] = None):
+    
+    def __init__(self, model: Optional[str] = None):
         """
         Initialize the GeoMind agent.
-
+        
         Args:
             model: Model name (default: xiaomi/mimo-v2-flash:free)
-            api_key: OpenRouter API key. If not provided, looks for OPENROUTER_API_KEY env variable.
         """
         self.provider = "openrouter"
-        self.api_key = api_key or OPENROUTER_API_KEY
+        self.api_key = OPENROUTER_API_KEY
         self.model_name = model or OPENROUTER_MODEL
         self.base_url = OPENROUTER_API_URL
-
+        
         if not self.api_key:
             raise ValueError(
-                "OpenRouter API key required.\n"
-                "You can provide it in three ways:\n"
-                "1. Pass it to the constructor: GeoMindAgent(api_key='your-key')\n"
-                "2. Set OPENROUTER_API_KEY environment variable\n"
-                "3. Create a .env file with OPENROUTER_API_KEY=your-key\n"
-                "\nGet your API key at: https://openrouter.ai/settings/keys"
+                "OpenRouter API key required. Set OPENROUTER_API_KEY in .env file.\n"
+                "Get your API key at: https://openrouter.ai/settings/keys"
             )
-
+        
         print(f"🚀 GeoMind Agent initialized with {self.model_name} (OpenRouter)")
         print(f"   API URL: {self.base_url}")
-
+        
         # Create OpenAI-compatible client
-        self.client = OpenAI(base_url=self.base_url, api_key=self.api_key)
-
+        self.client = OpenAI(
+            base_url=self.base_url,
+            api_key=self.api_key
+        )
+        
         # Chat history
         self.history = []
-
+        
         # Add system message
         self.system_prompt = self._get_system_prompt()
-
+    
     def _get_system_prompt(self) -> str:
         """Get the system prompt for the agent."""
-        return f"""You are GeoMind, an expert AI assistant specialized in geospatial analysis
-and satellite imagery. You help users find, analyze, and visualize Sentinel-2 satellite data
+        return f"""You are GeoMind, an expert AI assistant specialized in geospatial analysis 
+and satellite imagery. You help users find, analyze, and visualize Sentinel-2 satellite data 
 from the EOPF (ESA Earth Observation Processing Framework) catalog.
 
 Your capabilities include:
@@ -294,20 +298,20 @@ When users ask for imagery:
 3. Offer to create visualizations if data is found
 
 Always explain what you're doing and interpret results in a helpful way."""
-
+    
     def _execute_function(self, name: str, args: dict) -> dict:
         """Execute a function call and return the result."""
         print(f"  🔧 Executing: {name}({args})")
-
+        
         if name not in TOOL_FUNCTIONS:
             return {"error": f"Unknown function: {name}"}
-
+        
         try:
             result = TOOL_FUNCTIONS[name](**args)
             return result
         except Exception as e:
             return {"error": str(e)}
-
+    
     def chat(self, message: str, verbose: bool = True) -> str:
         """
         Send a message to the agent and get a response.
@@ -315,19 +319,19 @@ Always explain what you're doing and interpret results in a helpful way."""
         if verbose:
             print(f"\n💬 User: {message}")
             print("🤔 Processing...")
-
+        
         # Add user message to history
         self.history.append({"role": "user", "content": message})
-
+        
         # Build messages with system prompt
         messages = [{"role": "system", "content": self.system_prompt}] + self.history
-
+        
         max_iterations = 10
         iteration = 0
-
+        
         while iteration < max_iterations:
             iteration += 1
-
+            
             # Call the model
             response = self.client.chat.completions.create(
                 model=self.model_name,
@@ -336,59 +340,55 @@ Always explain what you're doing and interpret results in a helpful way."""
                 tool_choice="auto",
                 max_tokens=4096,
             )
-
+            
             assistant_message = response.choices[0].message
-
+            
             # Check if there are tool calls
             if assistant_message.tool_calls:
                 # Add assistant message with tool calls to messages
-                messages.append(
-                    {
-                        "role": "assistant",
-                        "content": assistant_message.content or "",
-                        "tool_calls": [
-                            {
-                                "id": tc.id,
-                                "type": "function",
-                                "function": {
-                                    "name": tc.function.name,
-                                    "arguments": tc.function.arguments,
-                                },
+                messages.append({
+                    "role": "assistant",
+                    "content": assistant_message.content or "",
+                    "tool_calls": [
+                        {
+                            "id": tc.id,
+                            "type": "function",
+                            "function": {
+                                "name": tc.function.name,
+                                "arguments": tc.function.arguments
                             }
-                            for tc in assistant_message.tool_calls
-                        ],
-                    }
-                )
-
+                        }
+                        for tc in assistant_message.tool_calls
+                    ]
+                })
+                
                 # Execute each tool call
                 for tool_call in assistant_message.tool_calls:
                     func_name = tool_call.function.name
                     func_args = json.loads(tool_call.function.arguments)
-
+                    
                     result = self._execute_function(func_name, func_args)
-
+                    
                     # Add tool result to messages
-                    messages.append(
-                        {
-                            "role": "tool",
-                            "tool_call_id": tool_call.id,
-                            "content": json.dumps(result, default=str),
-                        }
-                    )
+                    messages.append({
+                        "role": "tool",
+                        "tool_call_id": tool_call.id,
+                        "content": json.dumps(result, default=str)
+                    })
             else:
                 # No tool calls, we have a final response
                 final_text = assistant_message.content or ""
-
+                
                 # Add to history
                 self.history.append({"role": "assistant", "content": final_text})
-
+                
                 if verbose:
                     print(f"\n🌍 GeoMind: {final_text}")
-
+                
                 return final_text
-
+        
         return "Max iterations reached."
-
+    
     def reset(self):
         """Reset the chat session."""
         self.history = []
@@ -398,7 +398,7 @@ Always explain what you're doing and interpret results in a helpful way."""
 def main(model: Optional[str] = None):
     """Main entry point for CLI usage."""
     import sys
-
+    
     print("=" * 60)
     print("🌍 GeoMind - Geospatial AI Agent")
     print("=" * 60)
@@ -406,7 +406,7 @@ def main(model: Optional[str] = None):
     print("Type 'quit' or 'exit' to end the session")
     print("Type 'reset' to start a new conversation")
     print("=" * 60)
-
+    
     try:
         agent = GeoMindAgent(model=model)
     except ValueError as e:
@@ -416,24 +416,24 @@ def main(model: Optional[str] = None):
         print(f"\n❌ Error: {e}")
         print("\nPlease check your API key and internet connection.")
         sys.exit(1)
-
+    
     while True:
         try:
             user_input = input("\n💬 You: ").strip()
-
+            
             if not user_input:
                 continue
-
-            if user_input.lower() in ["quit", "exit", "q"]:
+            
+            if user_input.lower() in ['quit', 'exit', 'q']:
                 print("\n👋 Goodbye!")
                 break
-
-            if user_input.lower() == "reset":
+            
+            if user_input.lower() == 'reset':
                 agent.reset()
                 continue
-
+            
             agent.chat(user_input)
-
+            
         except KeyboardInterrupt:
             print("\n\n👋 Goodbye!")
             break

geomind/cli.py

@@ -32,36 +32,34 @@ Environment Variables:
   OPENROUTER_API_KEY    Your OpenRouter API key
   OPENROUTER_MODEL      Model to use (default: xiaomi/mimo-v2-flash:free)
   OPENROUTER_API_URL    API endpoint (default: https://openrouter.ai/api/v1)
-        """,
+        """
     )
 
     parser.add_argument(
-        "--query",
-        "-q",
+        "--query", "-q",
         type=str,
-        help="Single query to run (if not provided, starts interactive mode)",
+        help="Single query to run (if not provided, starts interactive mode)"
     )
     parser.add_argument(
-        "--model",
-        "-m",
+        "--model", "-m",
         type=str,
-        help="Model name to use (e.g., 'anthropic/claude-3.5-sonnet')",
+        help="Model name to use (e.g., 'anthropic/claude-3.5-sonnet')"
     )
     parser.add_argument(
-        "--api-key",
-        "-k",
+        "--api-key", "-k",
         type=str,
-        help="OpenRouter API key (or set OPENROUTER_API_KEY env variable)",
+        help="OpenRouter API key (or set OPENROUTER_API_KEY env variable)"
     )
     parser.add_argument(
-        "--version", "-v", action="store_true", help="Show version and exit"
+        "--version", "-v",
+        action="store_true",
+        help="Show version and exit"
     )
 
     args = parser.parse_args()
 
     if args.version:
         from . import __version__
-
         print(f"GeoMind version {__version__}")
         sys.exit(0)
 
@@ -104,11 +102,11 @@ def run_interactive(model: Optional[str] = None, api_key: Optional[str] = None):
             if not user_input:
                 continue
 
-            if user_input.lower() in ["quit", "exit", "q"]:
+            if user_input.lower() in ['quit', 'exit', 'q']:
                 print("\n👋 Goodbye!")
                 break
 
-            if user_input.lower() == "reset":
+            if user_input.lower() == 'reset':
                 agent.reset()
                 continue
 

geomind/tools/geocoding.py

@@ -14,22 +14,22 @@ from ..config import GEOCODER_USER_AGENT, DEFAULT_BUFFER_KM
 def geocode_location(place_name: str) -> dict:
     """
     Convert a place name to geographic coordinates.
-
+    
     Args:
         place_name: Name of the location (e.g., "New York", "Paris, France")
-
+        
     Returns:
         Dictionary with latitude, longitude, and full address
-
+        
     Example:
         >>> geocode_location("Central Park, New York")
         {'latitude': 40.7828, 'longitude': -73.9653, 'address': '...'}
     """
     geolocator = Nominatim(user_agent=GEOCODER_USER_AGENT, timeout=10)
     geocode = RateLimiter(geolocator.geocode, min_delay_seconds=1)
-
+    
     location = geocode(place_name)
-
+    
     if location is None:
         return {
             "success": False,
@@ -38,7 +38,7 @@ def geocode_location(place_name: str) -> dict:
             "longitude": None,
             "address": None,
         }
-
+    
     return {
         "success": True,
         "latitude": location.latitude,
@@ -47,55 +47,58 @@ def geocode_location(place_name: str) -> dict:
     }
 
 
-def get_bbox_from_location(place_name: str, buffer_km: Optional[float] = None) -> dict:
+def get_bbox_from_location(
+    place_name: str, 
+    buffer_km: Optional[float] = None
+) -> dict:
     """
     Convert a place name to a bounding box suitable for STAC queries.
-
+    
     Creates a square bounding box centered on the location with the
     specified buffer distance.
-
+    
     Args:
         place_name: Name of the location (e.g., "San Francisco")
         buffer_km: Buffer distance in kilometers (default: 10km)
-
+        
     Returns:
         Dictionary with bbox [min_lon, min_lat, max_lon, max_lat] and center point
-
+        
     Example:
         >>> get_bbox_from_location("London", buffer_km=5)
         {'bbox': [-0.17, 51.46, -0.08, 51.55], 'center': {...}}
     """
     if buffer_km is None:
         buffer_km = DEFAULT_BUFFER_KM
-
+        
     # Get coordinates
     location_result = geocode_location(place_name)
-
+    
     if not location_result["success"]:
         return {
             "success": False,
             "error": location_result["error"],
             "bbox": None,
         }
-
+    
     lat = location_result["latitude"]
     lon = location_result["longitude"]
-
+    
     # Calculate approximate degree offset
     # 1 degree latitude ≈ 111 km
     # 1 degree longitude ≈ 111 * cos(latitude) km
     import math
-
+    
     lat_offset = buffer_km / 111.0
     lon_offset = buffer_km / (111.0 * math.cos(math.radians(lat)))
-
+    
     bbox = [
         lon - lon_offset,  # min_lon (west)
         lat - lat_offset,  # min_lat (south)
         lon + lon_offset,  # max_lon (east)
         lat + lat_offset,  # max_lat (north)
     ]
-
+    
     return {
         "success": True,
         "bbox": bbox,

geomind/tools/processing.py

@@ -4,13 +4,14 @@ Image processing tools for Sentinel-2 data.
 Handles loading Zarr data, applying corrections, and creating visualizations.
 """
 
-from typing import Optional, List
+from typing import Optional, List, Tuple
 from pathlib import Path
 import numpy as np
 
 from ..config import (
     REFLECTANCE_SCALE,
     REFLECTANCE_OFFSET,
+    RGB_BANDS,
     OUTPUT_DIR,
 )
 
@@ -23,27 +24,27 @@ def _apply_scale_offset(
 ) -> np.ndarray:
     """
     Apply scale and offset to convert DN to surface reflectance.
-
+    
     Formula: reflectance = (DN * scale) + offset
-
+    
     Args:
         data: Raw digital number values
         scale: Scale factor (default: 0.0001)
         offset: Offset value (default: -0.1)
         nodata: NoData value to mask (default: 0)
-
+        
     Returns:
         Surface reflectance values
     """
     # Create mask for nodata
     mask = data == nodata
-
+    
     # Apply transformation
     result = (data.astype(np.float32) * scale) + offset
-
+    
     # Set nodata pixels to NaN
     result[mask] = np.nan
-
+    
     return result
 
 
@@ -54,37 +55,37 @@ def _normalize_for_display(
 ) -> np.ndarray:
     """
     Normalize data to 0-1 range for display using percentile stretch.
-
+    
     Args:
         data: Input array
         percentile_low: Lower percentile for clipping
         percentile_high: Upper percentile for clipping
-
+        
     Returns:
         Normalized array in 0-1 range
     """
     # Get valid (non-NaN) values
     valid = data[~np.isnan(data)]
-
+    
     if len(valid) == 0:
         return np.zeros_like(data)
-
+    
     # Calculate percentiles
     low = np.percentile(valid, percentile_low)
     high = np.percentile(valid, percentile_high)
-
+    
     # Normalize
     if high > low:
         result = (data - low) / (high - low)
     else:
         result = np.zeros_like(data)
-
+    
     # Clip to 0-1
     result = np.clip(result, 0, 1)
-
+    
     # Set NaN to 0 for display
     result = np.nan_to_num(result, nan=0)
-
+    
     return result
 
 
@@ -95,81 +96,78 @@ def create_rgb_composite(
 ) -> dict:
     """
     Create an RGB composite image from Sentinel-2 10m bands.
-
+    
     Uses B04 (Red), B03 (Green), B02 (Blue) bands.
-
+    
     Args:
         zarr_url: URL to the SR_10m Zarr asset
         output_path: Optional path to save the image
         subset_size: Size to subset the image (for faster processing)
-
+        
     Returns:
         Dictionary with path to saved image and metadata
     """
     try:
+        import xarray as xr
         import matplotlib.pyplot as plt
         import zarr
-
+        
         # Open the Zarr store
         # The SR_10m asset contains b02, b03, b04, b08
-        store = zarr.open(zarr_url, mode="r")
-
+        store = zarr.open(zarr_url, mode='r')
+        
         # Read the bands
         # Note: Band names are lowercase in the Zarr structure
-        red = np.array(store["b04"])
-        green = np.array(store["b03"])
-        blue = np.array(store["b02"])
-
+        red = np.array(store['b04'])
+        green = np.array(store['b03'])
+        blue = np.array(store['b02'])
+        
         # Subset if requested (for faster processing)
         if subset_size and red.shape[0] > subset_size:
             # Take center subset
             h, w = red.shape
             start_h = (h - subset_size) // 2
             start_w = (w - subset_size) // 2
-            red = red[start_h : start_h + subset_size, start_w : start_w + subset_size]
-            green = green[
-                start_h : start_h + subset_size, start_w : start_w + subset_size
-            ]
-            blue = blue[
-                start_h : start_h + subset_size, start_w : start_w + subset_size
-            ]
-
+            red = red[start_h:start_h+subset_size, start_w:start_w+subset_size]
+            green = green[start_h:start_h+subset_size, start_w:start_w+subset_size]
+            blue = blue[start_h:start_h+subset_size, start_w:start_w+subset_size]
+        
         # Apply scale and offset
         red = _apply_scale_offset(red)
         green = _apply_scale_offset(green)
         blue = _apply_scale_offset(blue)
-
+        
         # Normalize for display
         red = _normalize_for_display(red)
         green = _normalize_for_display(green)
         blue = _normalize_for_display(blue)
-
+        
         # Stack into RGB
         rgb = np.dstack([red, green, blue])
-
+        
         # Generate output path
         if output_path is None:
             output_path = OUTPUT_DIR / f"rgb_composite_{np.random.randint(10000)}.png"
         else:
             output_path = Path(output_path)
-
+        
         # Create figure
         fig, ax = plt.subplots(figsize=(10, 10))
         ax.imshow(rgb)
         ax.set_title("Sentinel-2 RGB Composite (B4/B3/B2)")
-        ax.axis("off")
-
+        ax.axis('off')
+        
         # Save
-        plt.savefig(output_path, dpi=150, bbox_inches="tight", pad_inches=0.1)
+        plt.savefig(output_path, dpi=150, bbox_inches='tight', pad_inches=0.1)
         plt.close(fig)
-
+        
         return {
             "success": True,
             "output_path": str(output_path),
             "image_size": rgb.shape[:2],
             "bands_used": ["B04 (Red)", "B03 (Green)", "B02 (Blue)"],
         }
-
+        
     except Exception as e:
         return {
             "success": False,
@@ -184,15 +182,15 @@ def calculate_ndvi(
 ) -> dict:
     """
     Calculate NDVI (Normalized Difference Vegetation Index) from Sentinel-2 data.
-
+    
     NDVI = (NIR - Red) / (NIR + Red)
     Uses B08 (NIR) and B04 (Red) bands.
-
+    
     Args:
         zarr_url: URL to the SR_10m Zarr asset
         output_path: Optional path to save the NDVI image
         subset_size: Size to subset the image
-
+        
     Returns:
         Dictionary with NDVI statistics and output path
     """
@@ -200,33 +198,33 @@ def calculate_ndvi(
         import zarr
         import matplotlib.pyplot as plt
         from matplotlib.colors import LinearSegmentedColormap
-
+        
         # Open the Zarr store
-        store = zarr.open(zarr_url, mode="r")
-
+        store = zarr.open(zarr_url, mode='r')
+        
         # Read the bands
-        nir = np.array(store["b08"])  # NIR
-        red = np.array(store["b04"])  # Red
-
+        nir = np.array(store['b08'])  # NIR
+        red = np.array(store['b04'])  # Red
+        
         # Subset if requested
         if subset_size and nir.shape[0] > subset_size:
             h, w = nir.shape
             start_h = (h - subset_size) // 2
             start_w = (w - subset_size) // 2
-            nir = nir[start_h : start_h + subset_size, start_w : start_w + subset_size]
-            red = red[start_h : start_h + subset_size, start_w : start_w + subset_size]
-
+            nir = nir[start_h:start_h+subset_size, start_w:start_w+subset_size]
+            red = red[start_h:start_h+subset_size, start_w:start_w+subset_size]
+        
         # Apply scale and offset
         nir = _apply_scale_offset(nir)
         red = _apply_scale_offset(red)
-
+        
         # Calculate NDVI
         # Avoid division by zero
         denominator = nir + red
         denominator[denominator == 0] = np.nan
-
+        
         ndvi = (nir - red) / denominator
-
+        
         # NDVI statistics
         valid_ndvi = ndvi[~np.isnan(ndvi)]
         stats = {
@@ -235,38 +233,38 @@ def calculate_ndvi(
             "mean": float(np.mean(valid_ndvi)) if len(valid_ndvi) > 0 else None,
             "std": float(np.std(valid_ndvi)) if len(valid_ndvi) > 0 else None,
         }
-
+        
         # Generate output path
         if output_path is None:
             output_path = OUTPUT_DIR / f"ndvi_{np.random.randint(10000)}.png"
         else:
             output_path = Path(output_path)
-
+        
         # Create NDVI colormap (brown -> yellow -> green)
-        colors = ["#8B4513", "#D2691E", "#FFD700", "#ADFF2F", "#228B22", "#006400"]
-        ndvi_cmap = LinearSegmentedColormap.from_list("ndvi", colors)
-
+        colors = ['#8B4513', '#D2691E', '#FFD700', '#ADFF2F', '#228B22', '#006400']
+        ndvi_cmap = LinearSegmentedColormap.from_list('ndvi', colors)
+        
         # Create figure
         fig, ax = plt.subplots(figsize=(10, 10))
         im = ax.imshow(ndvi, cmap=ndvi_cmap, vmin=-1, vmax=1)
         ax.set_title("NDVI - Normalized Difference Vegetation Index")
-        ax.axis("off")
-
+        ax.axis('off')
+        
         # Add colorbar
         cbar = plt.colorbar(im, ax=ax, shrink=0.8)
-        cbar.set_label("NDVI")
-
+        cbar.set_label('NDVI')
+        
         # Save
-        plt.savefig(output_path, dpi=150, bbox_inches="tight", pad_inches=0.1)
+        plt.savefig(output_path, dpi=150, bbox_inches='tight', pad_inches=0.1)
         plt.close(fig)
-
+        
         return {
             "success": True,
             "output_path": str(output_path),
             "statistics": stats,
             "interpretation": _interpret_ndvi(stats["mean"]) if stats["mean"] else None,
         }
-
+        
     except Exception as e:
         return {
             "success": False,
@@ -296,36 +294,36 @@ def get_band_statistics(
 ) -> dict:
     """
     Get statistics for specified bands from a Sentinel-2 Zarr asset.
-
+    
     Args:
         zarr_url: URL to the Zarr asset (e.g., SR_10m)
         bands: List of band names (default: all available)
-
+        
     Returns:
         Dictionary with statistics for each band
     """
     try:
         import zarr
-
-        store = zarr.open(zarr_url, mode="r")
-
+        
+        store = zarr.open(zarr_url, mode='r')
+        
         # Get available bands if not specified
         if bands is None:
-            bands = [key for key in store.keys() if key.startswith("b")]
-
+            bands = [key for key in store.keys() if key.startswith('b')]
+        
         results = {}
-
+        
         for band in bands:
             if band not in store:
                 results[band] = {"error": "Band not found"}
                 continue
-
+            
             data = np.array(store[band])
-
+            
             # Apply scale/offset
             data = _apply_scale_offset(data)
             valid = data[~np.isnan(data)]
-
+            
             if len(valid) > 0:
                 results[band] = {
                     "min": float(np.min(valid)),
@@ -336,12 +334,12 @@ def get_band_statistics(
                 }
             else:
                 results[band] = {"error": "No valid data"}
-
+        
         return {
             "success": True,
             "band_statistics": results,
         }
-
+        
     except Exception as e:
         return {
             "success": False,

geomind/tools/stac_search.py

@@ -24,7 +24,7 @@ def _get_stac_client() -> Client:
 def _format_item(item) -> dict:
     """Format a STAC item into a simplified dictionary."""
     props = item.properties
-
+    
     return {
         "id": item.id,
         "datetime": props.get("datetime"),
@@ -54,17 +54,17 @@ def search_imagery(
 ) -> dict:
     """
     Search for Sentinel-2 L2A imagery in the EOPF STAC catalog.
-
+    
     Args:
         bbox: Bounding box [min_lon, min_lat, max_lon, max_lat]
         start_date: Start date in YYYY-MM-DD format
         end_date: End date in YYYY-MM-DD format
         max_cloud_cover: Maximum cloud cover percentage (0-100)
         max_items: Maximum number of items to return
-
+        
     Returns:
         Dictionary with search results including items found
-
+        
     Example:
         >>> search_imagery(
         ...     bbox=[-74.0, 40.7, -73.9, 40.8],
@@ -77,48 +77,48 @@ def search_imagery(
         max_cloud_cover = DEFAULT_MAX_CLOUD_COVER
     if max_items is None:
         max_items = DEFAULT_MAX_ITEMS
-
+        
     # Build datetime string
     datetime_str = None
     if start_date or end_date:
         start = start_date or "2015-01-01"
         end = end_date or datetime.now().strftime("%Y-%m-%d")
         datetime_str = f"{start}/{end}"
-
+    
     try:
         client = _get_stac_client()
-
+        
         # Build search parameters
         search_params = {
             "collections": [STAC_COLLECTION],
             "max_items": max_items,
         }
-
+        
         if bbox:
             search_params["bbox"] = bbox
-
+            
         if datetime_str:
             search_params["datetime"] = datetime_str
-
+        
         # Execute search
         search = client.search(**search_params)
         items = list(search.items())
-
+        
         # Filter by cloud cover (post-filter since API may not support query param)
         filtered_items = [
-            item
-            for item in items
+            item for item in items
             if item.properties.get("eo:cloud_cover", 100) <= max_cloud_cover
         ]
-
+        
         # Sort by date (newest first)
         filtered_items.sort(
-            key=lambda x: x.properties.get("datetime", ""), reverse=True
+            key=lambda x: x.properties.get("datetime", ""),
+            reverse=True
         )
-
+        
         # Format results
         formatted_items = [_format_item(item) for item in filtered_items]
-
+        
         return {
             "success": True,
             "total_found": len(items),
@@ -130,7 +130,7 @@ def search_imagery(
                 "max_cloud_cover": max_cloud_cover,
             },
         }
-
+        
     except Exception as e:
         return {
             "success": False,
@@ -142,28 +142,30 @@ def search_imagery(
 def get_item_details(item_id: str) -> dict:
     """
     Get detailed information about a specific STAC item.
-
+    
     Args:
         item_id: The STAC item ID (e.g., "S2B_MSIL2A_20251218T110359_...")
-
+        
     Returns:
         Dictionary with full item details including all assets
     """
     try:
+        client = _get_stac_client()
+        collection = client.get_collection(STAC_COLLECTION)
+        
         # Get the item
         item_url = f"{STAC_API_URL}/collections/{STAC_COLLECTION}/items/{item_id}"
-
+        
         import requests
-
         response = requests.get(item_url)
         response.raise_for_status()
         item_data = response.json()
-
+        
         return {
             "success": True,
             "item": item_data,
         }
-
+        
     except Exception as e:
         return {
             "success": False,
@@ -179,28 +181,28 @@ def list_recent_imagery(
 ) -> dict:
     """
     List recent Sentinel-2 imagery, optionally for a specific location.
-
+    
     This is a convenience function that combines geocoding and search.
-
+    
     Args:
         location_name: Optional place name to search around
         days: Number of days to look back (default: 7)
         max_cloud_cover: Maximum cloud cover percentage
         max_items: Maximum items to return
-
+        
     Returns:
         Dictionary with recent imagery items
     """
     from .geocoding import get_bbox_from_location
-
+    
     # Calculate date range
     end_date = datetime.now()
     start_date = end_date - timedelta(days=days)
-
+    
     # Get bbox if location provided
     bbox = None
     location_info = None
-
+    
     if location_name:
         bbox_result = get_bbox_from_location(location_name)
         if bbox_result["success"]:
@@ -215,7 +217,7 @@ def list_recent_imagery(
                 "success": False,
                 "error": f"Could not geocode location: {location_name}",
             }
-
+    
     # Search for imagery
     result = search_imagery(
         bbox=bbox,
@@ -224,8 +226,8 @@ def list_recent_imagery(
         max_cloud_cover=max_cloud_cover,
         max_items=max_items,
     )
-
+    
     if location_info:
         result["location"] = location_info
-
+        
     return result

{geomind_ai-1.0.0.dist-info → geomind_ai-1.0.1.dist-info}/METADATA

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: geomind-ai
-Version: 1.0.0
-Summary: AI agent for geospatial analysis
+Version: 1.0.1
+Summary: AI agent for geospatial analysis with Sentinel-2 satellite imagery
 Author: Harsh Shinde
 License-Expression: MIT
-Project-URL: Homepage, https://harshshinde0.github.io/GeoMind/
+Project-URL: Homepage, https://github.com/HarshShinde0/GeoMind
 Project-URL: Repository, https://github.com/HarshShinde0/GeoMind
 Project-URL: Documentation, https://github.com/HarshShinde0/GeoMind#readme
 Project-URL: Issues, https://github.com/HarshShinde0/GeoMind/issues
@@ -36,27 +36,20 @@ Requires-Dist: numpy>=1.26.0
 Requires-Dist: python-dotenv>=1.0.0
 Dynamic: license-file
 
-### 1. Install Dependencies
+###  Install Dependencies
 
 ```bash
 pip install -r requirements.txt
 ```
 
-### 2. Set Up API Key
-
-Set your HuggingFace API key in the environment or update `config.py`:
-
-```python
-# In geomind/config.py
-HF_API_KEY = "your_huggingface_api_key"
-```
-
-Get a free API key from [HuggingFace](https://huggingface.co/settings/tokens).
-
-### 3. Run the Agent
+###  Run the Agent
 
 ```bash
-python main.py
+# Interactive mode
+geomind
+
+# Single query
+geomind --query "Find recent imagery of Paris"
 ```
 
 ## Example Queries

geomind_ai-1.0.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+geomind/__init__.py,sha256=jgrcaJGNFjwFADhRcgEfc7AUX1HkhTbJKqwjjxRUJH0,174
+geomind/agent.py,sha256=bp-nQa2go41vsI1vQKHQ9X6h08UDMBh6XEUVmQV3u5U,15696
+geomind/cli.py,sha256=gBNwUXFXJyWX5z3kIC6YFBoUPo7iQCp-LXnVnQZFU5k,3393
+geomind/config.py,sha256=E97f1yooN2NqUlREPhO3RKFQXwnvLUrTAdxuqjH6RCk,2066
+geomind/tools/__init__.py,sha256=C_7XGAMNkoapEpQ-5wkrMlskb_Nhew-VUjVZaYQo_Ks,747
+geomind/tools/geocoding.py,sha256=1cbEdLug4E4eoqpeLUnZhlgAnGGxEpBl3sIJXbtqFtE,3217
+geomind/tools/processing.py,sha256=t-TSdnaQ_Za9_nqwbqMdqm_10gGDc8_4GpGWxIRyUv8,10615
+geomind/tools/stac_search.py,sha256=dOHdUiK5SAOD-rFjARNzNPEYJBtM3OR4M7z2HjL_5xo,6884
+geomind_ai-1.0.1.dist-info/licenses/LICENSE,sha256=wVJsn_q_iEJVaeb9LpHj1v5Ljg14FkTR-AhRPQqwj_g,1090
+geomind_ai-1.0.1.dist-info/METADATA,sha256=35300Ii3nfZr9Txv_oTQ0L2S1-jOJo56NDA0CheCXio,2311
+geomind_ai-1.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+geomind_ai-1.0.1.dist-info/entry_points.txt,sha256=2nPR3faYKl0-1epccvzMJ2xdi-Q1Vt7aOSvA84oIWnw,45
+geomind_ai-1.0.1.dist-info/top_level.txt,sha256=rjKWNSNRhq4R9xJoZGsG-eAaH7BmTVNvfrrbcaJMIIs,8
+geomind_ai-1.0.1.dist-info/RECORD,,

geomind_ai-1.0.0.dist-info/RECORD

@@ -1,14 +0,0 @@
-geomind/__init__.py,sha256=ID2iX-nI4mf0RqErFeJm2buXYowD1EMDW-zk2lxNBA0,162
-geomind/agent.py,sha256=Go4ilgUXYLSWMNxAe_zYT-hB6lMJWkD2LUsPGrR-y5I,15816
-geomind/cli.py,sha256=Xu83Mn3rT4CpeHYCKPts3Kl-Y7XDLXVmjH_7hZd8QaY,3408
-geomind/config.py,sha256=E97f1yooN2NqUlREPhO3RKFQXwnvLUrTAdxuqjH6RCk,2066
-geomind/tools/__init__.py,sha256=C_7XGAMNkoapEpQ-5wkrMlskb_Nhew-VUjVZaYQo_Ks,747
-geomind/tools/geocoding.py,sha256=0tHschi3jSwyWPzkxNtrw6ziZwUxMtiElElsnRVcsYQ,3115
-geomind/tools/processing.py,sha256=3-sydyOfvjkz_-B9cEATAqcSEv4EXVR3bIA42H-eIv0,10275
-geomind/tools/stac_search.py,sha256=KpznD91Z6WlhC3JAjl0i1IQ3AnF-wWoiyvymy8xRKJw,6586
-geomind_ai-1.0.0.dist-info/licenses/LICENSE,sha256=wVJsn_q_iEJVaeb9LpHj1v5Ljg14FkTR-AhRPQqwj_g,1090
-geomind_ai-1.0.0.dist-info/METADATA,sha256=3mHcocB4-vFl2HHZa8ptX8mVGxtoJ_zRcuvFR8jPdvU,2466
-geomind_ai-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-geomind_ai-1.0.0.dist-info/entry_points.txt,sha256=2nPR3faYKl0-1epccvzMJ2xdi-Q1Vt7aOSvA84oIWnw,45
-geomind_ai-1.0.0.dist-info/top_level.txt,sha256=rjKWNSNRhq4R9xJoZGsG-eAaH7BmTVNvfrrbcaJMIIs,8
-geomind_ai-1.0.0.dist-info/RECORD,,