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

{pyreclaim-0.3.0.dist-info → pyreclaim-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyreclaim
-Version: 0.3.0
+Version: 0.5.0
 Summary: Reservoir Estimation of Capacity Loss using AI based Methods
 Author-email: Sanchit Minocha <msanchit@uw.edu>
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -698,6 +698,12 @@ Requires-Dist: joblib
 Requires-Dist: xgboost
 Requires-Dist: lightgbm
 Requires-Dist: catboost
+Requires-Dist: openpyxl
+Requires-Dist: netcdf4
+Requires-Dist: dask
+Requires-Dist: rioxarray
+Requires-Dist: matplotlib
+Requires-Dist: tqdm
 Dynamic: license-file
 
 <div align="center">
@@ -737,7 +743,7 @@ pip install pyreclaim
 
 To generate features for reservoirs using the **RECLAIM** framework and the [`pyreclaim`](https://pypi.org/project/pyreclaim/) Python package, you will need the global datasets.  
 
-You can download all required global datasets from the Open Science Framework (OSF):  
+You can download all required global datasets from the Zenodo Repository:  
 
 [Download Global Datasets](https://doi.org/10.5281/zenodo.17230533)  
 
@@ -763,7 +769,7 @@ from reclaim.reclaim import Reclaim
 reservoir_static = {
     "obc": 150.0,
     "hgt": 45.0,
-    "mrb": "Ganges",
+    "mrb": 4030033640,
     "lat": 25.6,
     "lon": 81.9,
     "reservoir_polygon": reservoir_polygon,

pyreclaim-0.5.0.dist-info/RECORD

@@ -0,0 +1,28 @@
+pyreclaim-0.5.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+reclaim/__init__.py,sha256=PnNGOrv5as3H8_WWLE3QqHR2LnqMgutXD8lDA-8PnCE,33
+reclaim/generate_features.py,sha256=td-XQtuYN8HiEkDV1yVBr8wSq9MAXVg0LbGY0U2ytZI,11300
+reclaim/reclaim.py,sha256=nUgE0gN4F76HGTIikR5GJZVV4KpL6HmUVuVUEhui6n8,20402
+reclaim/derived_features/__init__.py,sha256=boN0ilez7nbWdn4RKD4n7whlGrg_X-zxrqMv5RA6cmg,67
+reclaim/derived_features/feature_engineering_and_transformation.py,sha256=BzgITsvE1WTvVkf0-7ivg_-OaAnKWPfVz48GY9BWOzA,5689
+reclaim/dynamic_features/__init__.py,sha256=gjZmRYl9zCccSenz6f38EKntrV6ueT0_9MHRrjtw2Og,45
+reclaim/dynamic_features/catchment_dynamic.py,sha256=MKJwfZDepazDM6h5XnUxMFFhGSnkYSq7YBgxOourJ2s,3619
+reclaim/dynamic_features/reservoir_dynamic.py,sha256=IeNFwjkOVukNA4JeYJe-Eglf13KBypeFFDLYgacQtFg,5062
+reclaim/dynamic_features/utils/__init__.py,sha256=_mTSUeDu1jG5oBHvDKkMPx2A3xtIuSCpGpcMIURzmkU,89
+reclaim/dynamic_features/utils/catchment_meteorology.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+reclaim/dynamic_features/utils/inflow_outflow.py,sha256=vD5CTAR12gCd56y8zDpzKfzJvG_qU_uJFD5OAajyb-g,2384
+reclaim/dynamic_features/utils/rainfall.py,sha256=oWn1RbeHHmhZ--N7bx9UiJptRrPynYGXe1HTfPjHjWg,1387
+reclaim/dynamic_features/utils/statistical_metrics.py,sha256=qtiLtFCqtOa6sDkpCmZmGsS_kub4rkYqUKgSEODZea4,4881
+reclaim/dynamic_features/utils/ts_aggregate.py,sha256=veHO6h6YaO6nP7kN-sFKALqT-jMlLZ3FNCtfNfGC41c,3689
+reclaim/static_features/__init__.py,sha256=QRDAk3sgrGX-Oq8oRY5RESkWniVhcAPoQUa6jDJ59Zo,44
+reclaim/static_features/catchment_static.py,sha256=uCC-0r3R_awIWaEtkZ1t3jEXbUN4mXxKyWvuVbi_XWo,5933
+reclaim/static_features/reservoir_static.py,sha256=jo8s9Wjr8PIwQ4d8wHKqefFf3r2WQ9MqZpwcnz6848U,4652
+reclaim/static_features/utils/__init__.py,sha256=y-4GVIqARI0g8s2FVlTfx_4XprcPQ9HP_2nbhSw1NVA,88
+reclaim/static_features/utils/aec_shape.py,sha256=Tyew9tvPvNFpMOtPBf2GhdPBXoEjXr-VA2vyfY6ugYk,3270
+reclaim/static_features/utils/area_perimeter.py,sha256=yDLpxjyfGDQdL121w65X5oWLxCSwtSuPvJa7n_mtBl0,1338
+reclaim/static_features/utils/basin_names.py,sha256=-6PCuuaGqAP1KfhbrCM6DYCDQ5hkZp7nte099Ks6NjI,2024
+reclaim/static_features/utils/catchment_agreggate.py,sha256=Dvb7_vaeC-r69EXs2SOvDenhfWjp0-fbdmo492vqBoE,12083
+reclaim/static_features/utils/flow_length.py,sha256=BuYhQxss3x1TXlg6JxPvcV1wAkrCPEl6c0IEd935lfc,19889
+pyreclaim-0.5.0.dist-info/METADATA,sha256=qFIdVYDNazCXY-cQhLnNIfOZl-q54zIsTRyoegk8t8k,45510
+pyreclaim-0.5.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+pyreclaim-0.5.0.dist-info/top_level.txt,sha256=uO95g-XnD3UQLLqi3q30muhaC9VqO04IqCbwmfsGmW4,8
+pyreclaim-0.5.0.dist-info/RECORD,,

{pyreclaim-0.3.0.dist-info → pyreclaim-0.5.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

reclaim/derived_features/feature_engineering_and_transformation.py

@@ -1,6 +1,45 @@
 import pandas as pd
 import numpy as np
 
+ALL_FEATURES = [
+     'log_OBC', 'log_HGT', 'MRB', 'LAT', 'LON',
+     'log_RA', 'log_RP', 'log_FL',
+     'log_CA', 'log_DCA',
+     
+     'AECS', 'AECC','AECI',
+     
+     'log_LCAS', 'log_LCC',
+     'log_LCG', 'log_LCT', 'log_LCS',
+     'log_LCHV', 'log_LCM', 
+     'log_LCSV','log_LCBS', 
+     'log_LCSG', 'log_LCWB','DLC',
+     
+     'COAR', 'SAND', 'SILT', 'CLAY', 'BULK',
+     
+     'ELEV', 'SLOP', 'CURV', 'ASP', 'HILL',
+     
+     'log_MAI', 'log_PAI', 'I_cv',
+     'log_I_std','I_above_90', 'I_max_persis',
+     'log_MAO', 'log_O_std', 'O_cv',
+     'E_mean', 'E_std',
+     'log_SA_mean',  'log_SA_std', 'SA_cv', 'SA_skew', 'log_SA_kurt',
+     'log_SA_mean_clip', 'SA_above_90',
+     'NSSC1_mean', 'NSSC1_std', 'NSSC1_cv', 'NSSC1_skew', 'NSSC1_kurt', 
+     'NSSC2_mean', 'NSSC2_above_90', 'NSSC2_max_persis',
+     
+     'log_MAR', '#_rain_above_10', '#_rain_above_50', '#_rain_above_100',
+     'tmin_mean', 'tmax_mean',
+     'wind_mean', 'wind_std', 'wind_cv', 'wind_skew', 'wind_kurt', 
+     
+     'AGE', 'log_ROBC', 'log_GC',
+     'NVGF',
+     'R_tree_bare', 'R_shrub_bare', 'R_coarse_sand',
+     'log_rel_SA_mean_clip', 'log_R_SA_cap',
+     'log_rain_per_area',
+     'log_TE', 'log_RT', 'log_ECLR', 'ESR',
+     'log_SIN', 'log_SOUT',
+]
+
 def engineer_and_transform_features(df: pd.DataFrame) -> pd.DataFrame:
     """
     Engineer and transform features in reservoir/catchment dataset.
@@ -54,22 +93,44 @@ def engineer_and_transform_features(df: pd.DataFrame) -> pd.DataFrame:
         "SOUT": df["MAO"] * df["NSSC2_mean"],
     }
     
-    # Land cover log-area features
-    lc_cols = ['LCAS','LCC','LCG','LCT','LCS','LCHV','LCM','LCSV','LCBS','LCSG','LCWB']
-    for col in lc_cols:
-        feature_dict[col] = df["CA"] * df[col] / 100
-    
     df = pd.concat([df, pd.DataFrame(feature_dict)], axis=1)
 
+    # Land cover log-area features
+    lc_cols = ['LCAS','LCC','LCG','LCT','LCS','LCHV','LCM','LCSV','LCBS','LCSG','LCWB']
+    # for col in lc_cols:
+    #     df[col] = df["CA"] * df[col] / 100
+    # Doing calculation along with taking log as done in model training. results will slightly differ for cases where percentage of LC is 0.
+        
     # -------------------------
     # APPLY LOG TRANSFORMATIONS
     # -------------------------
     log_candidates = ['CA','DCA','OBC','HGT','RA','RP','FL',
                       'SA_mean','SA_mean_clip','SA_std','SA_kurt','PAI','MAI','MAO','I_std','O_std','MAR',
-                      'rain_per_area','GC','TE','ECLR','SIN','SOUT'] + lc_cols
+                      'ROBC','rain_per_area','GC','TE','RT','ECLR','SIN','SOUT', 'rel_SA_mean_clip', 'R_SA_cap'] + lc_cols
 
     for col in log_candidates:
         log_col = f'log_{col}'  # add prefix to avoid double log
-        df[log_col] = np.log(df[col].clip(lower=1e-15))
+        try:
+            if col in ['ECLR','SIN','SOUT']:
+                # Land cover columns can be zero (upto 15 decimal places), clip at 1e-15
+                df[log_col] = np.log(df[col].clip(lower=1e-15))
+            elif col in ['rain_per_area']:
+                # Rain per area can be zero (upto 10 decimal places), clip at 1e-10
+                df[log_col] = np.log(df[col].clip(lower=1e-10))
+            elif col in lc_cols:
+                df[log_col] = np.log(df["CA"].clip(lower=1e-6)) + np.log(df[col].clip(lower=1e-6)) - np.log(100)
+            else:
+                # All other columns can be zero (upto 6 decimal places), clip at 1e-6
+                df[log_col] = np.log(df[col].clip(lower=1e-6))
+        except Exception as e:
+            raise ValueError(f"Error applying log transform to column '{col}': {e}")
+    
+    # Process DLc as categorical column
+    df['DLC'] = df['DLC'].astype(int).fillna(0)
+    
+    # Add empty columns for any missing features
+    for feature in ALL_FEATURES:
+        if feature not in df.columns:
+            df[feature] = np.nan
     
     return df

reclaim/dynamic_features/catchment_dynamic.py

@@ -1,6 +1,6 @@
 import pandas as pd
 import numpy as np
-from typing import Dict, Sequence
+from typing import Dict, Sequence, List
 
 from reclaim.dynamic_features.utils.rainfall import (
     mean_annual_rainfall_mm,
@@ -13,12 +13,34 @@ from reclaim.dynamic_features.utils.statistical_metrics import (
     skewness,
     kurtosis_val,
 )
-from reclaim.dynamic_features.utils.ts_aggregate import compute_ts_aggregate
+from reclaim.dynamic_features.utils.ts_aggregate import compute_ts_aggregates
+
+VARIABLE_FEATURES = {
+        "precip": {
+            "MAR": mean_annual_rainfall_mm,
+            "#_rain_above_10": lambda ts: mean_annual_rainy_days(ts, threshold=10.0),
+            "#_rain_above_50": lambda ts: mean_annual_rainy_days(ts, threshold=50.0),
+            "#_rain_above_100": lambda ts: mean_annual_rainy_days(ts, threshold=100.0),
+        },
+        "tmin": {
+            "tmin_mean": annual_mean,
+        },
+        "tmax": {
+            "tmax_mean": annual_mean,
+        },
+        "wind": {
+            "wind_mean": annual_mean,
+            "wind_std": annual_std,
+            "wind_cv": coefficient_of_variation,
+            "wind_skew": skewness,
+            "wind_kurt": kurtosis_val,
+        },
+    }
 
 
 def catchment_based_dynamic_features(
     variable_info: Dict[str, Dict[str, str]],
-    observation_period: Sequence[int],
+    observation_intervals: List[Sequence[int]],
 ) -> pd.DataFrame:
     """
     Compute dynamic catchment-based features for a single reservoir's catchment,
@@ -41,63 +63,47 @@ def catchment_based_dynamic_features(
                 "time_column": str,
                 "data_column": str
             }
-
-    observation_period : sequence[int]
-        Two-element sequence [OSY, OEY] specifying the observation period to clip the series.
+            
+    observation_intervals : list of list of int
+        List of [start_year, end_year] intervals to compute features over.
 
     Returns
     -------
     pd.DataFrame
-        A one-row DataFrame containing the computed catchment-based features.
-
+        A DataFrame containing as many rows as there are observation intervals and columns corresponding to the computed catchment-based features.
+        Missing variables in ``variable_info`` will result in NaN values for their features.
     Notes
     -----
     - Precipitation features are reported as mm/year (for MAR) and counts (rainy days).
     - Wind statistics include mean, std, CV, skewness, kurtosis.
     - Temperature features are simple annual means (°C).
     """
-    
-    variable_features = {
-        "precip": {
-            "MAR": mean_annual_rainfall_mm,
-            "#_rain_above_10": lambda ts: mean_annual_rainy_days(ts, threshold=10.0),
-            "#_rain_above_50": lambda ts: mean_annual_rainy_days(ts, threshold=50.0),
-            "#_rain_above_100": lambda ts: mean_annual_rainy_days(ts, threshold=100.0),
-        },
-        "tmin": {
-            "tmin_mean": annual_mean,
-        },
-        "tmax": {
-            "tmax_mean": annual_mean,
-        },
-        "wind": {
-            "wind_mean": annual_mean,
-            "wind_std": annual_std,
-            "wind_cv": coefficient_of_variation,
-            "wind_skew": skewness,
-            "wind_kurt": kurtosis_val,
-        },
-    }
 
-    results = {}
+    all_vars = []
 
-    for var, feat_dict in variable_features.items():
+    for var, feat_dict in VARIABLE_FEATURES.items():
         if var not in variable_info:
-            for feat in feat_dict.keys():
-                results[feat] = np.nan
+            all_vars.append(
+                pd.DataFrame(np.nan, index=range(len(observation_intervals)),
+                             columns=feat_dict.keys())
+            )
             continue
 
         path = variable_info[var]["path"]
         time_col = variable_info[var]["time_column"]
         data_col = variable_info[var]["data_column"]
+        
+        try:
+            df_var = compute_ts_aggregates(
+                ts_csv_path=path,
+                time_column=time_col,
+                value_column=data_col,
+                feature_functions=feat_dict,
+                intervals=observation_intervals,
+            )
+            all_vars.append(df_var)
+        except Exception:
+            df_var = pd.DataFrame()
+            all_vars.append(df_var)
 
-        for feat, func in feat_dict.items():
-            try:
-                df_feat = compute_ts_aggregate(
-                    path, time_col, data_col, func, feat, observation_period
-                )
-                results[feat] = df_feat.iloc[0, 0]  # extract scalar
-            except Exception:
-                results[feat] = np.nan
-
-    return pd.DataFrame([results])
+    return pd.concat(all_vars, axis=1)

reclaim/dynamic_features/reservoir_dynamic.py

@@ -1,7 +1,7 @@
 import os
 import pandas as pd
 import numpy as np
-from typing import Dict, Sequence, Union, Callable
+from typing import Dict, Sequence, Union, Callable, List
 
 from reclaim.dynamic_features.utils.statistical_metrics import (
     annual_mean,
@@ -18,11 +18,53 @@ from reclaim.dynamic_features.utils.inflow_outflow import (
     max_annual_flow_m3_per_s,
     mean_annual_flow_variability
 )
-from reclaim.dynamic_features.utils.ts_aggregate import compute_ts_aggregate
+from reclaim.dynamic_features.utils.ts_aggregate import compute_ts_aggregates
+
+# Define which features depend on which variable
+VARIABLE_FEATURES = {
+    "inflow": {
+        "MAI": mean_annual_flow_m3_per_s,
+        "PAI": max_annual_flow_m3_per_s,
+        "I_cv": mean_annual_flow_variability,
+        "I_std": mean_annual_flow_std_m3_per_s,
+        "I_above_90": max_days_above_90th,
+        "I_max_persis": max_annual_persistence,
+    },
+    "outflow": {
+        "MAO": mean_annual_flow_m3_per_s,
+        "O_std": mean_annual_flow_std_m3_per_s,
+        "O_cv": mean_annual_flow_variability,
+    },
+    "evaporation": {
+        "E_mean": annual_mean,
+        "E_std": annual_std,
+    },
+    "surface_area": {
+        "SA_mean": annual_mean,
+        "SA_std": annual_std,
+        "SA_cv": coefficient_of_variation,
+        "SA_skew": skewness,
+        "SA_kurt": kurtosis_val,
+        "SA_mean_clip": annual_mean,
+        "SA_above_90": max_days_above_90th,
+    },
+    "nssc": {
+        "NSSC1_mean": annual_mean,
+        "NSSC1_std": annual_std,
+        "NSSC1_cv": coefficient_of_variation,
+        "NSSC1_skew": skewness,
+        "NSSC1_kurt": kurtosis_val,
+    },
+    "nssc2": {
+        "NSSC2_mean": annual_mean,
+        "NSSC2_above_90": max_days_above_90th,
+        "NSSC2_max_persis": max_annual_persistence,
+    },
+}
 
 def reservoir_based_dynamic_features(
     variable_info: Dict[str, Dict[str, str]],
-    observation_period: Sequence[int],
+    observation_intervals: List[Sequence[int]]
 ) -> pd.DataFrame:
     """
     Compute dynamic reservoir features for a single reservoir using inflow, outflow,
@@ -57,13 +99,13 @@ def reservoir_based_dynamic_features(
                 "outflow": {"path": "data/outflow.csv", "time_column": "date", "data_column": "outflow (m3/d)"}
             }
 
-    observation_period : sequence[int]
-        Two-element sequence [OSY, OEY] specifying the observation period to clip the series.
+    observation_intervals : list of list of int
+        List of [start_year, end_year] intervals to compute features over.
 
     Returns
     -------
     pd.DataFrame
-        A one-row DataFrame containing the computed reservoir dynamic features.
+        A DataFrame containing as many rows as ``observation_intervals`` and columns corresponding to the computed reservoir dynamic features.
         Missing variables in ``variable_info`` will result in NaN values for their features.
 
     Notes
@@ -74,75 +116,31 @@ def reservoir_based_dynamic_features(
     - If a variable is missing in ``variable_info``, its corresponding features are NaN.
     """
 
-    # Define which features depend on which variable
-    variable_features = {
-        "inflow": {
-            "MAI": mean_annual_flow_m3_per_s,
-            "PAI": max_annual_flow_m3_per_s,
-            "I_cv": mean_annual_flow_variability,
-            "I_std": mean_annual_flow_std_m3_per_s,
-            "I_above_90": max_days_above_90th,
-            "I_max_persis": max_annual_persistence,
-        },
-        "outflow": {
-            "MAO": mean_annual_flow_m3_per_s,
-            "O_std": mean_annual_flow_std_m3_per_s,
-            "O_cv": mean_annual_flow_variability,
-        },
-        "evaporation": {
-            "E_mean": annual_mean,
-            "E_std": annual_std,
-        },
-        "surface_area": {
-            "SA_mean": annual_mean,
-            "SA_std": annual_std,
-            "SA_cv": coefficient_of_variation,
-            "SA_skew": skewness,
-            "SA_kurt": kurtosis_val,
-            "SA_mean_clip": annual_mean,
-            "SA_above_90": max_days_above_90th,
-        },
-        "nssc": {
-            "NSSC1_mean": annual_mean,
-            "NSSC1_std": annual_std,
-            "NSSC1_cv": coefficient_of_variation,
-            "NSSC1_skew": skewness,
-            "NSSC1_kurt": kurtosis_val,
-        },
-        "nssc2": {
-            "NSSC2_mean": annual_mean,
-            "NSSC2_above_90": max_days_above_90th,
-            "NSSC2_max_persis": max_annual_persistence,
-        },
-    }
-
-    results = {}
+    all_vars = []
 
     # Loop through required variables
-    for var, feat_dict in variable_features.items():
+    for var, feat_dict in VARIABLE_FEATURES.items():
         if var not in variable_info:
-            # Fill with NaN if variable not provided
-            for feat in feat_dict.keys():
-                results[feat] = np.nan
+            all_vars.append(
+                pd.DataFrame(np.nan, index=range(len(observation_intervals)),
+                             columns=feat_dict.keys())
+            )
             continue
 
         path = variable_info[var]["path"]
         time_col = variable_info[var]["time_column"]
         data_col = variable_info[var]["data_column"]
-
-        # Some features require clipping, others use full record
-        for feat, func in feat_dict.items():
-            if var == "surface_area" and feat in ["SA_mean", "SA_std", "SA_cv", "SA_skew", "SA_kurt"]:
-                obs_period = None  # full record
-            else:
-                obs_period = observation_period
-
-            try:
-                df_feat = compute_ts_aggregate(
-                    path, time_col, data_col, func, feat, obs_period
-                )
-                results[feat] = df_feat.iloc[0, 0]  # single value
-            except Exception:
-                results[feat] = np.nan
-
-    return pd.DataFrame([results])
+        try:
+            df_var = compute_ts_aggregates(
+                ts_csv_path=path,
+                time_column=time_col,
+                value_column=data_col,
+                feature_functions=feat_dict,
+                intervals=observation_intervals,
+            )
+            all_vars.append(df_var)
+        except Exception:
+            df_var = pd.DataFrame()
+            all_vars.append(df_var)
+
+    return pd.concat(all_vars, axis=1)

reclaim/dynamic_features/utils/ts_aggregate.py

@@ -1,13 +1,40 @@
 import pandas as pd
-from typing import Callable, Union, Sequence
+import numpy as np
+from pathlib import Path
+from typing import Callable, Union, Sequence, List, Dict
 
-def compute_ts_aggregate(
+FULL_RECORD_FEATURES = ["SA_mean", "SA_std", "SA_cv", "SA_skew", "SA_kurt", "NSSC2_max_persis"]
+
+def build_intervals(start_year, end_year, time_interval):
+    total_years = end_year - start_year + 1
+
+    # Case 1: Entire window shorter than interval
+    if total_years <= time_interval:
+        return [[start_year, end_year]]
+
+    remainder = total_years % time_interval
+    outputs = []
+
+    # First interval absorbs remainder (if any)
+    first_len = time_interval + remainder if remainder != 0 else time_interval
+    first_end = min(start_year + first_len - 1, end_year)
+    outputs.append([start_year, first_end])
+
+    # Remaining intervals
+    current_start = first_end + 1
+    while current_start <= end_year:
+        current_end = current_start + time_interval - 1
+        outputs.append([current_start, min(current_end, end_year)])
+        current_start = current_end + 1
+
+    return outputs
+
+def compute_ts_aggregates(
     ts_csv_path: str,
     time_column: str,
     value_column: str,
-    feature_function: Callable,
-    feature_name: str,
-    observation_period: Union[Sequence[int], None] = None
+    feature_functions: Dict[str, Callable],
+    intervals: List[Sequence[int]],
 ) -> pd.DataFrame:
     """
     Compute an aggregate feature from a user-provided time series CSV for a single reservoir.
@@ -20,44 +47,58 @@ def compute_ts_aggregate(
         Name of the column representing dates/timestamps.
     value_column : str
         Name of the column representing the variable values.
-    feature_function : Callable
-        Function that takes a pd.Series (the time series) and returns a single value.
-    feature_name : str
-        Name of the column to store the computed feature in the returned DataFrame.
-    observation_period : list or tuple of two ints, optional
-        [start_year, end_year] to clip the time series. If None, no clipping is applied.
+    feature_functions : Dict[str, Callable]
+        Dictionary where keys are feature names (column names for output DataFrame) and values are functions that take a pd.Series and return a single value.
+    intervals : list of list of int
+        List of [start_year, end_year] intervals to compute features over.
 
     Returns
     -------
     pd.DataFrame
         A single-row DataFrame containing the computed feature with the specified column name.
     """
-
-    # Load the CSV
+    # --- Read CSV ONCE ---
+    # Check if path exists 
+    if not Path(ts_csv_path).is_file():
+        raise FileNotFoundError(f"CSV file not found at path: {ts_csv_path}")
+        
     df = pd.read_csv(ts_csv_path)
     if df.empty:
         raise ValueError(f"CSV at {ts_csv_path} is empty.")
+    
+    # Ensure columns exist
+    if time_column not in df.columns:
+        raise ValueError(f"Time column '{time_column}' not found in CSV.")
+    if value_column not in df.columns:
+        raise ValueError(f"Value column '{value_column}' not found in CSV.")
 
     # Ensure time column is datetime
     df[time_column] = pd.to_datetime(df[time_column], errors='coerce')
     if df[time_column].isna().all():
         raise ValueError(f"Time column '{time_column}' could not be converted to datetime.")
 
-    # Set index
-    ts = df.set_index(time_column)[value_column]
+    # Set index 
+    ts = df.set_index(time_column)[value_column].sort_index()
+    
+    if ts.empty:
+        raise ValueError("Time series is completely empty. Please check the data or avoid providing this variable.")
+
+    rows = []
 
-    # Clip to observation period if provided
-    if observation_period is not None:
-        start_year, end_year = observation_period
-        ts = ts[(ts.index.year >= start_year) & (ts.index.year <= end_year)]
+    for osy, oey in intervals:
+        ts_clip = ts[(ts.index.year >= osy) & (ts.index.year <= oey)]
+        ts_till_end_year = ts[ts.index.year <= oey]
 
-    # Remove NaNs
-    ts_clean = ts.dropna()
-    if ts_clean.empty:
-        raise ValueError("Time series has no valid data after clipping/removing NaNs.")
+        row = {}
+        for feat, func in feature_functions.items():
+            try:
+                if feat in FULL_RECORD_FEATURES:
+                    row[feat] = func(ts_till_end_year) if not ts_till_end_year.empty else np.nan
+                else:
+                    row[feat] = func(ts_clip) if not ts_clip.empty else np.nan
+            except Exception:
+                row[feat] = np.nan
 
-    # Apply user-defined feature function
-    feature_value = feature_function(ts_clean)
+        rows.append(row)
 
-    # Return as single-row DataFrame with user-specified column name
-    return pd.DataFrame({feature_name: [feature_value]})
+    return pd.DataFrame(rows)