Upload 8 files

README.md

@@ -1,12 +1,109 @@
+# Plant Identifier – Hyderabad Locator (Python)
+
+This project lets you:
+1. Upload a **plant JPG** photo.
+2. Identify the plant using the **Plant.id API** (AI model).
+3. Show **where the plant has been observed in Hyderabad** (using the iNaturalist public API) and plot it on an interactive map.
+
+It ships with a **Streamlit UI** (`streamlit_app.py`) so you can run everything locally in a few minutes.
+
 ---
-title: Rishiproject
-emoji: 🏢
-colorFrom: red
-colorTo: blue
-sdk: gradio
-sdk_version: 5.42.0
-app_file: app.py
-pinned: false
+
+## Features
+- 📷 Image upload (JPG/JPEG/PNG) via Streamlit
+- 🤖 AI recognition via **Plant.id** (top matches with confidence, scientific name, common names, wiki details when available)
+- 📍 Hyderabad occurrences via **iNaturalist** (observations plotted on a Folium map)
+- 🗺️ Interactive map embedded in the app
+- 🔑 `.env` support for secrets
+
+> **Note**: You need a free or paid **Plant.id** API key. Create an account at plant.id and copy your key into `.env` as `PLANT_ID_API_KEY`.
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## File structure
+
+```
+plant-identifier-hyd/
+├─ app/
+│  ├─ streamlit_app.py        # Streamlit UI
+│  ├─ plant_id_client.py      # Plant.id API client
+│  ├─ location.py             # Hyderabad bbox + iNaturalist search
+│  ├─ utils.py                # Helpers (image, env)
+│  └─ static/
+│     └─ styles.css           # Optional extra styles for Streamlit
+├─ data/
+│  └─ sample_images/          # Put example photos here
+├─ tests/
+│  └─ test_smoke.py           # Minimal smoke test
+├─ .env.example               # Copy to .env and fill in your API key
+├─ requirements.txt
+└─ README.md
+```
+
+---
+
+## Quickstart
+
+1) **Clone or unzip** this folder.
+2) Create a virtual environment (recommended):
+```bash
+python -m venv .venv
+source .venv/bin/activate  # Windows: .venv\Scripts\activate
+```
+3) **Install dependencies**:
+```bash
+pip install -r requirements.txt
+```
+4) **Set your API key**: copy `.env.example` to `.env` and put your Plant.id key.
+5) **Run the app**:
+```bash
+streamlit run app/streamlit_app.py
+```
+6) Open the printed local URL in your browser.
+
+---
+
+## How it works
+
+### Plant identification
+We send the uploaded image to **Plant.id** (`/v3/identification`) and request the top candidates. We show:
+- scientific name
+- common names
+- confidence score
+- a short description if available
+
+### Hyderabad locations
+We query **iNaturalist** for recent observations within a Hyderabad bounding box. We then plot markers on a **Folium** map and embed it in Streamlit.
+
+> The map shows where people have reported observing the plant in Hyderabad. This does not guarantee the plant is wild there; it simply shows community observations.
+
+---
+
+## Environment variables
+
+Create a `.env` file in the project root:
+
+```
+PLANT_ID_API_KEY=your_plant_id_api_key_here
+```
+
+---
+
+## Notes & Limits
+- API quotas apply (Plant.id & iNaturalist).
+- Identification quality depends on your photo (focus, lighting, background).
+- iNaturalist observations depend on community contributions—some plants may have few or no reports in the Hyderabad area.
+
+---
+
+## Testing
+
+```bash
+pytest -q
+```
+
+---
+
+## License
+
+MIT. For learning and non-commercial demo use. Check Plant.id and iNaturalist terms of service for production use.

app/location.py

