removed data dir path

backend/app/config/settings.py

@@ -3,7 +3,6 @@ from pydantic import Field
 from pydantic_settings import BaseSettings, SettingsConfigDict
 import os, tempfile
 
-# Resolve the repo root when running outside Docker
 REPO_ROOT = Path(__file__).resolve().parents[3]
 
 def _writable_dir(candidates: list[Path]) -> Path:
@@ -13,20 +12,21 @@ def _writable_dir(candidates: list[Path]) -> Path:
             t = p / ".write_test"
             t.write_text("ok", encoding="utf-8")
             t.unlink(missing_ok=True)
-            return p
+            return p.resolve()
         except Exception:
             continue
     raise RuntimeError(f"No writable data dir from: {candidates!r}")
 
 def _default_data_dir() -> Path:
-    # 1) Respect env if provided
-    if os.getenv("DATA_DIR"):
-        return Path(os.getenv("DATA_DIR")).resolve()
-    # 2) Prefer /data inside containers (Docker/HF Spaces)
-    candidates = [Path("/data")]
-    # 3) Repo local ./data for local dev
-    candidates.append((REPO_ROOT / "data").resolve())
-    # 4) Last resort: /tmp
+    candidates: list[Path] = []
+    env = os.getenv("DATA_DIR")
+    if env:
+        candidates.append(Path(env))
+    # Prefer the standard mount on Docker/HF (if writable)
+    candidates.append(Path("/data"))
+    # Local dev
+    candidates.append(REPO_ROOT / "data")
+    # Last resort
     candidates.append(Path(tempfile.gettempdir()) / "pulsemaps" / "data")
     return _writable_dir(candidates)
 
@@ -34,52 +34,40 @@ def _default_frontend_dist() -> Path:
     return (REPO_ROOT / "web" / "dist").resolve()
 
 class Settings(BaseSettings):
-    model_config = SettingsConfigDict(
-        env_file=".env",
-        extra="ignore",
-        case_sensitive=False,
-        populate_by_name=True,
-    )
+    model_config = SettingsConfigDict(env_file=".env", extra="ignore", case_sensitive=False)
 
-    # API / Models
     OPENAI_API_KEY: str | None = None
     OPENAI_MODEL_AGENT: str = "gpt-4o"
     OPENAI_MODEL_CLASSIFIER: str = "gpt-4o-mini"
 
-    # Paths
     DATA_DIR: Path = Field(default_factory=_default_data_dir)
     REPORTS_DB: Path | None = None
     SESSIONS_DB: Path | None = None
     UPLOADS_DIR: Path | None = None
     FRONTEND_DIST: Path = Field(default_factory=_default_frontend_dist)
 
-    # Defaults
     DEFAULT_RADIUS_KM: float = 40.0
     DEFAULT_LIMIT: int = 10
     MAX_AGE_HOURS: int = 48
 
-    # Optional extras you had in .env
     firms_map_key: str | None = None
     gdacs_rss_url: str | None = "https://www.gdacs.org/xml/rss.xml"
     nvidia_api_key: str | None = None
 
     def ensure_dirs(self) -> None:
-        # Fill path fields if not set, then ensure they exist
         if self.REPORTS_DB is None:
-            self.REPORTS_DB = (self.DATA_DIR / "pulsemaps_reports.db")
+            self.REPORTS_DB = self.DATA_DIR / "pulsemaps_reports.db"
         if self.SESSIONS_DB is None:
-            self.SESSIONS_DB = (self.DATA_DIR / "pulsemap_sessions.db")
+            self.SESSIONS_DB = self.DATA_DIR / "pulsemap_sessions.db"
         if self.UPLOADS_DIR is None:
-            self.UPLOADS_DIR = (self.DATA_DIR / "uploads")
+            self.UPLOADS_DIR = self.DATA_DIR / "uploads"
 
-        # Absolute, existing
-        self.DATA_DIR = self.DATA_DIR.resolve()
+        # Make & resolve
+        self.DATA_DIR.mkdir(parents=True, exist_ok=True)
+        self.UPLOADS_DIR.mkdir(parents=True, exist_ok=True)
         self.REPORTS_DB = self.REPORTS_DB.resolve()
         self.SESSIONS_DB = self.SESSIONS_DB.resolve()
         self.UPLOADS_DIR = self.UPLOADS_DIR.resolve()
 
-        self.DATA_DIR.mkdir(parents=True, exist_ok=True)
-        self.UPLOADS_DIR.mkdir(parents=True, exist_ok=True)
-
 settings = Settings()
 settings.ensure_dirs()

backend/app/data/store.py

@@ -7,11 +7,14 @@ from pathlib import Path
 from ..config.settings import settings
 from .geo import haversine_km
 
-# Use writable, absolute paths from settings (prefers /data in containers)
 DB_PATH: Path = settings.REPORTS_DB
+# Create parent and touch the file so we fail here if unwritable
 DB_PATH.parent.mkdir(parents=True, exist_ok=True)
+try:
+    DB_PATH.touch(exist_ok=True)
+except Exception as e:
+    raise RuntimeError(f"Cannot create DB file at {DB_PATH}: {e}")
 
-# Single connection
 _CONN = sqlite3.connect(str(DB_PATH), check_same_thread=False)
 _CONN.execute("""
 CREATE TABLE IF NOT EXISTS reports (
@@ -29,29 +32,18 @@ def _row_to_feature(row: tuple) -> Dict[str, Any]:
     _id, lat, lon, text, props_json, created_at = row
     props = {"type": "user_report", "text": text, "reported_at": created_at}
     if props_json:
-        try:
-            props.update(json.loads(props_json))
-        except Exception:
-            props["raw_props"] = props_json
-    return {
-        "type": "Feature",
-        "geometry": {"type": "Point", "coordinates": [lon, lat]},
-        "properties": props,
-    }
+        try: props.update(json.loads(props_json))
+        except Exception: props["raw_props"] = props_json
+    return {"type": "Feature", "geometry": {"type": "Point", "coordinates": [lon, lat]}, "properties": props}
 
 def add_report(lat: float, lon: float, text: str = "User report", props: dict | None = None):
     created_at = datetime.now(timezone.utc).isoformat()
     props_json = json.dumps(props or {})
-    _CONN.execute(
-        "INSERT INTO reports (lat, lon, text, props_json, created_at) VALUES (?,?,?,?,?)",
-        (float(lat), float(lon), text, props_json, created_at),
-    )
+    _CONN.execute("INSERT INTO reports (lat, lon, text, props_json, created_at) VALUES (?,?,?,?,?)",
+                  (float(lat), float(lon), text, props_json, created_at))
     _CONN.commit()
-    return {
-        "type": "Feature",
-        "geometry": {"type": "Point", "coordinates": [float(lon), float(lat)]},
-        "properties": {"type": "user_report", "text": text, "reported_at": created_at, **(props or {})},
-    }
+    return {"type": "Feature", "geometry": {"type": "Point", "coordinates": [float(lon), float(lat)]},
+            "properties": {"type": "user_report", "text": text, "reported_at": created_at, **(props or {})}}
 
 def get_feature_collection() -> Dict[str, Any]:
     cur = _CONN.execute("SELECT id, lat, lon, text, props_json, created_at FROM reports ORDER BY id DESC")