pyreclaim 0.3.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

reclaim/generate_features.py

@@ -2,40 +2,56 @@
 
 from typing import Dict, List
 import pandas as pd
+import geopandas as gpd
+from tqdm import tqdm
+import traceback
+from dask import delayed, compute
+from dask.diagnostics import ProgressBar
 
 # Import from your package structure
 from reclaim.static_features.reservoir_static import reservoir_based_static_features
-from reclaim.static_features.catchment_static import catchment_based_static_features
+from reclaim.static_features.catchment_static import catchment_based_static_features, catchment_based_static_features_multi_reservoir
 from reclaim.dynamic_features.reservoir_dynamic import reservoir_based_dynamic_features
 from reclaim.dynamic_features.catchment_dynamic import catchment_based_dynamic_features
+from reclaim.dynamic_features.utils.ts_aggregate import build_intervals
 from reclaim.derived_features.feature_engineering_and_transformation import engineer_and_transform_features
 
 
-def create_features_per_row(
+def create_features_per_reservoir(
+    idx: int,
+    observation_period: List[int],
     reservoir_static_params: dict,
-    catchment_static_params: dict,
+    catchment_static_params: dict = None,
     reservoir_dynamic_info: dict = None,
     catchment_dynamic_info: dict = None,
-    observation_period: List[int] = None
+    time_interval: int = None,
+    feature_engineering: bool = True,
 ) -> pd.DataFrame:
     """
     Compute all static, dynamic, and derived features for a single reservoir observation.
 
     Parameters
     ----------
+    idx : int
+        Index of the reservoir sedimentation observation (for tracking/logging purposes).
+    
+    observation_period : list of int
+        Two-element list [OSY, OEY] for observation start year and end year.
+        
     reservoir_static_params : dict
         Parameters for reservoir_based_static_features(). Expected keys:
             - obc : float, Original Built Capacity (MCM)
             - hgt : float, Dam Height (m)
-            - mrb : str, Major River Basin, optional
+            - mrb : int, Major River Basin, optional
             - lat : float, Latitude (deg)
             - lon : float, Longitude (deg)
+            - by : int, Build Year
             - reservoir_polygon : shapely.geometry.Polygon
             - inlet_point : shapely.geometry.Point, optional
             - resolution : float, optional
             - aec_df : pd.DataFrame with columns ['area', 'elevation']
 
-    catchment_static_params : dict
+    catchment_static_params : dict, optional
         Parameters for catchment_based_static_features(). Expected keys:
             - ca : float, Catchment Area (sq km)
             - dca : float, Differential Catchment Area (sq km)
@@ -61,9 +77,9 @@ def create_features_per_row(
             - "tmax":   {"path": str, "time_column": str, "data_column": str}
             - "wind":   {"path": str, "time_column": str, "data_column": str}
 
-    observation_period : list of int, optional
-        Two-element list [OSY, OEY] for observation start year and end year.
-
+    time_interval: int, optional
+        Time interval in years between reservoir observations for dynamic feature calculations. The number of rows in the dynamic features will depend on this interval.
+    
     Returns
     -------
     pd.DataFrame
@@ -72,34 +88,88 @@ def create_features_per_row(
         - Catchment static
         - Reservoir dynamic
         - Catchment dynamic
-        - Derived/log-transformed
+        - Derived/log-transformed (if requested)
     """
+    
+    # --- Observevation period features ---
+    osy, oey = observation_period
+    if time_interval is not None:
+        intervals = build_intervals(osy, oey, time_interval)
+    else:
+        intervals = [(osy, oey)]
+    # Create observation period dataframe with rows for each interval with same idx
+    df_obs = pd.DataFrame({
+    "idx": idx,
+    "OSY": [i[0] for i in intervals],
+    "OEY": [i[1] for i in intervals],
+    })
 
-    # --- Static features ---
+    # --- Static features (computed ONCE) ---
     df_res_static = reservoir_based_static_features(**reservoir_static_params)
-    df_catch_static = catchment_based_static_features(**catchment_static_params)
-
-    # --- Dynamic features ---
-    df_res_dyn = pd.DataFrame()
-    df_catch_dyn = pd.DataFrame()
-
-    if reservoir_dynamic_info is not None and observation_period is not None:
-        df_res_dyn = reservoir_based_dynamic_features(reservoir_dynamic_info, observation_period)
+    if catchment_static_params is not None:
+        df_catch_static = catchment_based_static_features(**catchment_static_params)
+    else:
+        df_catch_static = pd.DataFrame()
+    
+    static_block = pd.concat([df_res_static, df_catch_static], axis=1)
+    # Repeat static rows to match number of intervals
+    static_block = pd.concat(
+        [static_block] * len(df_obs),
+        ignore_index=True
+    )
 
-    if catchment_dynamic_info is not None and observation_period is not None:
-        df_catch_dyn = catchment_based_dynamic_features(catchment_dynamic_info, observation_period)
+    # --- Dynamic features (computed ONCE - internally handles intervals) ---
+    # Combine dynamic features for all intervals
+    df_res_dyn = (
+        reservoir_based_dynamic_features(
+            reservoir_dynamic_info,
+            intervals,
+        )
+        if reservoir_dynamic_info is not None
+        else pd.DataFrame()
+    )
 
-    # --- Combine all static + dynamic ---
-    df_combined = pd.concat([df_res_static, df_catch_static, df_res_dyn, df_catch_dyn], axis=1)
+    df_catch_dyn = (
+        catchment_based_dynamic_features(
+            catchment_dynamic_info,
+            intervals,
+        )
+        if catchment_dynamic_info is not None
+        else pd.DataFrame()
+    )
+    
+    # --- Combine all features for all intervals in single dataframe ---
+    df_out = pd.concat(
+        [df_obs, static_block, df_res_dyn, df_catch_dyn],
+        axis=1
+    ).reset_index(drop=True)
 
-    # --- Engineer + log-transform features ---
-    df_final = engineer_and_transform_features(df_combined)
+    # --- Engineer ONLY if requested ---
+    if feature_engineering:
+        df_out = engineer_and_transform_features(df_out)
 
-    return df_final
+    return df_out
 
+@delayed
+def process_one_reservoir(r):
+    try:
+        df = create_features_per_reservoir(
+            idx=r["idx"],
+            observation_period=r["observation_period"],
+            reservoir_static_params=r["reservoir_static_params"],
+            catchment_static_params=None,
+            reservoir_dynamic_info=r.get("reservoir_dynamic_info"),
+            catchment_dynamic_info=r.get("catchment_dynamic_info"),
+            time_interval=r.get("time_interval"),
+            feature_engineering=False,
+        )
+        return r["idx"], df, None
+    except Exception as e:
+        return r["idx"], pd.DataFrame({"idx": [r["idx"]]}), {str(e):traceback.format_exc()}
 
-def create_features_multi(
-    reservoirs_input: List[Dict]
+def create_features_multi_reservoirs(
+    reservoirs_input: List[Dict],
+    error_log: bool = False,
 ) -> pd.DataFrame:
     """
     Compute features for multiple reservoirs using structured input.
@@ -109,6 +179,10 @@ def create_features_multi(
     reservoirs_input : list of dict
         Each element should be a dictionary with the following keys:
         
+        - `idx` : int
+            Index of the reservoir sedimentation observation.
+        - `observation_period` : list of int
+            Two-element list `[OSY, OEY]` specifying the observation period.
         - `reservoir_static_params` : dict
             Parameters for `reservoir_based_static_features()`.
         - `catchment_static_params` : dict
@@ -117,25 +191,107 @@ def create_features_multi(
             Parameters for `reservoir_based_dynamic_features()`.
         - `catchment_dynamic_info` : dict
             Parameters for `catchment_based_dynamic_features()`.
-        - `observation_period` : list of int
-            Two-element list `[OSY, OEY]` specifying the observation period.
+        - `time_interval` : int, optional
+            Time interval in years between reservoir observations for dynamic feature calculations.
 
     Returns
     -------
     pd.DataFrame
-        Combined DataFrame with one row per reservoir observation.
+        Combined DataFrame with one row per reservoir and time intervals
+        in the observation period.
     """
 
-    all_rows = []
-    for idx, reservoir_info in enumerate(reservoirs_input):
-        df_row = create_features_per_row(
-            reservoir_static_params=reservoir_info.get("reservoir_static_params", {}),
-            catchment_static_params=reservoir_info.get("catchment_static_params", {}),
-            reservoir_dynamic_info=reservoir_info.get("reservoir_dynamic_info", None),
-            catchment_dynamic_info=reservoir_info.get("catchment_dynamic_info", None),
-            observation_period=reservoir_info.get("observation_period", None),
-        )
-        all_rows.append(df_row)
+    # -------- Collect catchments first (cheap, no tqdm needed)
+    catchment_rows = []
+
+    for r in reservoirs_input:
+        c = r["catchment_static_params"]
+        catchment_rows.append({
+            "idx": r["idx"],
+            "CA": c["ca"],
+            "DCA": c["dca"],
+            "geometry": c["catchment_geometry"],
+        })
+
+    catchments_gdf = gpd.GeoDataFrame(
+        catchment_rows, geometry="geometry", crs="EPSG:4326"
+    )
+
+    # -------- Compute catchment static ONCE
+    first = reservoirs_input[0]["catchment_static_params"]
+
+    df_catch_static_all = catchment_based_static_features_multi_reservoir(
+        catchments_gdf,
+        glc_share_path=first["glc_share_path"],
+        hwsd2_path=first["hwsd2_path"],
+        hilda_veg_freq_path=first["hilda_veg_freq_path"],
+        terrain_path=first["terrain_path"],
+    )
+    
+    catch_static_lookup = df_catch_static_all.set_index("idx")
+    # catch_static_lookup = pd.DataFrame()  # Placeholder if not computing
+
+    # -------- Per-reservoir loop (tqdm HERE)
+    tasks = [process_one_reservoir(r) for r in reservoirs_input]
+    with ProgressBar():
+        results = compute(*tasks, scheduler="processes", num_workers=4)
+    
+    all_reservoirs_static_info = []
+    errors = {}
+    
+    for idx, df, err in results:
+        all_reservoirs_static_info.append(df)
+        if err is not None:
+            errors[idx] = err
+
+    # for r in tqdm(
+    #     reservoirs_input,
+    #     total=len(reservoirs_input),
+    #     desc="Generating per-reservoir features",
+    #     unit="reservoir",
+    # ):
+    #     try:
+    #         df = create_features_per_reservoir(
+    #             idx=r["idx"],
+    #             observation_period=r["observation_period"],
+    #             reservoir_static_params=r["reservoir_static_params"],
+    #             catchment_static_params=None,  # already handled
+    #             reservoir_dynamic_info=r.get("reservoir_dynamic_info"),
+    #             catchment_dynamic_info=r.get("catchment_dynamic_info"),
+    #             time_interval=r.get("time_interval"),
+    #             feature_engineering=False,
+    #         )
+    #         all_reservoirs_static_info.append(df)
+    #     except Exception as e:
+    #         errors[r["idx"]] = e
+    #         errors['traceback'] = traceback.print_exc()
+    #         all_reservoirs_static_info.append(
+    #             pd.DataFrame({"idx": r["idx"]})  # Append empty DataFrame for failed reservoir
+    #         )
+            
+            
+
+    # -------- Concatenate static info
+    df_all = pd.concat(all_reservoirs_static_info, ignore_index=True)
+    # CRITICAL: restore logical ordering
+    df_all = df_all.sort_values(
+        by=["idx", "OSY"],   #
+        ascending=[True, True],
+    ).reset_index(drop=True)
+    
+    
+    # -------- Merge static catchment features with dynamic ONCE
+    df_all = df_all.merge(
+        catch_static_lookup,
+        left_on="idx",
+        right_index=True,
+        how="left",
+    )
 
-    df_all = pd.concat(all_rows, axis=0).reset_index(drop=True)
-    return df_all
+    # -------- Engineer ONCE
+    df_all = engineer_and_transform_features(df_all)
+    
+    if error_log:
+        return df_all, errors
+    else:
+        return df_all

reclaim/reclaim.py

@@ -1,5 +1,6 @@
 import os
 import pandas as pd
+from pandas.api.types import is_integer_dtype, is_string_dtype
 import numpy as np
 from sklearn.preprocessing import LabelEncoder
 from sklearn.metrics import  r2_score, mean_absolute_error,  root_mean_squared_error
@@ -189,12 +190,22 @@ class Reclaim:
             if self.feature_order_list is not None:
                 # Reorder columns automatically
                 X = X[self.feature_order_list]
+                # for col in self.cat_features:
+                #     X[col] = X[col].astype("category")
         elif isinstance(X, np.ndarray):
             warnings.warn(
                     "Predicting with NumPy array: assumes column order matches training order. "
                     "Safer to use DataFrame with feature names."
                 )
             
+        if self.cat_features is not None:
+            for col in self.cat_features:
+                if not (is_integer_dtype(X[col]) or is_string_dtype(X[col])):
+                    raise ValueError(
+                        f"Column {col} must be integer or string type, "
+                        f"found {X[col].dtype}"
+                    )
+            
             
         # Base model predictions
         pred_xgb = self.xgb_model.predict(X)
@@ -476,19 +487,21 @@ class Reclaim:
             load_dir = os.path.join(package_dir, "pretrained_model")
 
         # Load XGBoost
-        xgb_path = os.path.join(load_dir, f"{prefix}_xgb.json")
+        xgb_path = os.path.join(load_dir, f"{prefix}_xgb.pkl")
         if os.path.exists(xgb_path):
-            self.xgb_model = xgb.XGBRegressor()
-            self.xgb_model.load_model(xgb_path)
+            import xgboost as xgb
+            self.xgb_model = joblib.load(xgb_path)
 
         # Load LightGBM
-        lgb_path = os.path.join(load_dir, f"{prefix}_lgb.txt")
+        lgb_path = os.path.join(load_dir, f"{prefix}_lgb.pkl")
         if os.path.exists(lgb_path):
-            self.lgb_model = lgb.Booster(model_file=lgb_path)
+            import lightgbm as lgb
+            self.lgb_model = joblib.load(lgb_path)
 
         # Load CatBoost
         cat_path = os.path.join(load_dir, f"{prefix}_cat.cbm")
         if os.path.exists(cat_path):
+            from catboost import CatBoostRegressor
             self.cat_model = CatBoostRegressor()
             self.cat_model.load_model(cat_path)
 

reclaim/static_features/catchment_static.py

@@ -1,6 +1,39 @@
+import geopandas as gpd
 import pandas as pd
 
-from reclaim.static_features.utils.catchment_agreggate import compute_catchment_aggregate
+from reclaim.static_features.utils.catchment_agreggate import compute_catchment_aggregate, compute_catchment_aggregate_multi_reservoir
+
+# ---- Rename columns to abbreviations
+RENAME_VARIABLE_DICT = {
+    # Land cover
+    "artificial_surfaces_mean": "LCAS",
+    "cropland_mean": "LCC",
+    "grassland_mean": "LCG",
+    "tree_covered_mean": "LCT",
+    "shrubs_covered_mean": "LCS",
+    "aquatic_herbaceous_mean": "LCHV",
+    "mangroves_mean": "LCM",
+    "sparse_vegetation_mean": "LCSV",
+    "bare_soil_mean": "LCBS",
+    "snow_glaciers_mean": "LCSG",
+    "waterbodies_mean": "LCWB",
+    "dominant_class_mode": "DLC",
+    # Soil
+    "COARSE_mean": "COAR",
+    "SAND_mean": "SAND",
+    "SILT_mean": "SILT",
+    "CLAY_mean": "CLAY",
+    "BULK_mean": "BULK",
+    # Terrain
+    "elevation_mean": "ELEV",
+    "slope_mean": "SLOP",
+    "curvature_mean": "CURV",
+    "aspect_mean": "ASP",
+    "hillshade_mean": "HILL",
+    # HILDA (optional, not mapped to abbreviations yet)
+    "vegetation_gain_frequency_mean": "VGF",
+    "vegetation_loss_frequency_mean": "VLF",
+}
 
 def catchment_based_static_features(
     ca: float,
@@ -89,39 +122,81 @@ def catchment_based_static_features(
     merged = pd.concat([glc_df, hwsd_df, hilda_df, terrain_df], axis=1)
     features.update(merged.to_dict(orient="records")[0])
 
-    # ---- Rename columns to abbreviations
-    rename_dict = {
-        # Land cover
-        "artificial_surfaces_mean": "LCAS",
-        "cropland_mean": "LCC",
-        "grassland_mean": "LCG",
-        "tree_covered_mean": "LCT",
-        "shrubs_covered_mean": "LCS",
-        "aquatic_herbaceous_mean": "LCHV",
-        "mangroves_mean": "LCM",
-        "sparse_vegetation_mean": "LCSV",
-        "bare_soil_mean": "LCBS",
-        "snow_glaciers_mean": "LCSG",
-        "waterbodies_mean": "LCWB",
-        "dominant_class_mode": "DLC",
-        # Soil
-        "COARSE_mean": "COAR",
-        "SAND_mean": "SAND",
-        "SILT_mean": "SILT",
-        "CLAY_mean": "CLAY",
-        "BULK_mean": "BULK",
-        # Terrain
-        "elevation_mean": "ELEV",
-        "slope_mean": "SLOP",
-        "curvature_mean": "CURV",
-        "aspect_mean": "ASP",
-        "hillshade_mean": "HILL",
-        # HILDA (optional, not mapped to abbreviations yet)
-        "vegetation_gain_frequency_mean": "VGF",
-        "vegetation_loss_frequency_mean": "VLF",
+    # Apply renaming
+    features_df = pd.DataFrame([features]).rename(columns=RENAME_VARIABLE_DICT)
+
+    return features_df
+
+def catchment_based_static_features_multi_reservoir(
+    catchments_gdf: gpd.GeoDataFrame,
+    glc_share_path: str,
+    hwsd2_path: str,
+    hilda_veg_freq_path: str,
+    terrain_path: str,
+) -> pd.DataFrame:
+    """
+    Compute catchment-based static features for MULTIPLE reservoirs efficiently.
+
+    Parameters
+    ----------
+    catchments_gdf : geopandas.GeoDataFrame
+        Must contain columns:
+            - idx
+            - CA
+            - DCA
+            - geometry
+    glc_share_path : str
+        Path to the GLC-Share NetCDF file (land cover fractions).
+    hwsd2_path : str
+        Path to the HWSD2 NetCDF file (soil composition).
+    hilda_veg_freq_path : str
+        Path to the HILDA vegetation frequency NetCDF file.
+    terrain_path : str
+        Path to the terrain NetCDF file (DEM derivatives).
+
+    Returns
+    -------
+    pd.DataFrame
+        A single-row DataFrame with abbreviations as columns:
+        - CA, DCA, LCAS, LCC, LCG, LCT, LCS, LCHV, LCM, LCSV,
+        LCBS, LCSG, LCWB, DLC, COAR, SAND, SILT, CLAY, BULK,
+        ELEV, SLOP, CURV, ASP, HILL, VGF, VLF
+    """
+
+    base = catchments_gdf[["idx", "CA", "DCA"]].set_index("idx")
+
+    # --- Land cover
+    glc_dict = {
+        "artificial_surfaces": "mean",
+        "cropland": "mean",
+        "grassland": "mean",
+        "tree_covered": "mean",
+        "shrubs_covered": "mean",
+        "aquatic_herbaceous": "mean",
+        "mangroves": "mean",
+        "sparse_vegetation": "mean",
+        "bare_soil": "mean",
+        "snow_glaciers": "mean",
+        "waterbodies": "mean",
+        "dominant_class": "mode",
     }
 
-    # Apply renaming
-    features_df = pd.DataFrame([features]).rename(columns=rename_dict)
+    glc = compute_catchment_aggregate_multi_reservoir(
+        glc_share_path, catchments_gdf, glc_dict
+    )
+
+    hwsd = compute_catchment_aggregate_multi_reservoir(
+        hwsd2_path, catchments_gdf, "mean"
+    )
+
+    hilda = compute_catchment_aggregate_multi_reservoir(
+        hilda_veg_freq_path, catchments_gdf, "mean"
+    )
+
+    terrain = compute_catchment_aggregate_multi_reservoir(
+        terrain_path, catchments_gdf, "mean"
+    )
+
+    df = pd.concat([base, glc, hwsd, hilda, terrain], axis=1)
 
-    return features_df
+    return df.rename(columns=RENAME_VARIABLE_DICT).reset_index()

reclaim/static_features/reservoir_static.py

@@ -1,8 +1,10 @@
 import pandas as pd
+import geopandas as gpd
 from shapely.geometry import Point, Polygon
+import numpy as np
 
 # Import utils
-from reclaim.static_features.utils.flow_length import find_actual_flow_path
+from reclaim.static_features.utils.flow_length import find_actual_flow_path, plot_flow_length_with_reservoir
 from reclaim.static_features.utils.area_perimeter import calculate_length_area_meters
 from reclaim.static_features.utils.aec_shape import concavity_index, mean_curvature, mean_slope
 
@@ -13,10 +15,12 @@ def reservoir_based_static_features(
     mrb: str = None,
     lat: float = None,
     lon: float = None,
+    by: int = None,
     reservoir_polygon: Polygon = None,
     inlet_point: Point = None,
     resolution: float = None,
-    aec_df: pd.DataFrame = None
+    aec_df: pd.DataFrame = None,
+    savepath_flowpath_fig: str = None,
 ) -> pd.DataFrame:
     """
     Compute reservoir-based features for RECLAIM input dataset.
@@ -33,6 +37,8 @@ def reservoir_based_static_features(
         Latitude of dam location (degrees).
     lon : float, optional
         Longitude of dam location (degrees).
+    by : int, optional
+        Build year of the reservoir.
     reservoir_polygon : shapely.geometry.Polygon, optional
         Reservoir polygon geometry used to compute area and perimeter.
     dam_point : shapely.geometry.Point, optional
@@ -43,6 +49,8 @@ def reservoir_based_static_features(
         Spatial resolution used in flow length calculations.
     aec_df : pd.DataFrame, optional
         Area-Elevation Curve dataframe with columns ['area', 'elevation'].
+    savepath_flowpath_fig : str, optional
+        Path to save the flow path figure, optional.
     
     Returns
     -------
@@ -53,6 +61,7 @@ def reservoir_based_static_features(
         - MRB: Major River Basin
         - LAT: Latitude (deg)
         - LON: Longitude (deg)
+        - BY: Build Year
         - RA: Reservoir Area (sq km)
         - RP: Reservoir Perimeter (km)
         - FL: Flow Length (km)
@@ -67,6 +76,7 @@ def reservoir_based_static_features(
         "MRB": mrb,
         "LAT": lat,
         "LON": lon,
+        "BY": by,
         "RA": None,
         "RP": None,
         "FL": None,
@@ -76,22 +86,51 @@ def reservoir_based_static_features(
     }
 
     # Area and Perimeter
-    if reservoir_polygon is not None:
+    if reservoir_polygon is not None and not reservoir_polygon.is_empty:
         features["RP"], features["RA"] = calculate_length_area_meters(reservoir_polygon, area=True)
         features["RA"] = features["RA"] / 1e6  # m2 → km2
         features["RP"] = features["RP"] / 1e3  # m → km
+    else:
+        features["RP"] = np.nan
+        features["RA"] = np.nan
 
     # Flow Length
     dam_point = Point(lon, lat)
-    if dam_point is not None and reservoir_polygon is not None:
-        _, _, features["FL"], _ = (
-            find_actual_flow_path(dam_point, reservoir_polygon, inlet_point, resolution) / 1e3
-        )  # m → km
+    if dam_point is not None and reservoir_polygon is not None and not reservoir_polygon.is_empty:
+        try:
+            simplified_reservoir, far_end_point, flow_path, _ = (
+                find_actual_flow_path(dam_point, reservoir_polygon, inlet_point, resolution) 
+            )
+            if savepath_flowpath_fig is not None:
+                plot_flow_length_with_reservoir(
+                    dam_point,
+                    reservoir_polygon,
+                    far_end_point,
+                    flow_path,
+                    simplified_reservoir,
+                    savepath_flowpath_fig
+                )  
+            if flow_path is not None: 
+                gseries = gpd.GeoSeries([flow_path], crs="EPSG:4326")
+                gseries = gseries.to_crs(epsg=3395)
 
+                features["FL"] = gseries.length.iloc[0] / 1e3 # m → km  
+            else:
+                features["FL"] = np.nan
+        except Exception as e:
+            print(f"Flow length calculation failed: {e}")
+            features["FL"] = np.nan
+    else:
+        features["FL"] = np.nan
+    
     # AEC metrics
-    if aec_df is not None:
+    if isinstance(aec_df, pd.DataFrame) and not aec_df.empty:
         features["AECS"] = mean_slope(aec_df)
         features["AECC"] = mean_curvature(aec_df)
         features["AECI"] = concavity_index(aec_df)
+    else:
+        features["AECS"] = np.nan
+        features["AECC"] = np.nan
+        features["AECI"] = np.nan
 
     return pd.DataFrame([features])

reclaim/static_features/utils/aec_shape.py

@@ -94,8 +94,8 @@ def concavity_index(df: pd.DataFrame) -> float:
     line = np.linspace(0, 1, len(area_norm))
 
     # Area under actual curve vs line
-    auc_curve = np.trapz(elev_norm, area_norm)
-    auc_line = np.trapz(line, area_norm)
+    auc_curve = np.trapezoid(elev_norm, area_norm)
+    auc_line = np.trapezoid(line, area_norm)
 
     concavity = auc_curve / auc_line if auc_line > 0 else np.nan
     return concavity

reclaim/static_features/utils/area_perimeter.py

@@ -33,4 +33,4 @@ def calculate_length_area_meters(geometry, area= True):
         area_square_meters = scaled_geometry.area
         return length_meters, area_square_meters
     else:
-        return length_meters[0]
+        return length_meters