@@ -0,0 +1,46 @@
+import requests
+from typing import Dict, Any, List, Tuple
+
+# Rough bounding box for Hyderabad, India (approximate)
+# swlat, swlng (bottom-left) and nelat, nelng (top-right)
+HYD_BBOX = (17.200, 78.200, 17.650, 78.650)
+
+INAT_ENDPOINT = "https://api.inaturalist.org/v1/observations"
+
+def hyderabad_bbox() -> Tuple[float, float, float, float]:
+    return HYD_BBOX
+
+def find_observations_in_hyd(taxon_name: str, per_page: int = 30) -> List[Dict[str, Any]]:
+    swlat, swlng, nelat, nelng = HYD_BBOX
+    params = {
+        "taxon_name": taxon_name,
+        "swlat": swlat,
+        "swlng": swlng,
+        "nelat": nelat,
+        "nelng": nelng,
+        "order": "desc",
+        "order_by": "created_at",
+        "per_page": per_page,
+    }
+    r = requests.get(INAT_ENDPOINT, params=params, timeout=30)
+    r.raise_for_status()
+    data = r.json()
+    return data.get("results", [])
+
+def observations_to_markers(observations: List[Dict[str, Any]]):
+    markers = []
+    for o in observations:
+        coords = o.get("geojson", {}).get("coordinates")
+        if not coords or len(coords) != 2:
+            # fallback
+            lat = o.get("location", ",").split(",")[0] if o.get("location") else None
+            lng = o.get("location", ",").split(",")[1] if o.get("location") else None
+            if lat and lng:
+                try:
+                    markers.append((float(lat), float(lng), o))
+                except Exception:
+                    continue
+            continue
+        lng, lat = coords  # iNat stores as [lng, lat]
+        markers.append((lat, lng, o))
+    return markers

app/plant_id_client.py

@@ -0,0 +1,46 @@
+import requests
+from typing import Dict, Any, List, Optional
+
+PLANT_ID_ENDPOINT = "https://api.plant.id/v3/identification"
+
+class PlantIdClient:
+    def __init__(self, api_key: str):
+        self.api_key = api_key
+        self.headers = {"Api-Key": self.api_key, "Content-Type": "application/json"}
+
+    def identify(self, images_b64: List[str], latitude: Optional[float] = None, longitude: Optional[float] = None) -> Dict[str, Any]:
+        payload = {
+            "images": images_b64,
+            "modifiers": ["crops_fast", "similar_images"],
+            "plant_details": [
+                "common_names",
+                "url",
+                "name_authority",
+                "wiki_description",
+                "taxonomy",
+                "synonyms"
+            ],
+        }
+        if latitude is not None and longitude is not None:
+            payload["latitude"] = latitude
+            payload["longitude"] = longitude
+
+        resp = requests.post(PLANT_ID_ENDPOINT, headers=self.headers, json=payload, timeout=60)
+        resp.raise_for_status()
+        return resp.json()
+
+    @staticmethod
+    def parse_top_candidates(result_json: Dict[str, Any]) -> List[Dict[str, Any]]:
+        suggestions = result_json.get("result", {}).get("classification", {}).get("suggestions", [])
+        out = []
+        for s in suggestions:
+            plant = s.get("plant", {})
+            details = plant.get("details", {})
+            out.append({
+                "scientific_name": plant.get("scientific_name"),
+                "common_names": details.get("common_names", []),
+                "probability": s.get("probability"),
+                "wiki": (details.get("wiki_description", {}) or {}).get("value"),
+                "url": details.get("url"),
+            })
+        return out

app/static/styles.css

@@ -0,0 +1 @@
+/* Optional extra styles for Streamlit components */

app/streamlit_app.py

