edmt 1.0.7.dev1__tar.gz → 1.0.7.post1__tar.gz

{edmt-1.0.7.dev1 → edmt-1.0.7.post1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: edmt
-Version: 1.0.7.dev1
+Version: 1.0.7.post1
 Summary: Environmental Data Management Toolbox
 Author-email: "Odero, Kuloba & musasia" <francisodero10@gmail.com>
 License: MIT License
@@ -47,12 +47,13 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: duckdb<1.3.2,>=0.9
 Requires-Dist: earthengine-api<1.8,>=0.1.324
-Requires-Dist: geopandas>=1
-Requires-Dist: pandas<3
+Requires-Dist: geopandas<2,>=1.0
+Requires-Dist: pandas<3,>=2.2
 Requires-Dist: fiona<1.10.1,>=1.9.6
 Requires-Dist: tqdm>=4
 Requires-Dist: requests<3,>=2.28
 Requires-Dist: matplotlib>=3.9
+Requires-Dist: qrcode
 Dynamic: license-file
 
 <h1 align="center">EDMT — Environmental Data Management Toolbox</h1>

{edmt-1.0.7.dev1 → edmt-1.0.7.post1}/edmt/contrib/utils.py

@@ -126,3 +126,8 @@ def dict_expand(data,cols):
       expanded_df = pd.concat(dfs_to_join, axis=1)
 
   return df_processed.join(expanded_df).drop(columns=cols, errors='ignore')
+
+
+# generate a EDMT customized QR Code image
+
+

edmt-1.0.7.post1/edmt/mapping/__init__.py

@@ -0,0 +1,7 @@
+from .carto import (
+    make_qr
+)
+
+__all__ = [
+    "make_qr"
+]

edmt-1.0.7.post1/edmt/mapping/carto.py

@@ -0,0 +1,94 @@
+# qr_utils.py
+
+import qrcode
+from qrcode.constants import ERROR_CORRECT_H
+from PIL import Image, ImageDraw, ImageFont
+
+
+def _load_font(name: str, size: int):
+    """Safely load a TrueType font with a fallback."""
+    try:
+        return ImageFont.truetype(name, size)
+    except OSError:
+        return ImageFont.load_default()
+
+
+def make_qr(
+    url: str,
+    label: str,
+    short_url: str | None = None,
+    size: int = 180,
+    foreground: str = "#1B3A2D",
+    background: str = "white",
+    muted: str = "#555555",
+) -> Image.Image:
+    """
+    Generate a QR code image with a label and optional short URL.
+
+    Parameters
+    ----------
+    url : str
+        URL to encode in the QR code.
+    label : str
+        Title displayed below the QR code.
+    short_url : str, optional
+        Shortened URL displayed below the label.
+    size : int, default=180
+        Width and height of the QR code in pixels.
+    foreground : str, default='#1B3A2D'
+        QR code and label color.
+    background : str, default='white'
+        Background color.
+    muted : str, default='#555555'
+        Color of the short URL text.
+
+    Returns
+    -------
+    PIL.Image.Image
+        QR code image with annotations.
+    """
+    f_label = _load_font("DejaVuSans-Bold.ttf", 12)
+    f_url = _load_font("DejaVuSans.ttf", 10)
+
+    qr = qrcode.QRCode(
+        version=2,
+        error_correction=ERROR_CORRECT_H,
+        box_size=6,
+        border=2,
+    )
+    qr.add_data(url)
+    qr.make(fit=True)
+
+    qr_img = (
+        qr.make_image(fill_color=foreground, back_color=background)
+        .convert("RGB")
+        .resize((size, size), Image.LANCZOS)
+    )
+
+    label_height = 42
+    canvas = Image.new(
+        "RGB",
+        (size, size + label_height),
+        background,
+    )
+    canvas.paste(qr_img, (0, 0))
+
+    draw = ImageDraw.Draw(canvas)
+    draw.text(
+        (size // 2, size + 4),
+        label,
+        font=f_label,
+        fill=foreground,
+        anchor="mt",
+    )
+
+    if short_url:
+        draw.text(
+            (size // 2, size + 20),
+            short_url,
+            font=f_url,
+            fill=muted,
+            anchor="mt",
+        )
+
+    return canvas

{edmt-1.0.7.dev1 → edmt-1.0.7.post1}/edmt/workflow/__init__.py

@@ -1,3 +1,9 @@
+from .builder import (
+    gdf_to_ee_geometry
+)
+
+from .connector import ee_to_points
+
 from .workflow import (
     compute_evi_timeseries,
     compute_lst_timeseries,
@@ -13,12 +19,12 @@ from .workflow import (
     get_chirps_image_collection,
 )
 
-from .builder import (
-    gdf_to_ee_geometry
+from .analysis import (
+    create_ROI,
+    classify_ndvi_seasons,
+    classify_climate_seasons
 )
 
-from .connector import ee_to_points
-
 _builder_functions = [
     "gdf_to_ee_geometry",
 ]
@@ -39,8 +45,14 @@ _workflow_functions = [
     "ee_to_points"
 ]
 
+_analysis_functions = [
+    "create_ROI",
+    "classify_ndvi_seasons",
+    "classify_climate_seasons"
+]
 
 __all__ = [
     _builder_functions,
-    _workflow_functions
+    _workflow_functions,
+    _analysis_functions
 ]

edmt-1.0.7.post1/edmt/workflow/analysis.py

@@ -0,0 +1,493 @@
+import math
+import pandas as pd
+import numpy as np
+import geopandas as gpd
+from shapely.geometry import box
+
+import pandas as pd
+import numpy as np
+from typing import Optional, Tuple, List
+
+
+
+def create_ROI(
+    latitude: float,
+    longitude: float,
+    extent_km: float = 100.0,
+    name: str = "AOI",
+    ) -> gpd.GeoDataFrame:
+    """
+    Create a square bounding box polygon centered on a WGS84 coordinate.
+
+    Parameters
+    ----------
+    latitude : float
+        Center latitude in decimal degrees (WGS84 / EPSG:4326).
+    longitude : float
+        Center longitude in decimal degrees (WGS84 / EPSG:4326).
+    extent_km : float, optional
+        Full side length of the bounding box in kilometres (default: 100).
+        e.g. 10 → 10 km × 10 km box centered on the coordinate.
+    name : str, optional
+        Label for the polygon feature (default: "AOI").
+
+    Returns
+    -------
+    gpd.GeoDataFrame
+        Single-row GeoDataFrame (EPSG:4326) with columns:
+        name, latitude, longitude, extent_km, geometry.
+
+    Notes
+    -----
+    Degree-to-metre conversion uses the WGS84 approximation:
+        1° latitude  ≈ 111 320 m  (constant)
+        1° longitude ≈ 111 320 × cos(lat) m  (varies with latitude)
+    """
+    _KM_TO_M: float = 1_000.0
+    extent_m: float = extent_km * _KM_TO_M
+ 
+    _METRES_PER_DEGREE_LAT: float = 111_320.0
+    metres_per_degree_lon: float = _METRES_PER_DEGREE_LAT * math.cos(
+        math.radians(latitude)
+    )
+
+    half_extent_m: float = extent_m / 2.0
+    delta_lat: float = half_extent_m / _METRES_PER_DEGREE_LAT
+    delta_lon: float = half_extent_m / metres_per_degree_lon
+
+    west: float  = longitude - delta_lon
+    east: float  = longitude + delta_lon
+    south: float = latitude  - delta_lat
+    north: float = latitude  + delta_lat
+
+    bbox_geom = box(west, south, east, north)
+
+    return gpd.GeoDataFrame(
+        {
+            "name":       [name],
+            "latitude":   [latitude],
+            "longitude":  [longitude],
+            "extent_km":  [extent_km],
+            "geometry":   [bbox_geom],
+        },
+        crs="EPSG:4326",
+    )
+
+
+
+NDVI_WET_THRESHOLD: float = 0.5
+
+def _otsu_threshold(values: np.ndarray) -> float:
+    """
+    1-D Otsu's method: find the cut-point that maximises
+    between-class variance in `values`.
+    """
+    sorted_vals = np.sort(values)
+    best_thresh = sorted_vals[0]
+    best_var = -np.inf
+ 
+    for t in sorted_vals[1:]:
+        below = values[values < t]
+        above = values[values >= t]
+ 
+        if len(below) == 0 or len(above) == 0:
+            continue
+ 
+        w0, w1 = len(below) / len(values), len(above) / len(values)
+        between_var = w0 * w1 * (below.mean() - above.mean()) ** 2
+ 
+        if between_var > best_var:
+            best_var = between_var
+            best_thresh = float(t)
+ 
+    return best_thresh
+ 
+ 
+def _minmax_normalize_fixed(
+    series: pd.Series,
+    scale_min: float,
+    scale_max: float,
+) -> pd.Series:
+    """
+    Rescale a Series to [0, 1] using a *fixed* global range instead of
+    the data's own min/max.  Values outside [scale_min, scale_max] are
+    clipped before normalisation.
+ 
+    Using fixed bounds prevents the pathological amplification that occurs
+    when all data values occupy a very narrow band (e.g. NDVI 0.094–0.101
+    treated as if it spans the full 0–1 range).
+    """
+    clipped = series.clip(lower=scale_min, upper=scale_max)
+    return (clipped - scale_min) / (scale_max - scale_min)
+ 
+ 
+def _aggregate_to_monthly(
+    df: pd.DataFrame,
+    date_col: str,
+    value_col: str,
+    agg_func: str,
+    out_col: str,
+) -> pd.DataFrame:
+    """Parse dates, extract year/month, and aggregate value_col."""
+    work = df[[date_col, value_col]].copy()
+    work[date_col] = pd.to_datetime(work[date_col])
+    work["year"] = work[date_col].dt.year
+    work["month"] = work[date_col].dt.month
+    monthly = (
+        work.groupby(["year", "month"])[value_col]
+        .agg(agg_func)
+        .reset_index()
+        .rename(columns={value_col: out_col})
+    )
+    return monthly
+
+
+
+# Compute ndvi Seasons  (WET & DRY)
+
+def classify_ndvi_seasons(
+    df: pd.DataFrame,
+    date_col: str = "date",
+    ndvi_col: str = "ndvi",
+    threshold: float = None,
+    threshold_method: str = "discrete",
+    wet_label: str = "Wet",
+    dry_label: str = "Dry",
+    agg_func: str = "mean",
+) -> pd.DataFrame:
+    """
+    Aggregate NDVI observations to monthly means and classify each
+    month as a wet or dry period based on a vegetation threshold.
+ 
+    Parameters
+    ----------
+    df : pd.DataFrame
+        Input DataFrame containing at minimum a date and NDVI column.
+    date_col : str, optional
+        Name of the date column (default: "date").
+    ndvi_col : str, optional
+        Name of the NDVI column (default: "ndvi").
+    threshold : float, optional
+        Explicit NDVI cut-off on the true -1 to +1 scale.
+        Overrides `threshold_method` when supplied.
+        Months with mean NDVI >= threshold → wet; below → dry.
+        
+    threshold_method : str, optional
+        Auto-threshold strategy used when `threshold` is None:
+ 
+        "discrete" – Ecological fixed threshold from the NDVI scale
+                     (NDVI_WET_THRESHOLD = 0.25 by default).
+                     **Recommended** — anchors the result to real-world
+                     vegetation meaning regardless of data range. (default)
+        "otsu"     – Maximises between-class variance within the data.
+                     Only meaningful when the data spans a wide dynamic
+                     range (e.g. > 0.15 spread). Avoid for narrow-band data.
+        "median"   – Median of monthly means.
+        "mean"     – Mean of monthly means.
+ 
+    wet_label : str, optional
+        Label for wet months (default: "Wet").
+    dry_label : str, optional
+        Label for dry months (default: "Dry").
+    agg_func : str, optional
+        Aggregation function applied per month:
+        "mean" | "median" | "max" (default: "mean").
+ 
+    Returns
+    -------
+    pd.DataFrame
+        Monthly DataFrame ordered chronologically with columns:
+        year, month, month_name, ndvi_mean, threshold, season,
+        ndvi_vegetation_class.
+ 
+        ndvi_vegetation_class  →  human-readable land-cover interpretation
+        derived from the true NDVI scale (independent of the wet/dry split).
+ 
+    Notes
+    -----
+    The "discrete" method (default) anchors classification to the actual
+    NDVI scale (-1 to +1).  Statistical methods (otsu/median/mean) find a
+    threshold *within* the observed data range, which can produce misleading
+    results when all values are clustered in a narrow band — e.g. labelling
+    a month as "Wet" simply because its NDVI is 0.001 above the rest, even
+    though 0.10 is objectively bare soil by any vegetation index standard.
+    """
+    if date_col not in df.columns:
+        raise KeyError(f"Date column '{date_col}' not found in DataFrame.")
+    if ndvi_col not in df.columns:
+        raise KeyError(f"NDVI column '{ndvi_col}' not found in DataFrame.")
+ 
+    _VALID_AGG = {"mean", "median", "max"}
+    if agg_func not in _VALID_AGG:
+        raise ValueError(f"agg_func must be one of {_VALID_AGG}, got '{agg_func}'.")
+ 
+    _VALID_METHODS = {"discrete", "otsu", "median", "mean"}
+    if threshold_method not in _VALID_METHODS:
+        raise ValueError(
+            f"threshold_method must be one of {_VALID_METHODS}, "
+            f"got '{threshold_method}'."
+        )
+ 
+    work = df[[date_col, ndvi_col]].copy()
+    work[date_col] = pd.to_datetime(work[date_col])
+    work["year"] = work[date_col].dt.year
+    work["month"] = work[date_col].dt.month
+ 
+    monthly: pd.DataFrame = (
+        work.groupby(["year", "month"])[ndvi_col]
+        .agg(agg_func)
+        .reset_index()
+        .rename(columns={ndvi_col: "ndvi_mean"})
+    )
+ 
+    monthly["_period"] = pd.to_datetime(monthly[["year", "month"]].assign(day=1))
+    monthly = monthly.sort_values("_period").reset_index(drop=True)
+    monthly = monthly.drop(columns="_period")
+ 
+    monthly.insert(
+        2,
+        "month_name",
+        pd.to_datetime(monthly["month"], format="%m").dt.strftime("%B"),
+    )
+ 
+    if threshold is not None:
+        resolved_threshold = float(threshold)
+    elif threshold_method == "discrete":
+        resolved_threshold = NDVI_WET_THRESHOLD
+    elif threshold_method == "otsu":
+        resolved_threshold = _otsu_threshold(monthly["ndvi_mean"].to_numpy())
+    elif threshold_method == "median":
+        resolved_threshold = float(np.median(monthly["ndvi_mean"].to_numpy()))
+    else:  # mean
+        resolved_threshold = float(np.mean(monthly["ndvi_mean"].to_numpy()))
+ 
+    # monthly["threshold"] = round(resolved_threshold, 6)
+    monthly["season"] = np.where(
+        monthly["ndvi_mean"] >= resolved_threshold, wet_label, dry_label
+    )
+ 
+    monthly["ndvi_class"] = pd.cut(
+        monthly["ndvi_mean"],
+        bins=[-1.0, 0.0, 0.10, 0.20, 0.35, 0.50, 0.70, 1.0],
+        labels=[
+            "Water / Non-vegetated",
+            "Bare Soil / Arid",
+            "Very Sparse Vegetation",
+            "Sparse Grassland / Shrubland",
+            "Moderate Vegetation",
+            "Dense Vegetation",
+            "Very Dense / Forest",
+        ],
+        include_lowest=True,
+    ).astype(str)
+ 
+    return monthly
+ 
+
+
+_DEFAULT_SEASON_LABELS: List[str] = [
+    "Dry Season",
+    "Dry-Wet Transition",
+    "Rainfall Onset",
+    "Wet Season",
+    "Rainy Season",
+]
+
+_WET_LABELS = {"Rainy Season", "Wet Season", "Rainfall Onset"}
+_TRANSITION_LABEL = "Dry-Wet Transition"
+_DRY_LABEL = "Dry Season"
+
+
+def _minmax_normalize(series: pd.Series) -> pd.Series:
+    """Rescale a Series to [0, 1]. Returns 0.5 if all values are identical."""
+    s_min, s_max = series.min(), series.max()
+    if s_max == s_min:
+        return pd.Series(0.5, index=series.index)
+    return (series - s_min) / (s_max - s_min)
+
+
+def _aggregate_to_monthly(
+    df: pd.DataFrame,
+    date_col: str,
+    value_col: str,
+    agg_func: str,
+    out_col: str,
+) -> pd.DataFrame:
+    """Parse dates, extract year/month, and aggregate value_col."""
+    work = df[[date_col, value_col]].copy()
+    work[date_col] = pd.to_datetime(work[date_col])
+    work["year"]  = work[date_col].dt.year
+    work["month"] = work[date_col].dt.month
+    monthly = (
+        work.groupby(["year", "month"])[value_col]
+        .agg(agg_func)
+        .reset_index()
+        .rename(columns={value_col: out_col})
+    )
+    return monthly
+
+
+# Compute classification of climate seasons
+
+def classify_climate_seasons(
+    df_ndvi: pd.DataFrame,
+    df_rainfall: pd.DataFrame,
+    df_lst: pd.DataFrame,
+    ndvi_date_col: str = "date",
+    ndvi_col: str = "ndvi",
+    rainfall_date_col: str = "date",
+    rainfall_col: str = "precipitation_mm",
+    lst_date_col: str = "date",
+    lst_col: str = "mean",
+    weights: Tuple[float, float, float] = (0.40, 0.35, 0.25),
+    category_labels: Optional[List[str]] = None,
+    rainfall_gate_mm: float = 1.0,    
+    transition_gate_mm: float = 15.0,  
+) -> pd.DataFrame:
+    """
+    Merge monthly NDVI, rainfall, and LST data, then classify each month
+    into one of five climate seasons using a normalised composite score.
+
+    Composite score (0 = driest, 1 = wettest)
+    ------------------------------------------
+    score = w_rain  × rainfall_norm
+          + w_ndvi  × ndvi_norm
+          + w_temp  × (1 − temp_norm)   ← inverted: high temp → dry
+
+    Rainfall gate (applied after scoring)
+    --------------------------------------
+    Prevents non-dry labels when rainfall is negligible, regardless of
+    what NDVI or LST suggest:
+
+      rainfall_mm < rainfall_gate_mm   → forced "Dry Season"
+      rainfall_mm < transition_gate_mm → capped at "Dry-Wet Transition"
+                                         (only if score-based label is wetter)
+
+    Parameters
+    ----------
+    df_ndvi : pd.DataFrame
+        16-day or finer NDVI observations (aggregated to monthly mean).
+    df_rainfall : pd.DataFrame
+        Weekly or finer precipitation observations (aggregated to monthly sum).
+    df_lst : pd.DataFrame
+        Monthly or finer LST observations (aggregated to monthly mean).
+    ndvi_date_col : str
+        Date column in df_ndvi (default: "date").
+    ndvi_col : str
+        NDVI value column (default: "ndvi").
+    rainfall_date_col : str
+        Date column in df_rainfall (default: "date").
+    rainfall_col : str
+        Precipitation column (default: "precipitation_mm").
+    lst_date_col : str
+        Date column in df_lst (default: "date").
+    lst_col : str
+        LST value column (default: "mean").
+    weights : tuple of 3 floats
+        Relative importance of (rainfall, ndvi, temperature). Must sum to 1.0
+        (default: 0.40, 0.35, 0.25).
+    category_labels : list of 5 str, optional
+        Custom season names ordered driest → wettest.
+    rainfall_gate_mm : float, optional
+        Monthly rainfall (mm) below which a month is forced to "Dry Season",
+        regardless of NDVI or LST (default: 1.0 mm).
+    transition_gate_mm : float, optional
+        Monthly rainfall (mm) below which a month is capped at
+        "Dry-Wet Transition" if the score would place it in a wetter
+        category (default: 5.0 mm).
+
+    Returns
+    -------
+    pd.DataFrame
+        Chronologically sorted monthly DataFrame with columns:
+        year, month, month_name, rainfall_mm, ndvi_mean, lst_mean,
+        composite_score, season, season_source.
+
+        season_source: "score" if the label came from the composite score,
+                       "rainfall_gate" if it was overridden.
+    """
+    if rainfall_gate_mm > transition_gate_mm:
+        raise ValueError(
+            f"rainfall_gate_mm ({rainfall_gate_mm}) must be ≤ "
+            f"transition_gate_mm ({transition_gate_mm})."
+        )
+
+    w_rain, w_ndvi, w_temp = weights
+    if not abs(sum(weights) - 1.0) < 1e-6:
+        raise ValueError(
+            f"weights must sum to 1.0, got {sum(weights):.4f}. "
+            f"Received: rainfall={w_rain}, ndvi={w_ndvi}, temperature={w_temp}."
+        )
+
+    labels = category_labels or _DEFAULT_SEASON_LABELS
+    if len(labels) != 5:
+        raise ValueError(
+            f"category_labels must contain exactly 5 labels, got {len(labels)}."
+        )
+
+    dry_label        = labels[0] 
+    transition_label = labels[1] 
+    wet_labels       = set(labels[2:]) 
+
+    monthly_rainfall = _aggregate_to_monthly(
+        df_rainfall, rainfall_date_col, rainfall_col, "sum", "rainfall_mm"
+    )
+    monthly_ndvi = _aggregate_to_monthly(
+        df_ndvi, ndvi_date_col, ndvi_col, "mean", "ndvi_mean"
+    )
+    monthly_lst = _aggregate_to_monthly(
+        df_lst, lst_date_col, lst_col, "mean", "lst_mean"
+    )
+
+    merged = (
+        monthly_rainfall
+        .merge(monthly_ndvi, on=["year", "month"], how="inner")
+        .merge(monthly_lst,  on=["year", "month"], how="inner")
+    )
+
+    merged["_period"] = pd.to_datetime(merged[["year", "month"]].assign(day=1))
+    merged = merged.sort_values("_period").reset_index(drop=True)
+    merged.insert(2, "month_name", merged["_period"].dt.strftime("%B"))
+    merged = merged.drop(columns="_period")
+
+    merged["_rain_norm"] = _minmax_normalize(merged["rainfall_mm"])
+    merged["_ndvi_norm"] = _minmax_normalize(merged["ndvi_mean"])
+    merged["_temp_norm"] = _minmax_normalize(merged["lst_mean"])
+
+    merged["composite_score"] = (
+        w_rain * merged["_rain_norm"]
+        + w_ndvi * merged["_ndvi_norm"]
+        + w_temp * (1 - merged["_temp_norm"])
+    ).round(4)
+
+    merged = merged.drop(columns=["_rain_norm", "_ndvi_norm", "_temp_norm"])
+
+    merged["season"] = pd.cut(
+        merged["composite_score"],
+        bins=5,
+        labels=labels,
+        include_lowest=True,
+    ).astype(str)
+
+    merged["season_source"] = "score"
+
+    transition_mask = (
+        (merged["rainfall_mm"] < transition_gate_mm) &
+        (merged["rainfall_mm"] >= rainfall_gate_mm) &
+        (merged["season"].isin(wet_labels))
+    )
+    merged.loc[transition_mask, "season"]        = transition_label
+    merged.loc[transition_mask, "season_source"] = "rainfall_gate"
+
+    dry_mask = merged["rainfall_mm"] < rainfall_gate_mm
+    merged.loc[dry_mask, "season"]        = dry_label
+    merged.loc[dry_mask, "season_source"] = "rainfall_gate"
+
+    return merged[[
+        "year", "month", "month_name",
+        "rainfall_mm", "ndvi_mean", "lst_mean",
+        "composite_score", "season"
+    ]]
+
+
+

{edmt-1.0.7.dev1 → edmt-1.0.7.post1}/edmt/workflow/builder.py

@@ -123,6 +123,7 @@ _PRODUCT_REGISTRY = {
     "NDVI": "vegetation",
     "EVI": "vegetation",
     "CHIRPS": "chirps",
+    "FLOODING": "flooding",
 }
 
 
@@ -182,6 +183,14 @@ _SAT_CONFIG = {
             "scale_m": 250,
             "direct": True,
         },
+    },
+
+    "FLOODING": {
+        "SENTINEL1": {
+            "collection": "COPERNICUS/S1_GRD",
+            "band": "VH",
+            "scale_m": 10,
+        }
     }
 }
 
@@ -373,6 +382,27 @@ def _build_chirps(start_date, end_date):
     return ic, {"bands": ["precipitation"], "scale_m": 5500}
 
 
+# Flooding pipeline
+
+def _build_flooding(satellite, start_date, end_date):
+    sat = _norm_sat(satellite)
+
+    if sat != "SENTINEL1":
+        raise ValueError(f"Unsupported flooding satellite: {satellite}")
+
+    ic = (
+        ee.ImageCollection(_SAT_CONFIG["FLOODING"]["SENTINEL1"]["collection"])
+        .filterDate(start_date, end_date)
+        .filter(ee.Filter.listContains("transmitterReceiverPolarisation", "VH"))
+        .select(["VH"])
+        .map(lambda img: img.rename("VH").copyProperties(img, ["system:time_start"]))
+    )
+
+    return ic, {
+        "bands": ["VH"],
+        "scale_m": _SAT_CONFIG["FLOODING"]["SENTINEL1"]["scale_m"],
+        "satellite": sat,
+    }
 
 # 3 : COMPUTATION
 
@@ -456,6 +486,7 @@ _COMPUTE_REGISTRY = {
     "NDVI": _compute_veg,
     "EVI": _compute_veg,
     "LST": _compute_lst,
+    "FLOOD":_build_flooding
 }
 
 

{edmt-1.0.7.dev1 → edmt-1.0.7.post1}/edmt/workflow/connector.py

@@ -11,6 +11,7 @@ from .builder import (
 
     _PRODUCT_REGISTRY,
     _build_vegetation,
+    _build_flooding,
 
     _norm_sat,
     _build_chirps,
@@ -92,6 +93,9 @@ def get_satellite_collection(
     elif pipeline == "lst":
         ic, meta = _build_lst(satellite, start_date, end_date)
 
+    elif pipeline == "flooding":
+        ic, meta = _build_flooding(satellite, start_date, end_date)
+
     elif pipeline == "chirps":
         ic, meta = _build_chirps(start_date, end_date)
 
@@ -200,7 +204,7 @@ def ComputeTimeseries(
     roi_gdf: gpd.GeoDataFrame,
     satellite: Optional[str] = None,
     scale: Optional[int] = None,
-) -> pd.DataFrame:
+    ) -> pd.DataFrame:
     """
     Generate a time series of environmental metrics (e.g., NDVI, LST, precipitation) over a region of interest.
 
@@ -316,6 +320,10 @@ def ComputeTimeseries(
         if "precipitation_mm" in df.columns:
             df = df[df["precipitation_mm"].notna()]
 
+    # elif prod == "CHIRPS":
+    #     if "precipitation_mm" in df.columns:
+    #         df = df[df["precipitation_mm"].notna()]
+
     elif prod in ("NDVI", "EVI"):
         key = prod.lower()
         if key in df.columns:

{edmt-1.0.7.dev1 → edmt-1.0.7.post1}/edmt.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: edmt
-Version: 1.0.7.dev1
+Version: 1.0.7.post1
 Summary: Environmental Data Management Toolbox
 Author-email: "Odero, Kuloba & musasia" <francisodero10@gmail.com>
 License: MIT License
@@ -47,12 +47,13 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: duckdb<1.3.2,>=0.9
 Requires-Dist: earthengine-api<1.8,>=0.1.324
-Requires-Dist: geopandas>=1
-Requires-Dist: pandas<3
+Requires-Dist: geopandas<2,>=1.0
+Requires-Dist: pandas<3,>=2.2
 Requires-Dist: fiona<1.10.1,>=1.9.6
 Requires-Dist: tqdm>=4
 Requires-Dist: requests<3,>=2.28
 Requires-Dist: matplotlib>=3.9
+Requires-Dist: qrcode
 Dynamic: license-file
 
 <h1 align="center">EDMT — Environmental Data Management Toolbox</h1>

{edmt-1.0.7.dev1 → edmt-1.0.7.post1}/edmt.egg-info/SOURCES.txt

@@ -17,10 +17,12 @@ edmt/contrib/utils.py
 edmt/conversion/__init__.py
 edmt/conversion/conversion.py
 edmt/mapping/__init__.py
+edmt/mapping/carto.py
 edmt/models/__init__.py
 edmt/models/drones.py
 edmt/plotting/__init__.py
 edmt/workflow/__init__.py
+edmt/workflow/analysis.py
 edmt/workflow/builder.py
 edmt/workflow/connector.py
 edmt/workflow/workflow.py

{edmt-1.0.7.dev1 → edmt-1.0.7.post1}/edmt.egg-info/requires.txt

@@ -1,8 +1,9 @@
 duckdb<1.3.2,>=0.9
 earthengine-api<1.8,>=0.1.324
-geopandas>=1
-pandas<3
+geopandas<2,>=1.0
+pandas<3,>=2.2
 fiona<1.10.1,>=1.9.6
 tqdm>=4
 requests<3,>=2.28
 matplotlib>=3.9
+qrcode

{edmt-1.0.7.dev1 → edmt-1.0.7.post1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "edmt"
-version = "1.0.7.dev1"
+version = "1.0.7post1"
 description = "Environmental Data Management Toolbox"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -47,12 +47,13 @@ keywords = [
 dependencies = [
   "duckdb>=0.9,<1.3.2",
   "earthengine-api>=0.1.324,<1.8",
-  "geopandas>=1",
-  "pandas<3",
+  "geopandas>=1.0,<2",
+  "pandas>=2.2,<3",
   "fiona>=1.9.6,<1.10.1",
   "tqdm>=4",
   "requests>=2.28,<3",
   "matplotlib>=3.9",
+  "qrcode",
 ]
 
 

edmt-1.0.7.dev1/edmt/mapping/__init__.py

@@ -1,3 +0,0 @@
-__all__ = [
-    
-]