Update imported package usage to avoid deprecation warnings (#253)

misi9170 · web-flow · commit 8c01b15d78b1 · 2025-09-23T10:06:24.000-06:00
diff --git a/examples_artificial_data/03_energy_ratio/01_demo_energy_ratio_options.ipynb b/examples_artificial_data/03_energy_ratio/01_demo_energy_ratio_options.ipynb
diff --git a/examples_smarteole/02_download_and_format_dataset.ipynb b/examples_smarteole/02_download_and_format_dataset.ipynb
diff --git a/flasc/analysis/energy_ratio.py b/flasc/analysis/energy_ratio.py
@@ -137,7 +137,7 @@ def _compute_energy_ratio_single(
         .with_columns(energy_ratio=pl.col("test_energy") / pl.col("ref_energy"))
         .pivot(
             values=["energy_ratio", "count"],
-            columns="df_name",
+            on="df_name",
             index="wd_bin",
             aggregate_function="first",
         )
diff --git a/flasc/analysis/energy_ratio_output.py b/flasc/analysis/energy_ratio_output.py
@@ -564,7 +564,7 @@ def _compute_ws_counts(self):
         )
 
         # Get the bin count by wd, ws and df_name
-        df_group = df_.group_by(["wd_bin", "ws_bin", "df_name"]).count()
+        df_group = df_.group_by(["wd_bin", "ws_bin", "df_name"]).len().rename({"len": "count"})
 
         # Collect the minimum number of points per bin
         df_return = (
diff --git a/flasc/analysis/expected_power_analysis_by.py b/flasc/analysis/expected_power_analysis_by.py
@@ -308,7 +308,7 @@ def plot(
         # If the color dict is empty fill using a matplotlib palette
         if len(color_dict) == 0:
             num_uplift_names = len(self.uplift_names)
-            c_pal = plt.cm.get_cmap("tab10", num_uplift_names)
+            c_pal = plt.get_cmap("tab10", num_uplift_names)
             color_dict = {
                 uplift_name: c_pal(up_idx) for up_idx, uplift_name in enumerate(self.uplift_names)
             }
@@ -703,7 +703,7 @@ def total_uplift_expected_power_by_wd_shift_ws_min(
     labels = [f"ws_min = {ws_min_loop:.1f}" for ws_min_loop in ws_min_values]
 
     # Define the color dict
-    c_pal = plt.cm.get_cmap("viridis", n_step)
+    c_pal = plt.get_cmap("viridis", n_step)
     color_dict = {label: c_pal(idx) for idx, label in enumerate(labels)}
 
     # Declare a figure
diff --git a/flasc/analysis/total_uplift_power_ratio.py b/flasc/analysis/total_uplift_power_ratio.py
@@ -137,7 +137,7 @@ def _total_uplift_power_ratio_single(
             )
             .pivot(
                 values=["power_ratio"],
-                columns="df_name",
+                on="df_name",
                 index=bin_cols_without_df_name + ["weight", "weighted_pow_ref"],
                 aggregate_function="first",
             )
diff --git a/flasc/data_processing/energy_ratio_wd_bias_estimation.py b/flasc/data_processing/energy_ratio_wd_bias_estimation.py
@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import os as os
-from typing import Callable, List, Union
+from typing import Callable, Iterable, List, Union
 
 import matplotlib.pyplot as plt
 import numpy as np
@@ -89,7 +89,7 @@ def __init__(
 
     def _load_a_input_for_wd_bias(
         self,
-        wd_bias,
+        wd_bias: float,
     ):
         """Load AnalysisInput objects with bias.
 
@@ -158,16 +158,16 @@ def _load_a_input_for_wd_bias(
 
     def _get_energy_ratios_allbins(
         self,
-        wd_bias,
-        time_mask=None,
-        ws_mask=(6.0, 10.0),
-        wd_mask=None,
-        ti_mask=None,
-        wd_step=3.0,
-        ws_step=1.0,
-        wd_bin_width=3.0,
-        N_btstrp=1,
-        plot_iter_path=None,
+        wd_bias: float,
+        time_mask: None = None,
+        ws_mask: Iterable[float, float] = (6.0, 10.0),
+        wd_mask: Iterable[float, float] | None = None,
+        ti_mask: None = None,
+        wd_step: float = 3.0,
+        ws_step: float = 1.0,
+        wd_bin_width: float = 3.0,
+        N_btstrp: int = 1,
+        plot_iter_path: str | None = None,
     ):
         """Calculate the energy ratios.
 
@@ -177,8 +177,7 @@ def _get_energy_ratios_allbins(
                 the data based on this variable. Defaults to None.
             ws_mask ([iterable], optional): Wind speed mask. Should be an
                 iterable of length 2, e.g., [6.0, 10.0], defining the lower
-                and upper bound, respectively. If not specified, will not
-                mask the data based on this variable. Defaults to (6, 10).
+                and upper bound, respectively. Defaults to (6, 10).
             wd_mask ([iterable], optional): Wind direction mask. Should
                 be an iterable of length 2, e.g., [0.0, 180.0], defining
                 the lower and upper bound, respectively. If not specified,
@@ -233,7 +232,7 @@ def _get_energy_ratios_allbins(
 
         for ii, ti in enumerate(self.test_turbines):
             self.logger.info(
-                "    Determining energy ratios for test turbine = %03d." % (ti)
+                "    Determining energy ratios for test turbine = %03d." % ti
                 + " WD bias: %.3f deg." % wd_bias
             )
 
@@ -420,9 +419,14 @@ def estimate_wd_bias(
         """
         self.logger.info("Estimating the wind direction bias")
 
-        def cost_fun(wd_bias):
+        def cost_fun(x: np.ndarray):
+            """Cost function to minimize.
+
+            Args:
+                x (np.ndarray): Wind direction bias to evaluate. 1D array with 1 element.
+            """
             self._get_energy_ratios_allbins(
-                wd_bias=wd_bias,
+                wd_bias=x[0],  # pass as float
                 time_mask=time_mask,
                 ws_mask=ws_mask,
                 wd_mask=wd_mask,
@@ -467,7 +471,7 @@ def opt_finish(func, x0, args=()):
             # workers=opt_workers,
         )
 
-        wd_bias = x_opt
+        wd_bias = x_opt[0]
         self.opt_wd_bias = wd_bias
         self.opt_cost = J_opt
         self.opt_wd_grid = x
@@ -476,7 +480,7 @@ def opt_finish(func, x0, args=()):
         # End with optimal results and bootstrapping
         self.logger.info("  Evaluating optimal solution with bootstrapping")
         self._get_energy_ratios_allbins(
-            wd_bias=x_opt,
+            wd_bias=wd_bias,
             time_mask=time_mask,
             ws_mask=ws_mask,
             wd_mask=wd_mask,
@@ -530,7 +534,7 @@ def plot_energy_ratios(
             er_out_test_turbine_list_scada_copy = self.er_out_test_turbine_list_scada.copy()
             # (Re)compute case with wd_bias=0
             self._get_energy_ratios_allbins(
-                wd_bias=0,
+                wd_bias=0.0,
                 time_mask=self._input_args["time_mask"],
                 ws_mask=self._input_args["ws_mask"],
                 wd_mask=self._input_args["wd_mask"],
diff --git a/flasc/data_processing/filtering.py b/flasc/data_processing/filtering.py
@@ -311,9 +311,14 @@ def filter_by_condition(
         if not apply_filters_to_df:
             df_in = df_in.copy()
 
-        # Mark data as faulty on the dataframe
+        # Mark data as faulty on the dataframe, omitting boolean type columns.
         N_pre = [df_get_no_faulty_measurements(df_in, tii) for tii in ti]
-        df_out = df_mark_turbdata_as_faulty(df=df_in, cond=condition, turbine_list=ti)
+        df_out = df_mark_turbdata_as_faulty(
+            df=df_in,
+            cond=condition,
+            turbine_list=ti,
+            exclude_columns=df_in.select_dtypes(include=["bool"]).columns.tolist(),
+        )
 
         # Print the reduction in useful data to the console, if verbose
         if verbose:
@@ -1379,6 +1384,7 @@ def filter_df_by_faulty_impacting_turbines(df, ti, df_impacting_turbines, verbos
         df=df,
         cond=test_turbine_impacted,
         turbine_list=[ti],
+        exclude_columns=df.select_dtypes(include=["bool"]).columns.tolist(),
     )
     N_post = df_get_no_faulty_measurements(df_out, ti)
 
diff --git a/flasc/data_processing/time_operations.py b/flasc/data_processing/time_operations.py
@@ -56,21 +56,21 @@ def df_movingaverage(
     # Carry out the mean calculations
     df_regular = (
         df[cols_regular]  # Select only non-angular columns
-        .rolling(window_width, center=center, axis=0, min_periods=min_periods)
+        .rolling(window_width, center=center, min_periods=min_periods)
         .mean()
     )
 
     df_cos = (
         df[cols_angular]  # Select only angular columns
         .pipe(lambda df_: np.cos(df_ * np.pi / 180.0))
-        .rolling(window_width, center=center, axis=0, min_periods=min_periods)
+        .rolling(window_width, center=center, min_periods=min_periods)
         .mean()
     )
 
     df_sin = (
         df[cols_angular]  # Select only angular columns
         .pipe(lambda df_: np.sin(df_ * np.pi / 180.0))
-        .rolling(window_width, center=center, axis=0, min_periods=min_periods)
+        .rolling(window_width, center=center, min_periods=min_periods)
         .mean()
     )
 
@@ -83,7 +83,7 @@ def df_movingaverage(
 
     if calc_median_min_max_std:  # if including other statistics
         df_regular_stats = (
-            df.rolling(window_width, center=center, axis=0, min_periods=min_periods)
+            df.rolling(window_width, center=center, min_periods=min_periods)
             .agg(["median", "min", "max", "std"])
             .pipe(lambda df_: flatten_cols(df_))
         )
@@ -168,7 +168,7 @@ def df_downsample(
 
     # Now calculate downsampled dataframe, automatically
     # mark by label on the right (i.e., "past 10 minutes").
-    df_resample = df.resample(window_width, label="right", axis=0)
+    df_resample = df.resample(window_width, label="right")
 
     # First calculate mean values of non-angular columns
     df_mean = df_resample[cols_regular].mean().copy()
@@ -204,7 +204,7 @@ def df_downsample(
         # Compute the stats for the non_angular columns
         df_stats_regular = (
             df_stats[cols_regular]  # Select non-angular columns
-            .resample(window_width, label="right", axis=0)  # Resample to desired window
+            .resample(window_width, label="right")  # Resample to desired window
             .agg(["median", "min", "max", "std"])  # Perform aggregations
             .pipe(lambda df_: flatten_cols(df_))  # Flatten columns
         )
@@ -224,7 +224,7 @@ def df_downsample(
             .add(180)  # Shift up by 180 (start of sequence for -180/180 wrap)
             .mod(360)  # Wrap by 360
             .subtract(180)  # Remove shift (end of sequence for -180/180 wrap)
-            .resample(window_width, label="right", axis=0)  # Resample to desired window
+            .resample(window_width, label="right")  # Resample to desired window
         )
 
         # Now create the individual statistics
@@ -297,7 +297,7 @@ def df_downsample(
 
     if return_index_mapping:
         df_tmp = pd.DataFrame(data={"time": df.reset_index()["time"], "tmp": 1}).resample(
-            window_width, on="time", label="right", axis=0
+            window_width, on="time", label="right"
         )
 
         # Grab index of first and last time entry for each window
diff --git a/flasc/model_fitting/yaw_pow_fitting.py b/flasc/model_fitting/yaw_pow_fitting.py
@@ -67,7 +67,7 @@ def set_df(self, df, df_upstream, ti):
         if df_upstream is not None:
             df_upstr_ti = df_upstream[[ti in tl for tl in df_upstream["turbines"]]]
             df_upstr_ti = df_upstr_ti.reset_index(drop=True)
-            in_range = [False for _ in range(df.shape[0])]
+            in_range = np.array([False for _ in range(df.shape[0])])
             for i in range(df_upstr_ti.shape[0]):
                 wd_min = df_upstr_ti.loc[i, "wd_min"]
                 wd_max = df_upstr_ti.loc[i, "wd_max"]
diff --git a/flasc/utilities/energy_ratio_utilities.py b/flasc/utilities/energy_ratio_utilities.py
@@ -577,9 +577,9 @@ def bin_and_group_dataframe(
             pl.all_horizontal(pl.col(bin_cols_with_df_name).is_not_null())
         )  # Select for all bin cols present
         .group_by(bin_cols_with_df_name, maintain_order=True)
-        .agg([pl.mean("pow_ref"), pl.mean("pow_test"), pl.count()])
+        .agg([pl.mean("pow_ref"), pl.mean("pow_test"), pl.len().alias("count")])
         # Enforce that each ws/wd bin combination has to appear in all dataframes
-        .filter(pl.count().over(bin_cols_without_df_name) == num_df)
+        .filter(pl.len().over(bin_cols_without_df_name) == num_df)
     )
 
     return df_
diff --git a/flasc/utilities/floris_tools.py b/flasc/utilities/floris_tools.py
@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import copy
 from time import perf_counter as timerpc
 from typing import Union
 
@@ -922,8 +921,9 @@ def get_dependent_turbines_by_wd(
                 (number of wind directions) x (number of turbines). Returned
                 only if return_influence_magnitudes is True.
     """
-    # Copy fi to a local to not mess with incoming
-    fm = copy.deepcopy(fm_in)
+    # Copy incoming ForisModel to modify locally. FlorisModel.copy() is used,
+    # which will not copy over stored wind_data or control setpoints.
+    fm = fm_in.copy()
 
     # Compute the base power
     fm.set(
@@ -943,8 +943,6 @@ def get_dependent_turbines_by_wd(
     fm.set(
         layout_x=np.delete(fm.layout_x, [test_turbine]),
         layout_y=np.delete(fm.layout_y, [test_turbine]),
-        wind_speeds=ws_test * np.ones_like(wd_array),
-        wind_directions=wd_array,
     )  # This will reindex the turbines; undone in following steps.
     fm.run()
     test_power = fm.get_turbine_powers()
diff --git a/flasc/utilities/utilities_examples.py b/flasc/utilities/utilities_examples.py
@@ -90,7 +90,7 @@ def load_floris_artificial(wake_model="gch", wd_std=0.0, cosine_exponent=None):
         for ii in range(len(tdefs)):
             tdefs[ii]["power_thrust_table"]["cosine_loss_exponent_yaw"] = cosine_exponent
 
-        fm.set(turbine_type=tdefs)
+        fm.set(turbine_type=tdefs, reference_wind_height=fm.reference_wind_height)
 
     # Add uncertainty
     if wd_std > 0.01:
diff --git a/flasc/visualization.py b/flasc/visualization.py
@@ -242,7 +242,9 @@ def plot_binned_mean_and_ci(
     df["x_bin"] = pd.cut(df["x"], x_edges, labels=x_labels)
 
     # Get aggregate statistics
-    df_agg = df.groupby("x_bin").agg({"y": ["count", "std", "min", "max", "mean", st.sem]})
+    df_agg = df.groupby("x_bin", observed=False).agg(
+        {"y": ["count", "std", "min", "max", "mean", st.sem]}
+    )
     # Flatten column names
     df_agg.columns = ["_".join(c) for c in df_agg.columns]
 
diff --git a/flasc/yaw_optimizer_visualization.py b/flasc/yaw_optimizer_visualization.py
@@ -99,7 +99,7 @@ def plot_uplifts_by_atmospheric_conditions(
             y = [None for _ in range(len(df_list))]
             f = [None for _ in range(len(df_list))]
             for dii, df in enumerate(df_list):
-                df_group = df.groupby(xq_col)
+                df_group = df.groupby(xq_col, observed=False)
                 if yii == 0:
                     y[dii] = 100.0 * (df_group["Prel"].apply(np.nanmean) - 1.0)
                 else:
diff --git a/tests/energy_ratio_test.py b/tests/energy_ratio_test.py
@@ -225,6 +225,7 @@ def test_flascdataframe_input(self):
 
     def test_energy_ratio_input(self):
         # Energy ratio input is deprecated but should still work
+        # TODO: Remove this test in next major release since EnergyRatioInput is deprecated.
 
         # Load data and FLORIS model
         fm, _ = load_floris()
diff --git a/tests/total_uplift_test.py b/tests/total_uplift_test.py
@@ -87,6 +87,8 @@ def test_compute_total_uplift(self):
         # compute_total_uplift is the old name for total_uplift_power_ratio, test that
         # it can be used as total_uplift_power_ratio
         # Test the returned energy ratio assuming alternative weightings of the wind speed bins
+        # TODO: Remove this test in next major FLASC release since compute_total_uplift is
+        # deprecated
         df_base = pd.DataFrame(
             {
                 "wd": [270, 270.0, 270.0, 270.0, 272.0],

Original file line number	Diff line number	Diff line change
`@@ -137,7 +137,7 @@ def _compute_energy_ratio_single(`
`137`	`137`	`.with_columns(energy_ratio=pl.col("test_energy") / pl.col("ref_energy"))`
`138`	`138`	`.pivot(`
`139`	`139`	`values=["energy_ratio", "count"],`
`140`		`- columns="df_name",`
	`140`	`+ on="df_name",`
`141`	`141`	`index="wd_bin",`
`142`	`142`	`aggregate_function="first",`
`143`	`143`	`)`
Original file line number	Diff line number	Diff line change
`@@ -564,7 +564,7 @@ def _compute_ws_counts(self):`
`564`	`564`	`)`
`565`	`565`
`566`	`566`	`# Get the bin count by wd, ws and df_name`
`567`		`- df_group = df_.group_by(["wd_bin", "ws_bin", "df_name"]).count()`
	`567`	`+ df_group = df_.group_by(["wd_bin", "ws_bin", "df_name"]).len().rename({"len": "count"})`
`568`	`568`
`569`	`569`	`# Collect the minimum number of points per bin`
`570`	`570`	`df_return = (`
Original file line number	Diff line number	Diff line change
`@@ -137,7 +137,7 @@ def _total_uplift_power_ratio_single(`
`137`	`137`	`)`
`138`	`138`	`.pivot(`
`139`	`139`	`values=["power_ratio"],`
`140`		`- columns="df_name",`
	`140`	`+ on="df_name",`
`141`	`141`	`index=bin_cols_without_df_name + ["weight", "weighted_pow_ref"],`
`142`	`142`	`aggregate_function="first",`
`143`	`143`	`)`