@@ -0,0 +1,97 @@
+import os
+import streamlit as st
+from streamlit_folium import st_folium
+import folium
+
+from app.utils import load_image, image_to_base64_jpeg, get_env
+from app.plant_id_client import PlantIdClient
+from app.location import find_observations_in_hyd, observations_to_markers, hyderabad_bbox
+
+st.set_page_config(page_title="Plant Identifier – Hyderabad Locator", page_icon="🌿", layout="wide")
+
+st.title("🌿 Plant Identifier – Hyderabad Locator")
+st.write("Upload a plant photo, identify it with AI, and see where it was observed in Hyderabad.")
+
+with st.sidebar:
+    st.header("Settings")
+    api_key = st.text_input("Plant.id API Key", value=get_env("PLANT_ID_API_KEY"), type="password")
+    st.caption("You can also put this in a `.env` file as `PLANT_ID_API_KEY`.")
+    st.divider()
+    st.markdown("**Tip:** Better results with a clear leaf/flower close-up, good lighting, and neutral background.")
+
+uploaded = st.file_uploader("Upload a plant photo (JPG/PNG)", type=["jpg", "jpeg", "png"])
+
+if uploaded and api_key:
+    image = load_image(uploaded)
+    st.image(image, caption="Uploaded image", use_column_width=True)
+
+    b64 = image_to_base64_jpeg(image)
+    client = PlantIdClient(api_key)
+
+    with st.spinner("Identifying plant via Plant.id..."):
+        try:
+            result = client.identify([b64])
+        except Exception as e:
+            st.error(f"Plant.id API error: {e}")
+            st.stop()
+
+    candidates = client.parse_top_candidates(result)
+    if not candidates:
+        st.warning("No candidates returned. Try a clearer image.")
+        st.stop()
+
+    st.subheader("Top Matches")
+    top = None
+    for idx, c in enumerate(candidates, start=1):
+        with st.expander(f"{idx}. {c['scientific_name']} (confidence: {c['probability']:.2%})", expanded=(idx == 1)):
+            if idx == 1:
+                top = c
+            st.write("**Scientific name:**", c["scientific_name"] or "—")
+            st.write("**Common names:**", ", ".join(c["common_names"]) if c["common_names"] else "—")
+            if c["wiki"]:
+                st.write("**About:**", c["wiki"])
+            if c["url"]:
+                st.write(f"[More details]({c['url']})")
+
+    # Map Hyderabad occurrences for the top candidate
+    if top and top.get("scientific_name"):
+        st.subheader(f"📍 Observations in Hyderabad: {top['scientific_name']}")
+
+        with st.spinner("Fetching observations from iNaturalist..."):
+            try:
+                observations = find_observations_in_hyd(top["scientific_name"], per_page=100)
+            except Exception as e:
+                st.error(f"iNaturalist API error: {e}")
+                observations = []
+
+        markers = observations_to_markers(observations)
+        swlat, swlng, nelat, nelng = hyderabad_bbox()
+
+        # Create a Folium map centered roughly in Hyderabad
+        center_lat = (swlat + nelat) / 2.0
+        center_lng = (swlng + nelng) / 2.0
+        fmap = folium.Map(location=[center_lat, center_lng], zoom_start=11)
+
+        for lat, lng, o in markers:
+            popup_lines = []
+            if o.get("species_guess"):
+                popup_lines.append(f"<b>{o['species_guess']}</b>")
+            if o.get("observed_on"):
+                popup_lines.append(f"Date: {o['observed_on']}")
+            if o.get("place_guess"):
+                popup_lines.append(f"Place: {o['place_guess']}")
+            popup_html = "<br/>".join(popup_lines) if popup_lines else "iNaturalist observation"
+            folium.Marker([lat, lng], popup=popup_html).add_to(fmap)
+
+        # draw bbox
+        folium.Rectangle(
+            bounds=[[swlat, swlng], [nelat, nelng]],
+            fill=False
+        ).add_to(fmap)
+
+        st_map = st_folium(fmap, width=1000, height=600)
+
+        st.caption("Map shows iNaturalist community observations within a Hyderabad bounding box.")
+
+else:
+    st.info("Enter your Plant.id API key in the sidebar and upload an image to begin.")

app/utils.py

@@ -0,0 +1,20 @@
+import base64
+import os
+from io import BytesIO
+from PIL import Image
+from dotenv import load_dotenv
+
+load_dotenv()
+
+def get_env(key: str, default: str = "") -> str:
+    return os.getenv(key, default)
+
+def image_to_base64_jpeg(image: Image.Image) -> str:
+    """Convert a PIL image to base64-encoded JPEG string."""
+    buf = BytesIO()
+    image = image.convert("RGB")
+    image.save(buf, format="JPEG", quality=90)
+    return base64.b64encode(buf.getvalue()).decode("utf-8")
+
+def load_image(file) -> Image.Image:
+    return Image.open(file)

requirements.txt

@@ -0,0 +1,6 @@
+streamlit
+requests
+python-dotenv
+Pillow
+folium
+streamlit-folium

tests/test_smoke.py

@@ -0,0 +1,4 @@
+def test_imports():
+    import app.utils
+    import app.plant_id_client
+    import app.location