import json import pickle from typing import Tuple, Optional, List, Dict, Any import numpy as np import pandas as pd from geopy.distance import geodesic from gadm_utils import GADMHandler from geo_utils import resolve_place from plot_utils import scatter_plot import ast class LUCASSoilData: def __init__(self, table_path: str, dict_path: str, column_names_path: str, gadm_handler: GADMHandler) -> None: self.df = pd.read_csv(table_path, low_memory=False) self.df["LAT_LONG"] = self.df["LAT_LONG"].apply( lambda x: ast.literal_eval(x) if isinstance(x, str) else x ) with open(column_names_path, 'r') as f: self.column_names = json.load(f)["column_names"] self.property_map = {} for full_name in self.column_names: base, unit = full_name.split("(", maxsplit=1) if "(" in full_name else (full_name, None) if unit is not None: unit = unit[:-1].strip() # remove trailing ")" theme, prop = [x.strip() for x in base.split(":", 1)] self.property_map[prop] = (full_name, theme, unit) with open(dict_path, 'rb') as f: self.sample_dict = pickle.load(f) self.gadm_handler = gadm_handler def resolve_theme_property_unit(self, input_string: str) -> Tuple[str, str, str, Optional[str]]: """ Resolve and return (full_name, theme, property, unit) from a user input string. The user may provide: - full form: "theme:property (unit)" - partial form: "theme:property" - property only: "property" """ input_string = input_string.strip() # Extract unit if present if "(" in input_string: base, input_unit = input_string.split("(", maxsplit=1) input_unit = input_unit[:-1].strip() # remove trailing ")" else: base, input_unit = input_string, None # Extract theme + property if ":" in base: input_theme, input_property = [x.strip() for x in base.split(":", 1)] else: input_theme, input_property = None, base.strip() # Property must exist if input_property not in self.property_map: raise ValueError(f"Property '{input_property}' not found in dataset.") full_name, expected_theme, expected_unit = self.property_map[input_property] # Validate theme if user supplied one if input_theme is not None and input_theme != expected_theme: raise ValueError(f"Theme mismatch: expected '{expected_theme}', got '{input_theme}'.") # Validate unit if user supplied one if input_unit is not None and input_unit != expected_unit: raise ValueError(f"Unit mismatch for '{input_property}': expected '{expected_unit}', got '{input_unit}'.") return full_name, expected_theme, input_property, expected_unit def get_point(self, place: str | tuple[float, float], properties: List[str], distance_top_k: int = 20, distance_limit: float = 200000, session_name: Optional[str] = None) -> Dict[str, Any]: """ Retrieve soil data near a place, selecting the best among top-k nearest samples. Rules: 1) Find top-k nearest samples (by squared distance, then geodesic meters). 2) Exclude samples farther than `distance_limit` (meters). 3) From remaining samples, choose the one with the most valid properties. (valid = property exists AND sample[...] has non-None "value"). Tie-break: smaller distance wins. 4) If all survivors have zero valid properties, return Failed. 5) Resolver is strict: if user requests an unknown property, immediate Failed. Output always contains `query_input` and `query_status`. Sample data is included only for success or partial success cases. """ # always include input record in response query_input = { "place": place, "properties": properties, "distance_limit": distance_limit, "distance_top_k": distance_top_k, } # ---------- Resolve place → (lat, lon) ---------- try: if isinstance(place, str): if place not in self.gadm_handler.tree: resolved = resolve_place(place, session_name=session_name, gadm_handler=self.gadm_handler) gid = resolved.get("gid") if gid is None: return { "query_input": query_input, "query_status": f"Failed. Cannot resolve place: {place}", "query_output": {} } else: gid = place geom_info = self.gadm_handler.get_geometry_info(gid) if geom_info is None: return { "query_input": query_input, "query_status": f"Failed. Cannot get geometry for place (GID): {place} ({gid})", "query_output": {} } lat, lon = geom_info["latitude"], geom_info["longitude"] else: lat, lon = place except Exception as e: return { "query_input": query_input, "query_status": f"Failed. {str(e)}", "query_output": {} } # ---------- Strict property resolution (fail if any invalid) ---------- resolved_props = [] try: for input_prop in properties: full_name, theme, prop, unit = self.resolve_theme_property_unit(input_prop) resolved_props.append((theme, prop, input_prop)) except Exception as e: return { "query_input": query_input, "query_status": f"Failed. {str(e)}", "query_output": {} } # ---------- Find top-k nearest candidates ---------- try: latlon = np.vstack(self.df["LAT_LONG"].values).astype(float) # (N, 2) d2 = (latlon[:, 0] - lat) ** 2 + (latlon[:, 1] - lon) ** 2 k = max(1, min(distance_top_k, len(d2))) idx_k = np.argpartition(d2, kth=k - 1)[:k] candidates = [] for idx in idx_k: sample_lat, sample_lon = latlon[idx] dist_m = geodesic((lat, lon), (sample_lat, sample_lon)).meters candidates.append((idx, dist_m)) survivors = [(idx, dist_m) for (idx, dist_m) in candidates if dist_m <= distance_limit] if not survivors: return { "query_input": query_input, "query_status": f"Failed. No nearby samples within {distance_limit:g} m.", "query_output": {} } except Exception as e: return { "query_input": query_input, "query_status": f"Failed. Error during nearest-point search: {str(e)}", "query_output": {} } # ---------- Score survivors by valid property count, then distance ---------- def count_valid(idx: int) -> int: row = self.df.iloc[idx] src = self.sample_dict.get(row["id"], {}) valid = 0 for theme, prop, _orig in resolved_props: try: val = src[theme][prop]["value"] if val is not None: valid += 1 except Exception: pass return valid scored = [(idx, dist, count_valid(idx)) for idx, dist in survivors] scored.sort(key=lambda x: (-x[2], x[1])) # most valid props, then nearest best_idx, best_dist, best_valid = scored[0] if best_valid == 0: return { "query_input": query_input, "query_status": ( "Failed. No sample within " f"{distance_limit:g} m contains any of the requested properties." ), "query_output": {} } # ---------- Build result for best candidate ---------- try: row = self.df.iloc[best_idx] source = self.sample_dict[row["id"]] except Exception: return { "query_input": query_input, "query_status": f"Failed. Sample data missing for best candidate.", "query_output": {} } result = {} for key in ["LAT_LONG", "GADM_IDS", "GADM_NAMES", "COUNTRY_CODE", "SAMPLE_DATE", "SAMPLE_DEPTH_RANGE_CM", "SAMPLE_SOURCE_DATASET"]: result[key] = source.get(key) failed_props = [] for theme, prop, original_input in resolved_props: try: val = source[theme][prop]["value"] if val is not None: if theme not in result: result[theme] = {} result[theme][prop] = val else: failed_props.append(original_input) except Exception: failed_props.append(original_input) if failed_props and len(failed_props) < len(resolved_props): status = ( "Partial success. Some properties were not available: " + ", ".join(failed_props) + f". Distance to nearest sample (m): {best_dist:.1f}." ) else: status = f"Success. Distance to nearest sample (m): {best_dist:.1f}." result["entry_key"] = row["id"] return { "query_output": result, "query_input": query_input, "query_status": status, } def get_map(self, place: str | tuple[float, float, float], properties: List[str], session_name: Optional[str] = None, **kwargs) -> Dict[str, Any]: """ Generate scatter plots for the specified properties around a GADM region. Returns: { "query_output": { "": "", ... }, "query_input": { "place": ..., "properties": [...] }, "query_status": "Success. N plot(s) generated." | "Failed. " } """ # Always include the input query_input = {"place": place, "properties": properties} # ---------- Resolve place → gid (and lat/lon if needed) ---------- try: if isinstance(place, str): if place not in self.gadm_handler.tree: resolved = resolve_place(place, session_name=session_name, gadm_handler=self.gadm_handler) gid = resolved.get("gid") if gid is None: return {"query_input": query_input, "query_status": f"Failed. Cannot resolve place: {place}", "query_output": {}} else: gid = place else: # tuple expected: (lat, lon, bbox_area) if len(place) != 3: return {"query_input": query_input, "query_status": "Failed. Tuple `place` must be (lat, lon, bbox_area).", "query_output": {}} lat, lon, bbox_area = place gid = self.gadm_handler.find_gid(lat, lon, bbox_area) if gid is None: return {"query_input": query_input, "query_status": "Failed. No matching GADM region found for given coordinates.", "query_output": {}} geom_info = self.gadm_handler.get_geometry_info(gid) if geom_info is None: return {"query_input": query_input, "query_status": f"Failed. Cannot get geometry for place (GID): {gid}", "query_output": {}} except Exception as e: return {"query_input": query_input, "query_status": f"Failed. {str(e)}", "query_output": {}} # ---------- Strict property resolution (fail if any invalid) ---------- resolved = [] try: for input_prop in properties: full_name, theme, prop, unit = self.resolve_theme_property_unit(input_prop) resolved.append((full_name, theme, prop, unit)) except Exception as e: return {"query_input": query_input, "query_status": f"Failed. {str(e)}", "query_output": {}} if len(resolved) > 5: return {"query_input": query_input, "query_status": "Failed. API does not accept more than 5 properties.", "query_output": {}} # ---------- Compute map extent using gid + siblings ---------- try: siblings = self.gadm_handler.get_tree_info(gid)["siblings"] gids = [gid] + siblings polygon = self.gadm_handler.get_polygon(gid) minx, miny, maxx, maxy = polygon.bounds # 100% margin dlat = (maxy - miny) or 1.0 dlon = (maxx - minx) or 1.0 lat_min, lat_max = miny - dlat, maxy + dlat lon_min, lon_max = minx - dlon, maxx + dlon except Exception as e: return {"query_input": query_input, "query_status": f"Failed. {str(e)}", "query_output": {}} # ---------- Region filter using LAT_LONG ---------- try: latlon = np.vstack(self.df["LAT_LONG"].values).astype(float) # shape (N,2) lats, lons = latlon[:, 0], latlon[:, 1] mask = (lats >= lat_min) & (lats <= lat_max) & (lons >= lon_min) & (lons <= lon_max) df_region = self.df[mask] except Exception as e: return {"query_input": query_input, "query_status": f"Failed. {str(e)}", "query_output": {}} # ---------- Plot helper (returns URL or warning string) ---------- def plot_one(full_name: str, prop: str) -> str: try: if full_name not in df_region.columns: return "Skipped. No valid data." # Build [lat, lon, value] values = pd.to_numeric(df_region[full_name], errors="coerce") ok = values.notna() if not ok.any(): return "Skipped. No valid data." # extract lat/lon for the same rows latlon_sub = np.vstack(df_region.loc[ok, "LAT_LONG"].values).astype(float) data = np.column_stack([latlon_sub[:, 0], latlon_sub[:, 1], values.loc[ok].astype(float).values]) # numeric vs categorical: if after coercion we have floats, treat as numeric. # If you need categorical, you can branch by dtype before coercion. img_path = scatter_plot( gadm_handler=self.gadm_handler, data=data, is_categorical=False, short_name=prop, long_name=full_name, map_boundary_gadm_gids=gids, map_limits="gadm_first", session_name=session_name, **kwargs ) return img_path except Exception: return "Skipped. No valid data." # ---------- Generate outputs (flat) ---------- query_output: Dict[str, str] = {} for full_name, theme, prop, unit in resolved: query_output[full_name] = plot_one(full_name, prop) # ---------- Status ---------- n_plots = sum(1 for v in query_output.values() if isinstance(v, str) and v.endswith(".png")) if n_plots >= 1: status = f"Success. {n_plots} plot{'s' if n_plots != 1 else ''} generated." else: status = "Failed. No plots generated." return { "query_output": query_output, "query_input": query_input, "query_status": status, }