ci: split CI into Tests + Lint workflows, fix CI failures

Why CI was failing:
- ci.yml ran pytest without first generating data/observations/*.csv
  (those CSVs are gitignored — only wells.geojson is tracked)
- ruff check + format had 46 lint + 51 format errors on existing code
- E402 false positives on test files that intentionally set
  os.environ.setdefault() before module imports

Fixes:
- Split workflows: .github/workflows/test.yml (pytest) + lint.yml (ruff)
  → README gets two independent dynamic badges
- test.yml: pip cache, generate-data step, dummy API keys via env
- lint.yml: ruff check + ruff format --check
- backend/ruff.toml: line-length 100, select E F I W, ignore E501,
  per-file-ignore E402 in tests/
- ruff format applied across backend/ (51 files reformatted)
- ruff check --fix removed 27 unused imports / dead vars
- Manually fixed 1 F841 in test_analyze_interference (added missing
  r30.t_days assertion)
- README: replaced single ci.yml badge + hardcoded "tests-154-passing"
  shield with two live workflow badges (Tests + Lint)

Tests: 154 passed, 0 regressions. Ruff check + format both clean.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: CreatmanCEO

.github/workflows/ci.yml

@@ -0,0 +1,24 @@
+name: Lint
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  ruff:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+      - name: Install ruff
+        run: pip install ruff
+      - name: Lint check
+        working-directory: backend
+        run: ruff check .
+      - name: Format check
+        working-directory: backend
+        run: ruff format --check .

.github/workflows/lint.yml

@@ -0,0 +1,31 @@
+name: Tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  pytest:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+          cache: 'pip'
+          cache-dependency-path: backend/requirements.txt
+      - name: Install dependencies
+        run: pip install -r backend/requirements.txt
+      - name: Generate synthetic data (wells GeoJSON is committed; observations CSV are not)
+        working-directory: backend
+        run: |
+          python -m data_generator.generate_wells
+          python -m data_generator.generate_timeseries
+      - name: Run pytest
+        working-directory: backend
+        env:
+          GEMINI_API_KEY: test-key
+          OPENROUTER_API_KEY: test-key
+        run: python -m pytest tests/ -v --tb=short

.github/workflows/test.yml

@@ -1,11 +1,11 @@
 # HydroWatch
 
-[![CI](https://github.com/CreatmanCEO/hydrowatch/actions/workflows/ci.yml/badge.svg)](https://github.com/CreatmanCEO/hydrowatch/actions)
+[![Tests](https://github.com/CreatmanCEO/hydrowatch/actions/workflows/test.yml/badge.svg)](https://github.com/CreatmanCEO/hydrowatch/actions/workflows/test.yml)
+[![Lint](https://github.com/CreatmanCEO/hydrowatch/actions/workflows/lint.yml/badge.svg)](https://github.com/CreatmanCEO/hydrowatch/actions/workflows/lint.yml)
 [![Python 3.12](https://img.shields.io/badge/python-3.12-blue.svg)](https://python.org)
 [![FastAPI](https://img.shields.io/badge/FastAPI-0.115-009688.svg)](https://fastapi.tiangolo.com)
 [![Next.js 15](https://img.shields.io/badge/Next.js-15-black.svg)](https://nextjs.org)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
-[![Tests](https://img.shields.io/badge/tests-154%20passing-brightgreen.svg)](#testing)
 
 **Theis-based groundwater monitoring with LLM assistant for well interference and depression cone analysis in Abu Dhabi aquifer systems.**
 

README.md

@@ -1,7 +1,9 @@
 """Application configuration via environment variables."""
+
 from pathlib import Path
+
+from pydantic import SecretStr
 from pydantic_settings import BaseSettings
-from pydantic import SecretStr, Field
 
 
 class Settings(BaseSettings):

backend/config.py

@@ -1,6 +1,6 @@
 """Generate synthetic time series with anomaly injection for groundwater wells."""
+
 import json
-import os
 from datetime import datetime, timedelta
 from pathlib import Path
 
@@ -178,59 +178,64 @@ def generate_well_timeseries(
                 data["debit_ls"] = AnomalyInjector.gradual_decline(
                     data["debit_ls"], start, duration, decline_pct
                 )
-                anomaly_log.append({
-                    "type": "debit_decline",
-                    "start_idx": start,
-                    "duration": duration,
-                    "decline_pct": round(decline_pct, 3),
-                    "parameter": "debit_ls",
-                })
+                anomaly_log.append(
+                    {
+                        "type": "debit_decline",
+                        "start_idx": start,
+                        "duration": duration,
+                        "decline_pct": round(decline_pct, 3),
+                        "parameter": "debit_ls",
+                    }
+                )
 
             elif atype == "tds_spike":
                 spike_factor = float(rng.uniform(1.5, 3.0))
                 spike_dur = max(duration // 3, 10)
                 data["tds_mgl"] = AnomalyInjector.sudden_spike(
                     data["tds_mgl"], start, spike_dur, spike_factor
                 )
-                anomaly_log.append({
-                    "type": "tds_spike",
-                    "start_idx": start,
-                    "duration": spike_dur,
-                    "spike_factor": round(spike_factor, 2),
-                    "parameter": "tds_mgl",
-                })
+                anomaly_log.append(
+                    {
+                        "type": "tds_spike",
+                        "start_idx": start,
+                        "duration": spike_dur,
+                        "spike_factor": round(spike_factor, 2),
+                        "parameter": "tds_mgl",
+                    }
+                )
 
             elif atype == "sensor_fault":
                 fault_dur = max(duration // 5, 5)
                 data["ph"] = AnomalyInjector.sensor_fault(
                     data["ph"], start, fault_dur, fault_value=0.0
                 )
-                anomaly_log.append({
-                    "type": "sensor_fault",
-                    "start_idx": start,
-                    "duration": fault_dur,
-                    "fault_value": 0.0,
-                    "parameter": "ph",
-                })
+                anomaly_log.append(
+                    {
+                        "type": "sensor_fault",
+                        "start_idx": start,
+                        "duration": fault_dur,
+                        "fault_value": 0.0,
+                        "parameter": "ph",
+                    }
+                )
 
     # Build timestamps
     start_date = datetime(2024, 1, 1)
     hours_step = 24 // measurements_per_day
-    timestamps = [
-        start_date + timedelta(hours=i * hours_step)
-        for i in range(n_points)
-    ]
-
-    df = pd.DataFrame({
-        "timestamp": timestamps,
-        "well_id": well_id,
-        "debit_ls": np.round(data["debit_ls"], 3),
-        "tds_mgl": np.round(data["tds_mgl"], 1),
-        "ph": np.round(data["ph"], 2),
-        "chloride_mgl": np.round(data["chloride_mgl"], 1),
-        "water_level_m": np.round(data["water_level_m"], 2),
-        "temperature_c": np.round(data["temperature_c"], 1),
-    })
+    timestamps = [start_date + timedelta(hours=i * hours_step) for i in range(n_points)]
+
+    df = pd.DataFrame(
+        {
+            "timestamp": timestamps,
+            "well_id": well_id,
+            "debit_ls": np.round(data["debit_ls"], 3),
+            "tds_mgl": np.round(data["tds_mgl"], 1),
+            "ph": np.round(data["ph"], 2),
+            "chloride_mgl": np.round(data["chloride_mgl"], 1),
+            "water_level_m": np.round(data["water_level_m"], 2),
+            "temperature_c": np.round(data["temperature_c"], 1),
+        }
+    )
 
     return df, anomaly_log
 
@@ -274,9 +279,7 @@ def main():
     well_ids = [f["properties"]["id"] for f in geojson["features"]]
     obs_dir = data_dir / "observations"
 
-    result = generate_all_timeseries(
-        well_ids, days=365, output_dir=str(obs_dir)
-    )
+    result = generate_all_timeseries(well_ids, days=365, output_dir=str(obs_dir))
     print(f"Generated {len(result)} time series -> observations/")
 
 

backend/data_generator/generate_timeseries.py

@@ -1,23 +1,58 @@
 """Generate synthetic groundwater well GeoJSON for Abu Dhabi region."""
+
 import json
-import os
 from pathlib import Path
 
 import numpy as np
 
 # Abu Dhabi well field clusters (center lat, lon, name)
 CLUSTERS = [
-    {"id": "AL_WATHBA", "name": "Al Wathba", "center": (24.42, 54.72), "radius_deg": 0.06},
-    {"id": "MUSSAFAH", "name": "Mussafah Industrial", "center": (24.35, 54.50), "radius_deg": 0.04},
+    {
+        "id": "AL_WATHBA",
+        "name": "Al Wathba",
+        "center": (24.42, 54.72),
+        "radius_deg": 0.06,
+    },
+    {
+        "id": "MUSSAFAH",
+        "name": "Mussafah Industrial",
+        "center": (24.35, 54.50),
+        "radius_deg": 0.04,
+    },
     {"id": "SWEIHAN", "name": "Sweihan", "center": (24.48, 55.35), "radius_deg": 0.08},
-    {"id": "AL_KHATIM", "name": "Al Khatim", "center": (24.28, 55.10), "radius_deg": 0.07},
+    {
+        "id": "AL_KHATIM",
+        "name": "Al Khatim",
+        "center": (24.28, 55.10),
+        "radius_deg": 0.07,
+    },
 ]
 
 AQUIFER_TYPES = [
-    {"name": "Dammam Limestone", "depth_range": (80, 200), "T_range": (200, 1200), "S_range": (0.002, 0.008)},
-    {"name": "Umm Er Radhuma", "depth_range": (150, 350), "T_range": (100, 800), "S_range": (0.001, 0.005)},
-    {"name": "Quaternary Sand", "depth_range": (30, 80), "T_range": (50, 400), "S_range": (0.01, 0.05)},
-    {"name": "Alluvial", "depth_range": (20, 60), "T_range": (30, 300), "S_range": (0.05, 0.15)},
+    {
+        "name": "Dammam Limestone",
+        "depth_range": (80, 200),
+        "T_range": (200, 1200),
+        "S_range": (0.002, 0.008),
+    },
+    {
+        "name": "Umm Er Radhuma",
+        "depth_range": (150, 350),
+        "T_range": (100, 800),
+        "S_range": (0.001, 0.005),
+    },
+    {
+        "name": "Quaternary Sand",
+        "depth_range": (30, 80),
+        "T_range": (50, 400),
+        "S_range": (0.01, 0.05),
+    },
+    {
+        "name": "Alluvial",
+        "depth_range": (20, 60),
+        "T_range": (30, 300),
+        "S_range": (0.05, 0.15),
+    },
 ]
 
 OPERATORS = [
@@ -27,7 +62,14 @@
     "Abu Dhabi Agriculture Authority",
 ]
 
-STATUSES = ["active", "active", "active", "active", "inactive", "maintenance"]  # weighted
+STATUSES = [
+    "active",
+    "active",
+    "active",
+    "active",
+    "inactive",
+    "maintenance",
+]  # weighted
 
 
 def generate_wells_geojson(
@@ -79,10 +121,10 @@ def generate_wells_geojson(
             status = str(rng.choice(STATUSES))
             operator = str(rng.choice(OPERATORS))
             install_year = int(rng.integers(1995, 2023))
-            install_date = f"{install_year}-{rng.integers(1,13):02d}-{rng.integers(1,29):02d}"
+            install_date = f"{install_year}-{rng.integers(1, 13):02d}-{rng.integers(1, 29):02d}"
 
-            well_id = f"AUH-{ci+1:02d}-{j+1:03d}"
-            name_en = f"{cluster['name']} Well {j+1}"
+            well_id = f"AUH-{ci + 1:02d}-{j + 1:03d}"
+            name_en = f"{cluster['name']} Well {j + 1}"
 
             feature = {
                 "type": "Feature",

backend/data_generator/generate_wells.py

@@ -1,19 +1,22 @@
 """Analytical groundwater models: Theis equation, superposition."""
+
 from dataclasses import dataclass
+
 import numpy as np
 from scipy.special import exp1
 
 
 @dataclass
 class PumpingWell:
     """A pumping well with hydraulic parameters."""
+
     id: str
-    x: float            # UTM easting, meters
-    y: float            # UTM northing, meters
-    Q: float            # pumping rate, m3/day
-    T: float            # transmissivity, m2/day
-    S: float            # storativity (dimensionless)
-    start_time: float   # pumping start time, days
+    x: float  # UTM easting, meters
+    y: float  # UTM northing, meters
+    Q: float  # pumping rate, m3/day
+    T: float  # transmissivity, m2/day
+    S: float  # storativity (dimensionless)
+    start_time: float  # pumping start time, days
 
 
 def theis_drawdown(Q: float, T: float, S: float, r: float, t: float) -> float:

backend/data_generator/hydro_models.py

@@ -1,16 +1,17 @@
 """Seed database from generated GeoJSON and CSV files."""
+
 import asyncio
 import json
 from pathlib import Path
 
 import pandas as pd
-from sqlalchemy import delete
-from sqlalchemy.ext.asyncio import AsyncSession
 from geoalchemy2.shape import from_shape
 from shapely.geometry import shape
+from sqlalchemy import delete
+from sqlalchemy.ext.asyncio import AsyncSession
 
-from models.database import Base, Well, Observation
 from db.session import get_engine, get_session_factory
+from models.database import Base, Observation, Well
 
 
 async def seed_wells(session: AsyncSession, geojson_path: str):

backend/db/seed.py

@@ -1,5 +1,6 @@
 """Async SQLAlchemy session factory — lazy initialization."""
-from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker, AsyncSession
+
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
 
 _engine = None
 _session_factory = None
@@ -9,6 +10,7 @@ def get_engine():
     global _engine
     if _engine is None:
         from config import get_settings
+
         _engine = create_async_engine(get_settings().database_url, echo=False)
     return _engine