Upload folder using huggingface_hub

modules/classifier.py

@@ -0,0 +1,34 @@
+import os
+
+import torch
+from PIL import Image
+from transformers import AutoImageProcessor, AutoModelForImageClassification
+
+CLASSIFIER_MODEL_ID = os.getenv("CLASSIFIER_MODEL_ID", "your-username/plant-genus-classifier")
+
+_processor = None
+_model = None
+
+
+def _load():
+    global _processor, _model
+    if _model is None:
+        _processor = AutoImageProcessor.from_pretrained(CLASSIFIER_MODEL_ID)
+        _model = AutoModelForImageClassification.from_pretrained(CLASSIFIER_MODEL_ID)
+        _model.eval()
+    return _processor, _model
+
+
+def classify_plant(image: Image.Image) -> tuple[str, float]:
+    """Run the fine-tuned genus classifier on an uploaded image.
+
+    Returns:
+        (genus_name, confidence_score)
+    """
+    processor, model = _load()
+    inputs = processor(images=image.convert("RGB"), return_tensors="pt")
+    with torch.no_grad():
+        logits = model(**inputs).logits
+    probs = torch.softmax(logits, dim=-1)
+    top_id = int(probs.argmax(dim=-1))
+    return model.config.id2label[top_id], probs[0, top_id].item()

modules/pixel_art.py

@@ -0,0 +1,214 @@
+"""Procedural pixel-art sprites for plants and the app favicon.
+
+Each sprite is built from a 16x16 grid: a 10-row plant "archetype" stacked on
+top of a 6-row pot. Rows are authored as 8-character halves and mirrored
+(`half + half[::-1]`) to get a symmetric 16-wide row, then the whole grid is
+upscaled with nearest-neighbour resizing for a crisp pixel-art look.
+"""
+
+import functools
+from pathlib import Path
+
+import pandas as pd
+from PIL import Image
+
+GROWTH_CSV = "data/growth_csv/growth_ds.csv"
+STATIC_DIR = Path("static")
+SPRITES_DIR = STATIC_DIR / "sprites"
+FAVICON_PATH = STATIC_DIR / "favicon.png"
+
+# ── Palette ──────────────────────────────────────────────────────────────────
+PALETTE = {
+    ".": (0, 0, 0, 0),
+    "G": (46, 125, 50, 255),    # dark leaf green
+    "g": (102, 187, 106, 255),  # mid green
+    "l": (197, 225, 165, 255),  # light green / highlight
+    "y": (255, 213, 79, 255),   # yellow flower
+    "o": (255, 152, 0, 255),    # orange flower center
+    "t": (121, 85, 72, 255),    # trunk brown
+    "S": (109, 76, 65, 255),    # soil
+}
+
+POT_STYLES = {
+    "terracotta":   {"P": (216, 124, 90, 255), "Q": (173, 96, 68, 255),  "R": (235, 165, 138, 255)},
+    "white":        {"P": (245, 245, 245, 255), "Q": (210, 210, 210, 255), "R": (255, 255, 255, 255)},
+    "ceramic_blue": {"P": (84, 153, 199, 255), "Q": (55, 109, 148, 255), "R": (165, 214, 237, 255)},
+    "charcoal":     {"P": (74, 74, 74, 255),   "Q": (45, 45, 45, 255),   "R": (115, 115, 115, 255)},
+}
+POT_NAMES = list(POT_STYLES.keys())
+
+# ── Plant archetypes (10 half-rows, 8 chars each) ───────────────────────────
+PLANT_SPRITES = {
+    "cactus": [
+        "........",
+        "........",
+        "......gg",
+        "......gG",
+        "..gg..gG",
+        "..gG..gG",
+        "..gg..gG",
+        "......gG",
+        "......gg",
+        "......gl",
+    ],
+    "succulent": [
+        "........",
+        ".......l",
+        "......gl",
+        ".....Ggl",
+        "....gGgl",
+        "...ggGgl",
+        "..gggGgl",
+        ".ggggGgl",
+        "ggggggGl",
+        "gggggggl",
+    ],
+    "fern": [
+        "........",
+        "...gGg..",
+        "..glGgl.",
+        ".gGglGg.",
+        "gGlgGgl.",
+        "gglGglg.",
+        ".gGlGg..",
+        "...g.g..",
+        "....g...",
+        "....gg..",
+    ],
+    "flower": [
+        "......y.",
+        ".....yoy",
+        "......y.",
+        ".......g",
+        "..g....g",
+        ".gG....g",
+        "..g....g",
+        ".......g",
+        ".......g",
+        "......gg",
+    ],
+    "palm": [
+        "..l...l.",
+        ".gg...gg",
+        "..gGGg..",
+        "...g.g..",
+        ".......t",
+        ".......t",
+        ".......t",
+        ".......t",
+        "......tt",
+        "......tt",
+    ],
+    "trailing": [
+        "........",
+        ".gGggGl.",
+        "gGggGgl.",
+        "Gggggl..",
+        "gl......",
+        "Gl......",
+        "gl......",
+        "Gl......",
+        "gl......",
+        "gl......",
+    ],
+}
+ARCHETYPES = list(PLANT_SPRITES.keys())
+
+# ── Pot (6 half-rows, 8 chars each) ─────────────────────────────────────────
+POT_BASE = [
+    "...SSSSS",
+    "..RPPPPP",
+    "..QPPPPP",
+    "...QPPPP",
+    "....QPPP",
+    ".....QPP",
+]
+
+
+# ── Genus -> (archetype, pot) mapping ───────────────────────────────────────
+@functools.lru_cache(maxsize=1)
+def _growth_table() -> pd.DataFrame:
+    return pd.read_csv(GROWTH_CSV)
+
+
+def _stable_hash(text: str) -> int:
+    """Deterministic hash (stable across runs, unlike builtin hash() for str)."""
+    h = 0
+    for ch in text:
+        h = (h * 31 + ord(ch)) & 0xFFFFFFFF
+    return h
+
+
+def genus_to_sprite_key(genus: str) -> tuple[str, str]:
+    """Map a genus to a deterministic (plant archetype, pot style) pair."""
+    df = _growth_table()
+    row = df[df["Genus"] == genus]
+
+    if row.empty:
+        h = _stable_hash(genus)
+        archetype = ARCHETYPES[h % len(ARCHETYPES)]
+        pot = POT_NAMES[(h // len(ARCHETYPES)) % len(POT_NAMES)]
+        return archetype, pot
+
+    growth = str(row["Growth"].iloc[0]).lower()
+    soil = str(row["Soil"].iloc[0]).lower()
+    sunlight = str(row["Sunlight"].iloc[0]).lower()
+
+    if "sandy" in soil and "full" in sunlight:
+        archetype = "cactus" if growth == "slow" else "succulent"
+    elif "indirect" in sunlight and growth in ("slow", "moderate"):
+        archetype = "fern" if ("well-drained" in soil or "loamy" in soil) else "trailing"
+    elif growth == "fast" and "full" in sunlight:
+        archetype = "flower"
+    elif growth == "slow" and "well-drained" in soil:
+        archetype = "palm"
+    else:
+        archetype = "fern"
+
+    pot = {"sandy": "terracotta", "well-drained": "white", "loamy": "charcoal"}.get(soil, "ceramic_blue")
+    return archetype, pot
+
+
+# ── Rendering ────────────────────────────────────────────────────────────────
+def _build_image(half_rows: list[str], palette: dict) -> Image.Image:
+    rows = [half + half[::-1] for half in half_rows]
+    size = len(rows)
+    img = Image.new("RGBA", (size, size), (0, 0, 0, 0))
+    for y, row in enumerate(rows):
+        for x, ch in enumerate(row):
+            img.putpixel((x, y), palette.get(ch, (0, 0, 0, 0)))
+    return img
+
+
+def render_sprite(genus: str, scale: int = 8) -> Image.Image:
+    """Render the pixel-art (plant + pot) sprite for a genus."""
+    archetype, pot_style = genus_to_sprite_key(genus)
+    half_rows = PLANT_SPRITES[archetype] + POT_BASE
+    palette = {**PALETTE, **POT_STYLES[pot_style]}
+    img = _build_image(half_rows, palette)
+    return img.resize((img.width * scale, img.height * scale), Image.NEAREST)
+
+
+def _slugify(genus: str) -> str:
+    return "".join(ch.lower() if ch.isalnum() else "_" for ch in genus)
+
+
+def get_sprite_path(genus: str) -> str:
+    """Return the path to the (lazily rendered + cached) sprite for a genus."""
+    SPRITES_DIR.mkdir(parents=True, exist_ok=True)
+    path = SPRITES_DIR / f"{_slugify(genus)}.png"
+    if not path.exists():
+        render_sprite(genus).save(path)
+    return str(path)
+
+
+def ensure_favicon() -> str:
+    """Return the path to the (lazily rendered + cached) app favicon."""
+    STATIC_DIR.mkdir(parents=True, exist_ok=True)
+    if not FAVICON_PATH.exists():
+        half_rows = PLANT_SPRITES["fern"] + POT_BASE
+        palette = {**PALETTE, **POT_STYLES["terracotta"]}
+        img = _build_image(half_rows, palette)
+        img = img.resize((img.width * 4, img.height * 4), Image.NEAREST)
+        img.save(FAVICON_PATH)
+    return str(FAVICON_PATH)

modules/plant.py

@@ -0,0 +1,59 @@
+import pandas as pd
+class Plant:
+    def __init__(self, genus):
+        self.genus = genus
+        self.db_path = './data/growth_csv/growth_ds.csv'
+        self.watering_frequency = self.get_watering_frequency()
+        self.plant_name = self.get_plant_name()
+        self.sunlight = self.get_sunlight_requirements()
+        self.soil_type = self.get_soil_type()
+        self.fertilization_type = self.get_fertilization_type()
+        self.last_watered = None  # Track the last watered date
+        
+
+    def __str__(self):
+        return f"Plant(genus={self.genus}, plant_name={self.plant_name}, watering_frequency={self.watering_frequency}, sunlight={self.sunlight}, soil_type={self.soil_type}, fertilization_type={self.fertilization_type})"
+
+    def get_watering_frequency(self):
+        # import csv
+        growth_csv = pd.read_csv(self.db_path)
+        plant_data = growth_csv[growth_csv['Genus'] == self.genus]
+        if not plant_data.empty:
+            return plant_data['Watering'].iloc[0]
+        
+        return None  # Return None if no data found for the genus
+    
+    def get_plant_name(self):
+        # import csv
+        growth_csv = pd.read_csv(self.db_path)
+        plant_data = growth_csv[growth_csv['Genus'] == self.genus]
+        if not plant_data.empty:
+            return plant_data['Plant Name'].iloc[0]
+        return None  # Return None if no data found for the genus
+    
+    def get_sunlight_requirements(self):
+        # import csv
+        growth_csv = pd.read_csv(self.db_path)
+        plant_data = growth_csv[growth_csv['Genus'] == self.genus]
+        if not plant_data.empty:
+            return plant_data['Sunlight'].iloc[0]
+        return None  # Return None if no data found for the genus
+    
+    def get_soil_type(self):
+        # import csv
+        growth_csv = pd.read_csv(self.db_path)
+        plant_data = growth_csv[growth_csv['Genus'] == self.genus]
+        if not plant_data.empty:
+            return plant_data['Soil'].iloc[0]
+        return None  # Return None if no data found for the genus
+    
+    def get_fertilization_type(self):
+        # import csv
+        growth_csv = pd.read_csv(self.db_path)
+        plant_data = growth_csv[growth_csv['Genus'] == self.genus]
+        if not plant_data.empty:
+            return plant_data['Fertilization Type'].iloc[0]
+        return None  # Return None if no data found for the genus
+    
+    def set_last_watered(self, date):
+        self.last_watered = date

modules/recommender.py

@@ -0,0 +1,50 @@
+import os
+
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+RECOMMENDER_MODEL_ID = os.getenv("RECOMMENDER_MODEL_ID", "your-username/plant-care-recommender")
+
+_tokenizer = None
+_model = None
+
+
+def _load():
+    global _tokenizer, _model
+    if _model is None:
+        _tokenizer = AutoTokenizer.from_pretrained(RECOMMENDER_MODEL_ID)
+        _model = AutoModelForCausalLM.from_pretrained(RECOMMENDER_MODEL_ID)
+        _model.eval()
+    return _tokenizer, _model
+
+
+def generate_care_notes(plant_info: dict, plant_name: str | None = None, genus: str | None = None) -> str:
+    """Generate natural-language care tips for a plant.
+
+    Args:
+        plant_info: Care metadata (watering_frequency_days, sunlight, soil, fertilization_type).
+        plant_name: Common plant name, if known.
+        genus: Genus name, if known.
+
+    Returns:
+        Generated care notes.
+    """
+    tokenizer, model = _load()
+
+    subject = plant_name or genus or "this plant"
+    messages = [{"role": "user", "content": f"Give me care tips for {subject}."}]
+    inputs = tokenizer.apply_chat_template(
+        messages, add_generation_prompt=True, return_tensors="pt", return_dict=True
+    )
+
+    with torch.no_grad():
+        output = model.generate(
+            **inputs,
+            max_new_tokens=200,
+            do_sample=True,
+            temperature=0.7,
+            pad_token_id=tokenizer.eos_token_id,
+        )
+
+    response = tokenizer.decode(output[0, inputs["input_ids"].shape[-1]:], skip_special_tokens=True)
+    return response.strip()

modules/test.ipynb

@@ -0,0 +1,45 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "e05bbcd8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Plant(genus=Ficus, plant_name=Rubber Plant, watering_frequency=Water when soil feels dry, sunlight=indirect sunlight, soil_type=well-drained, fertilization_type=Balanced)\n"
+     ]
+    }
+   ],
+   "source": [
+    "from plant import Plant\n",
+    "p = Plant(\"Ficus\")\n",
+    "print(p)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.14.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

modules/watering.py

@@ -0,0 +1,119 @@
+import datetime
+import re
+ 
+from modules.plant import Plant
+from modules.weather_utils import did_or_will_rain, weather_values
+ 
+ 
+# ── 1. Watering frequency parser ───────────────────────────────────────────────
+ 
+_RECOMMENDATION_MAP: dict[str, int] = {
+    # ── Fixed cadence ──────────────────────────────────────────────────────
+    "water weekly":                   7,
+    # ── Always moist ──────────────────────────────────────────────────────
+    "keep soil moist":                2,
+    "keep soil consistently moist":   2,
+    "keep soil evenly moist":         2,
+    "keep soil slightly moist":       3,
+    "regular, moist soil":            3,
+    # ── Regular ───────────────────────────────────────────────────────────
+    "regular watering":               4,
+    "regular, well-drained soil":     4,
+    # ── Water when dry ────────────────────────────────────────────────────
+    "water when soil is dry":         5,
+    "water when topsoil is dry":      5,
+    "water when soil feels dry":      5,
+    "let soil dry between watering":  7,
+}
+ 
+_FALLBACK_RULES: list[tuple[str, int | None]] = [
+    (r"daily",                                              1),
+    (r"twice.{0,10}week",                                   3),
+    (r"every\s+(\d+)\s+day",                                None),  # extracted dynamically
+    (r"once.{0,10}week|weekly",                             7),
+    (r"once.{0,10}fortnight|every.{0,6}two.{0,6}week",    14),
+    (r"monthly",                                           30),
+    (r"moist",                                              2),
+    (r"dry",                                                6),
+    (r"regular",                                            4),
+]
+ 
+DEFAULT_INTERVAL = 4
+ 
+
+def _parse_watering_frequency(recommendation: str) -> int:
+    """Map a free-text watering recommendation to a watering interval in days.
+ 
+    Args:
+        recommendation: e.g. "Water weekly", "Keep soil moist"
+ 
+    Returns:
+        Watering interval in days (>= 1).
+    """
+    if not recommendation or not recommendation.strip():
+        return DEFAULT_INTERVAL
+ 
+    cleaned = recommendation.strip().lower()
+ 
+    if cleaned in _RECOMMENDATION_MAP:
+        return _RECOMMENDATION_MAP[cleaned]
+ 
+    for key, days in _RECOMMENDATION_MAP.items():
+        if cleaned.startswith(key) or key.startswith(cleaned):
+            return days
+ 
+    for pattern, days in _FALLBACK_RULES:
+        m = re.search(pattern, cleaned)
+        if m:
+            if days is None:
+                try:
+                    return max(1, int(m.group(1)))
+                except (IndexError, ValueError):
+                    return DEFAULT_INTERVAL
+            return days
+ 
+    return DEFAULT_INTERVAL
+ 
+
+
+def get_watering_frequency(plant: Plant) -> int:
+    """Determine the watering frequency for a plant, in days.
+ 
+    Args:
+        plant: The plant to determine the watering frequency for.
+ 
+    Returns:
+        Watering frequency in days (>= 1).
+    """
+    if plant.watering_frequency:
+        return _parse_watering_frequency(plant.watering_frequency)
+ 
+    return DEFAULT_INTERVAL
+
+
+def should_water(plant: Plant,last_watered: datetime.date | None, date: datetime.date, LAT: float, LON: float) -> bool:
+    """Determine if a plant should be watered on a given date.
+    # returns true if its not raining and the plant wasnt watered since the last watering frequency interval
+ 
+    Args:
+        plant: The plant to check.
+        last_watered: The date the plant was last watered.
+        date: The date to check for.
+        LAT: The latitude of the plant's location.
+        LON: The longitude of the plant's location.
+    """
+    if last_watered is None:
+        return True
+ 
+    frequency = get_watering_frequency(plant)
+    # convert last_watered to datetime.date if it's a string
+    if isinstance(last_watered, str):
+        last_watered = datetime.datetime.strptime(last_watered, "%Y-%m-%d").date()
+        
+    next_watering_date = last_watered + datetime.timedelta(days=frequency)
+ 
+    if date >= next_watering_date and not did_or_will_rain(date, LAT, LON, forecast_threshold=50):
+        return True
+ 
+
+    return False

modules/weather.py

@@ -0,0 +1,8 @@
+class Weather:
+    def __init__(self, temp_max: int = None, temp_min: int = None, precipitation: float = None, precipitation_probability: int = None, wind_speed: float = None, comment: str = None):
+        self.temp_max : int = temp_max
+        self.temp_min : int = temp_min
+        self.precipitation : float = precipitation
+        self.precipitation_probability : int = precipitation_probability
+        self.wind_speed : float = wind_speed
+        self.comment : str = comment

modules/weather_test.ipynb

@@ -0,0 +1,242 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5726d887",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Temperature: 22.7 °C\n",
+      "Humidity: 54 %\n",
+      "Wind speed: 3.6 km/h\n",
+      "{'time': '2026-06-08T21:45', 'interval': 900, 'temperature_2m': 22.7, 'relative_humidity_2m': 54, 'wind_speed_10m': 3.6}\n"
+     ]
+    }
+   ],
+   "source": [
+    "import requests\n",
+    "\n",
+    "# Coordinates for Marseille\n",
+    "lat = 43.2965\n",
+    "lon = 5.3698\n",
+    "\n",
+    "url = (\n",
+    "    \"https://api.open-meteo.com/v1/forecast\"\n",
+    "    f\"?latitude={lat}&longitude={lon}\"\n",
+    "    \"&current=temperature_2m,relative_humidity_2m,wind_speed_10m\"\n",
+    ")\n",
+    "\n",
+    "data = requests.get(url).json()\n",
+    "\n",
+    "current = data[\"current\"]\n",
+    "\n",
+    "print(\"Temperature:\", current[\"temperature_2m\"], \"°C\")\n",
+    "print(\"Humidity:\", current[\"relative_humidity_2m\"], \"%\")\n",
+    "print(\"Wind speed:\", current[\"wind_speed_10m\"], \"km/h\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "eda4c3a6",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Chance of rain tomorrow: 35%\n",
+      "☀️ Rain unlikely tomorrow\n"
+     ]
+    }
+   ],
+   "source": [
+    "# check if it rains tommorrow\n",
+    "from datetime import datetime, timedelta\n",
+    "\n",
+    "LATITUDE = 43.2965\n",
+    "LONGITUDE = 5.3698\n",
+    "\n",
+    "url = (\n",
+    "    \"https://api.open-meteo.com/v1/forecast\"\n",
+    "    f\"?latitude={LATITUDE}\"\n",
+    "    f\"&longitude={LONGITUDE}\"\n",
+    "    \"&daily=precipitation_probability_max\"\n",
+    "    \"&timezone=auto\"\n",
+    ")\n",
+    "\n",
+    "data = requests.get(url, timeout=10).json()\n",
+    "\n",
+    "tomorrow = (datetime.now() + timedelta(days=1)).strftime(\"%Y-%m-%d\")\n",
+    "\n",
+    "dates = data[\"daily\"][\"time\"]\n",
+    "probs = data[\"daily\"][\"precipitation_probability_max\"]\n",
+    "\n",
+    "idx = dates.index(tomorrow)\n",
+    "prob = probs[idx]\n",
+    "\n",
+    "print(f\"Chance of rain tomorrow: {prob}%\")\n",
+    "\n",
+    "if prob >= 50:\n",
+    "    print(\"🌧️ Likely to rain tomorrow\")\n",
+    "else:\n",
+    "    print(\"☀️ Rain unlikely tomorrow\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "c806be1c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "False\n",
+      "True\n",
+      "False\n"
+     ]
+    }
+   ],
+   "source": [
+    "from datetime import date, datetime\n",
+    "def did_or_will_rain(\n",
+    "    target_date,\n",
+    "    latitude,\n",
+    "    longitude,\n",
+    "    forecast_threshold=50,\n",
+    "):\n",
+    "    \"\"\"\n",
+    "    Returns True if:\n",
+    "      - it rained on a past date\n",
+    "      - rain is forecast on a future date above the threshold\n",
+    "\n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    target_date : str | date | datetime\n",
+    "        Date to check (\"YYYY-MM-DD\" or date object)\n",
+    "    latitude : float\n",
+    "    longitude : float\n",
+    "    forecast_threshold : int\n",
+    "        Minimum rain probability (%) for future dates\n",
+    "\n",
+    "    Returns\n",
+    "    -------\n",
+    "    bool\n",
+    "    \"\"\"\n",
+    "\n",
+    "    # Normalize date\n",
+    "    if isinstance(target_date, str):\n",
+    "        target_date = datetime.strptime(target_date, \"%Y-%m-%d\").date()\n",
+    "    elif isinstance(target_date, datetime):\n",
+    "        target_date = target_date.date()\n",
+    "\n",
+    "    today = date.today()\n",
+    "\n",
+    "    # Historical date\n",
+    "    if target_date < today:\n",
+    "        url = (\n",
+    "            \"https://archive-api.open-meteo.com/v1/archive\"\n",
+    "            f\"?latitude={latitude}\"\n",
+    "            f\"&longitude={longitude}\"\n",
+    "            f\"&start_date={target_date}\"\n",
+    "            f\"&end_date={target_date}\"\n",
+    "            \"&daily=precipitation_sum\"\n",
+    "            \"&timezone=auto\"\n",
+    "        )\n",
+    "\n",
+    "        data = requests.get(url, timeout=10).json()\n",
+    "\n",
+    "        rain_mm = data[\"daily\"][\"precipitation_sum\"][0]\n",
+    "        return rain_mm > 0\n",
+    "\n",
+    "    # Today / future date\n",
+    "    else:\n",
+    "        url = (\n",
+    "            \"https://api.open-meteo.com/v1/forecast\"\n",
+    "            f\"?latitude={latitude}\"\n",
+    "            f\"&longitude={longitude}\"\n",
+    "            \"&daily=precipitation_probability_max,precipitation_sum\"\n",
+    "            \"&forecast_days=16\"\n",
+    "            \"&timezone=auto\"\n",
+    "        )\n",
+    "\n",
+    "        data = requests.get(url, timeout=10).json()\n",
+    "\n",
+    "        dates = data[\"daily\"][\"time\"]\n",
+    "\n",
+    "        target_date_str = target_date.isoformat()\n",
+    "\n",
+    "        if target_date_str not in dates:\n",
+    "            raise ValueError(\"Date outside forecast range\")\n",
+    "\n",
+    "        idx = dates.index(target_date_str)\n",
+    "\n",
+    "        probability = data[\"daily\"][\"precipitation_probability_max\"][idx]\n",
+    "        precipitation = data[\"daily\"][\"precipitation_sum\"][idx]\n",
+    "\n",
+    "        return (\n",
+    "            probability >= forecast_threshold\n",
+    "            or precipitation > 0\n",
+    "        )\n",
+    "    \n",
+    "# Marseille\n",
+    "LAT = 43.2965\n",
+    "LON = 5.3698\n",
+    "\n",
+    "# Did it rain yesterday?\n",
+    "print(did_or_will_rain(\"2026-06-03\", LAT, LON))\n",
+    "\n",
+    "# Will it rain tomorrow?\n",
+    "print(did_or_will_rain(\"2026-06-04\", LAT, LON))\n",
+    "\n",
+    "# Require at least 70% confidence\n",
+    "print(\n",
+    "    did_or_will_rain(\n",
+    "        \"2026-06-05\",\n",
+    "        LAT,\n",
+    "        LON,\n",
+    "        forecast_threshold=70,\n",
+    "    ))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "34b8844f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from plant import Plant\n",
+    "p = Plant(\"Ficus\")\n",
+    "print(p)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.14.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

modules/weather_utils.py

@@ -0,0 +1,200 @@
+import requests
+from datetime import date, datetime, timedelta
+from modules.weather import Weather
+def fetch_json(url: str, timeout: int = 10) -> dict:
+    resp = requests.get(url, timeout=timeout)
+    resp.raise_for_status()
+    data = resp.json()
+    if data.get("error"):
+        raise RuntimeError(f"Open-Meteo API error: {data.get('reason', data)}")
+    if "daily" not in data:
+        raise RuntimeError(f"Unexpected Open-Meteo response: {data}")
+    return data
+def did_or_will_rain(
+    target_date,
+    latitude,
+    longitude,
+    forecast_threshold=50,
+):
+    """
+    Returns True if:
+      - it rained on a past date
+      - rain is forecast on a future date above the threshold
+
+    Parameters
+    ----------
+    target_date : str | date | datetime
+        Date to check ("YYYY-MM-DD" or date object)
+    latitude : float
+    longitude : float
+    forecast_threshold : int
+        Minimum rain probability (%) for future dates
+
+    Returns
+    -------
+    bool
+    """
+
+    # Normalize date
+    if isinstance(target_date, str):
+        target_date = datetime.strptime(target_date, "%Y-%m-%d").date()
+    elif isinstance(target_date, datetime):
+        target_date = target_date.date()
+
+    today = date.today()
+
+    # Historical date
+    if target_date < today:
+        url = (
+            "https://archive-api.open-meteo.com/v1/archive"
+            f"?latitude={latitude}"
+            f"&longitude={longitude}"
+            f"&start_date={target_date}"
+            f"&end_date={target_date}"
+            "&daily=precipitation_sum"
+            "&timezone=auto"
+        )
+
+        data = fetch_json(url)
+
+        rain_mm = data["daily"]["precipitation_sum"][0]
+        return rain_mm > 0
+
+    # Today / future date
+    else:
+        url = (
+            "https://api.open-meteo.com/v1/forecast"
+            f"?latitude={latitude}"
+            f"&longitude={longitude}"
+            "&daily=precipitation_probability_max,precipitation_sum"
+            "&forecast_days=16"
+            "&timezone=auto"
+        )
+
+        data = fetch_json(url)
+        
+        dates = data["daily"]["time"]
+
+        target_date_str = target_date.isoformat()
+
+        if target_date_str not in dates:
+            raise ValueError("Date outside forecast range")
+
+        idx = dates.index(target_date_str)
+
+        probability = data["daily"]["precipitation_probability_max"][idx]
+        precipitation = data["daily"]["precipitation_sum"][idx]
+
+        return (
+            probability >= forecast_threshold
+            or precipitation > 0
+        )
+    
+
+def weather_comment(code: int) -> str:
+    WMO_CODES = {
+    0:  "☀️ Sunny",
+    1:  "🌤️ Mainly clear",
+    2:  "⛅ Partly cloudy",
+    3:  "☁️ Cloudy",
+    45: "🌫️ Foggy",
+    48: "🌫️ Icy fog",
+    51: "🌦️ Light drizzle",
+    53: "🌦️ Moderate drizzle",
+    55: "🌧️ Dense drizzle",
+    56: "🌨️ Light freezing drizzle",
+    57: "🌨️ Heavy freezing drizzle",
+    61: "🌧️ Slight rain",
+    63: "🌧️ Moderate rain",
+    65: "🌧️ Heavy rain",
+    66: "🌨️ Light freezing rain",
+    67: "🌨️ Heavy freezing rain",
+    71: "❄️ Slight snowfall",
+    73: "❄️ Moderate snowfall",
+    75: "❄️ Heavy snowfall",
+    77: "🌨️ Snow grains",
+    80: "🌦️ Slight rain showers",
+    81: "🌧️ Moderate rain showers",
+    82: "⛈️ Violent rain showers",
+    85: "🌨️ Slight snow showers",
+    86: "🌨️ Heavy snow showers",
+    95: "⛈️ Thunderstorm",
+    96: "⛈️ Thunderstorm with slight hail",
+    99: "⛈️ Thunderstorm with heavy hail",
+}
+    return WMO_CODES.get(code, "Unknown weather")
+    
+
+def weather_values(date, latitude, longitude):
+    # return temperature, wind, precipitation, and a comment (cloudy/sunny/rainy/windy)
+    url = (
+        "https://api.open-meteo.com/v1/forecast"
+        f"?latitude={latitude}"
+        f"&longitude={longitude}"
+        "&daily=temperature_2m_max,temperature_2m_min,precipitation_sum,precipitation_probability_max,windspeed_10m_max,weathercode"
+        "&forecast_days=16"
+        "&timezone=auto"
+    )
+    data = fetch_json(url)
+    dates = data["daily"]["time"]
+    # date_str = date.isoformat() if isinstance(date, date) else date
+    date_str = date.isoformat()
+    if date_str not in dates:
+        raise ValueError("Date outside forecast range")
+    idx = dates.index(date_str)
+    temp_max = data["daily"]["temperature_2m_max"][idx]
+    temp_min = data["daily"]["temperature_2m_min"][idx]
+    precipitation = data["daily"]["precipitation_sum"][idx]
+    precipitation_probability = data["daily"]["precipitation_probability_max"][idx]
+    windspeed = data["daily"]["windspeed_10m_max"][idx]
+    weathercode = data["daily"]["weathercode"][idx]
+
+    comment = weather_comment(weathercode)
+    return Weather(
+        temp_max=temp_max,
+        temp_min=temp_min,
+        precipitation=precipitation,
+        precipitation_probability=precipitation_probability,
+        wind_speed=windspeed,
+        comment=comment,
+    )
+
+def last_rained_date(latitude, longitude, days_back=15):
+    url = (
+        "https://archive-api.open-meteo.com/v1/archive"
+        f"?latitude={latitude}"
+        f"&longitude={longitude}"
+        f"&start_date={(date.today() - timedelta(days=days_back + 1 )).isoformat()}"
+        f"&end_date={(date.today() - timedelta(days=1)).isoformat()}" # YESTERDAY
+        "&daily=precipitation_sum"
+        "&timezone=auto"
+    )
+
+    data = fetch_json(url)
+    dates = data["daily"]["time"]
+    precipitation = data["daily"]["precipitation_sum"]
+
+    for d, p in zip(reversed(dates), reversed(precipitation)):
+        if p > 5:  # Consider it rained if precipitation > 5mm
+            return date.fromisoformat(d)
+
+    return None  # No rain in the past `days_back` days
+
+# Marseille
+LAT = 43.2965
+LON = 5.3698
+
+# Did it rain yesterday?
+print(did_or_will_rain("2026-06-03", LAT, LON))
+
+# Will it rain tomorrow?
+print(did_or_will_rain("2026-06-04", LAT, LON))
+
+# Require at least 70% confidence
+print(
+    did_or_will_rain(
+        "2026-06-05",
+        LAT,
+        LON,
+        forecast_threshold=70,
+    ))