foxes 1.2.5__py3-none-any.whl → 1.4__py3-none-any.whl

foxes/output/__init__.py

@@ -2,24 +2,26 @@
 Output tools and functions.
 """
 
-from .round import round_defaults
-from .output import Output
-from .farm_layout import FarmLayoutOutput
-from .farm_results_eval import FarmResultsEval
-from .rose_plot import RosePlotOutput, StatesRosePlotOutput, WindRoseBinPlot
-from .results_writer import ResultsWriter
-from .state_turbine_map import StateTurbineMap
-from .turbine_type_curves import TurbineTypeCurves
-from .animation import Animator
-from .calc_points import PointCalculator
-from .slice_data import SliceData
-from .slices_data import SlicesData
-from .rotor_point_plots import RotorPointPlot
-from .state_turbine_table import StateTurbineTable
-from .plt import plt
+from .output import Output as Output
+from .farm_layout import FarmLayoutOutput as FarmLayoutOutput
+from .farm_results_eval import FarmResultsEval as FarmResultsEval
+from .rose_plot import RosePlotOutput as RosePlotOutput
+from .rose_plot import StatesRosePlotOutput as StatesRosePlotOutput
+from .rose_plot import WindRoseBinPlot as WindRoseBinPlot
+from .results_writer import ResultsWriter as ResultsWriter
+from .state_turbine_map import StateTurbineMap as StateTurbineMap
+from .turbine_type_curves import TurbineTypeCurves as TurbineTypeCurves
+from .animation import Animator as Animator
+from .calc_points import PointCalculator as PointCalculator
+from .slice_data import SliceData as SliceData
+from .slices_data import SlicesData as SlicesData
+from .rotor_point_plots import RotorPointPlot as RotorPointPlot
+from .state_turbine_table import StateTurbineTable as StateTurbineTable
+from .plt import plt as plt
 
-from .flow_plots_2d import FlowPlots2D
-from .seq_plugins import SeqFlowAnimationPlugin, SeqWakeDebugPlugin
+from .flow_plots_2d import FlowPlots2D as FlowPlots2D
+from .seq_plugins import SeqFlowAnimationPlugin as SeqFlowAnimationPlugin
+from .seq_plugins import SeqWakeDebugPlugin as SeqWakeDebugPlugin
 
-from . import grids
-from . import seq_plugins
+from . import grids as grids
+from . import seq_plugins as seq_plugins

foxes/output/farm_layout.py

@@ -5,8 +5,9 @@ import matplotlib.pyplot as plt
 from mpl_toolkits.axes_grid1 import make_axes_locatable
 
 from foxes.config import config
-import foxes.variables as FV
 from foxes.output.output import Output
+import foxes.variables as FV
+import foxes.constants as FC
 
 
 class FarmLayoutOutput(Output):
@@ -66,10 +67,10 @@ class FarmLayoutOutput(Output):
         self.D = D
 
         if from_results and farm_results is None:
-            raise ValueError(f"Missing farm_results for switch from_results.")
+            raise ValueError("Missing farm_results for switch from_results.")
 
         if from_results and results_state is None:
-            raise ValueError(f"Please specify results_state for switch from_results.")
+            raise ValueError("Please specify results_state for switch from_results.")
 
     def get_layout_data(self):
         """
@@ -229,9 +230,16 @@ class FarmLayoutOutput(Output):
                 if self.fres is None:
                     raise ValueError(f"Missing farm_results for color_by '{color_by}'")
                 if color_by[:5] == "mean_":
-                    kw["c"] = np.einsum(
-                        "st,st->t", self.fres[color_by[5:]], self.fres[FV.WEIGHT]
-                    )
+                    weights = self.fres[FV.WEIGHT]
+                    if weights.dims == (FC.STATE,):
+                        wx = "s"
+                    elif weights.dims == (FC.STATE, FC.TURBINE):
+                        wx = "st"
+                    else:
+                        raise ValueError(
+                            f"Unsupported dimensions for '{FV.WEIGHT}': Expecting '{(FC.STATE,)}' or '{(FC.STATE, FC.TURBINE)}', got '{weights.dims}'"
+                        )
+                    kw["c"] = np.einsum(f"st,{wx}->t", self.fres[color_by[5:]], weights)
                 elif color_by[:4] == "sum_":
                     kw["c"] = np.sum(self.fres[color_by[4:]], axis=0)
                 elif color_by[:4] == "min_":

foxes/output/farm_results_eval.py

@@ -66,9 +66,9 @@ class FarmResultsEval(Output):
             if isinstance(v, str):
                 vdata = self.results[v].to_numpy()
                 nns = np.sum(np.isnan(vdata))
-                assert (
-                    nns == 0
-                ), f"Found {nns} nan values for variable '{v}' of shape {vdata.shape}"
+                assert nns == 0, (
+                    f"Found {nns} nan values for variable '{v}' of shape {vdata.shape}"
+                )
                 fields.append(vdata)
             else:
                 fields.append(v)
@@ -76,22 +76,46 @@ class FarmResultsEval(Output):
                 nas = np.zeros_like(fields[-1], dtype=bool)
             nas = nas | np.isnan(fields[-1])
 
-        inds = ["st" for v in fields] + ["st"]
-        expr = ",".join(inds) + "->" + rhs
+        inds = ["st" for __ in fields]
+        if self.results[FV.WEIGHT].dims == (FC.STATE,):
+            inds += ["s"]
+
+            if np.any(nas):
+                sel = ~np.any(nas, axis=1)
+                fields = [f[sel] for f in fields]
+
+                weights0 = self.results[FV.WEIGHT].to_numpy()
+                w0 = np.sum(weights0)
+                weights = weights0[sel]
+                w1 = np.sum(weights)
+                weights *= w0 / w1
+                fields.append(weights)
 
-        if np.any(nas):
-            sel = ~np.any(nas, axis=1)
-            fields = [f[sel] for f in fields]
+            else:
+                fields.append(self.results[FV.WEIGHT].to_numpy())
+
+        elif self.results[FV.WEIGHT].dims == (FC.STATE, FC.TURBINE):
+            inds += ["st"]
 
-            weights0 = self.results[FV.WEIGHT].to_numpy()
-            w0 = np.sum(weights0, axis=0)[None, :]
-            weights = weights0[sel]
-            w1 = np.sum(weights, axis=0)[None, :]
-            weights *= w0 / w1
-            fields.append(weights)
+            if np.any(nas):
+                sel = ~np.any(nas, axis=1)
+                fields = [f[sel] for f in fields]
+
+                weights0 = self.results[FV.WEIGHT].to_numpy()
+                w0 = np.sum(weights0, axis=0)[None, :]
+                weights = weights0[sel]
+                w1 = np.sum(weights, axis=0)[None, :]
+                weights *= w0 / w1
+                fields.append(weights)
+
+            else:
+                fields.append(self.results[FV.WEIGHT].to_numpy())
 
         else:
-            fields.append(self.results[FV.WEIGHT].to_numpy())
+            raise ValueError(
+                f"Expecting '{FV.WEIGHT}' variable with dimensions {(FC.STATE,)} or {(FC.STATE, FC.TURBINE)}, got {self.results[FV.WEIGHT].dims}"
+            )
+        expr = ",".join(inds) + "->" + rhs
 
         return np.einsum(expr, *fields)
 
@@ -118,9 +142,9 @@ class FarmResultsEval(Output):
         for v, op in vars_op.items():
             vdata = self.results[v].to_numpy()
             nns = np.sum(np.isnan(vdata))
-            assert (
-                nns == 0
-            ), f"Found {nns} nan values for variable '{v}' of shape {vdata.shape}"
+            assert nns == 0, (
+                f"Found {nns} nan values for variable '{v}' of shape {vdata.shape}"
+            )
 
             if op == "weights":
                 rdata[v] = self.weinsum("t", vdata)
@@ -167,9 +191,9 @@ class FarmResultsEval(Output):
         for v, op in vars_op.items():
             vdata = self.results[v].to_numpy()
             nns = np.sum(np.isnan(vdata))
-            assert (
-                nns == 0
-            ), f"Found {nns} nan values for variable '{v}' of shape {vdata.shape}"
+            assert nns == 0, (
+                f"Found {nns} nan values for variable '{v}' of shape {vdata.shape}"
+            )
 
             if op == "weights":
                 rdata[v] = self.weinsum("s", vdata)
@@ -220,9 +244,9 @@ class FarmResultsEval(Output):
         for v, op in turbines_op.items():
             vdata = sdata[v].to_numpy()
             nns = np.sum(np.isnan(vdata))
-            assert (
-                nns == 0
-            ), f"Found {nns} nan values for variable '{v}' of shape {vdata.shape}"
+            assert nns == 0, (
+                f"Found {nns} nan values for variable '{v}' of shape {vdata.shape}"
+            )
 
             if op == "weights":
                 if states_op[v] == "weights":
@@ -447,11 +471,11 @@ class FarmResultsEval(Output):
             duration = times[-1] - times[0] + delta_t
             duration_seconds = np.int64(duration.astype(np.int64) / 1e9)
             duration_hours = duration_seconds / 3600
-        elif hours is None and annual == True:
+        elif hours is None and annual:
             duration_hours = 8760
         elif hours is None:
             raise ValueError(
-                f"Expecting parameter 'hours' for non-timeseries data, or 'annual=True'"
+                "Expecting parameter 'hours' for non-timeseries data, or 'annual=True'"
             )
         else:
             duration_hours = hours
@@ -630,7 +654,7 @@ class FarmResultsEval(Output):
         else:
             hax = ax
 
-        hax.set_xlabel(f"State")
+        hax.set_xlabel("State")
         hax.set_ylabel(variable)
         cc = cycler(color="bgrcmyk")
 

foxes/output/flow_plots_2d/__init__.py

@@ -1,2 +1,2 @@
-from .flow_plots import FlowPlots2D
-from .get_fig import get_fig
+from .flow_plots import FlowPlots2D as FlowPlots2D
+from .get_fig import get_fig as get_fig

foxes/output/flow_plots_2d/get_fig.py

@@ -181,6 +181,7 @@ def get_fig(
         hax.invert_yaxis()
 
     # add rotor position:
+    imr = []
     if show_rotor_dict is not None:
         D = show_rotor_dict["D"]
         coords = np.zeros(shape=(2, len(D)))  # array to hold change to turbine coords
@@ -211,12 +212,13 @@ def get_fig(
             turb_x2 = x[t] - coords[0, t]
             turb_y1 = y[t] + coords[1, t]
             turb_y2 = y[t] - coords[1, t]
-            hax.plot(
+            imr += hax.plot(
                 [turb_x1, turb_x2],
                 [turb_y1, turb_y2],
                 color=c,
                 linestyle="-",
                 linewidth=1,
+                animated=animated,
             )
 
     if add_bar:
@@ -233,7 +235,7 @@ def get_fig(
     if ret_state:
         out.append(si)
     if ret_im:
-        out.append([i for i in [im, qv, ttl] if i is not None])
+        out.append([i for i in [im, qv, ttl] if i is not None] + imr)
     if ret_state or ret_im:
         out = tuple(out)
 

foxes/output/rose_plot.py

@@ -1,7 +1,6 @@
 import numpy as np
 import matplotlib.pyplot as plt
 from xarray import Dataset
-from matplotlib.cm import ScalarMappable
 from matplotlib.projections.polar import PolarAxes
 from matplotlib.lines import Line2D
 
@@ -58,7 +57,7 @@ class RosePlotOutput(Output):
             self.results = farm_results
             self._rtype = FC.TURBINE
         else:
-            raise KeyError(f"Require either farm_results or point_results")
+            raise KeyError("Require either farm_results or point_results")
 
     @classmethod
     def get_data_info(cls, dname):
@@ -151,9 +150,19 @@ class RosePlotOutput(Output):
             The plot data
 
         """
+        if self.results[FV.WEIGHT].dims == (FC.STATE,):
+            w = self.results[FV.WEIGHT].to_numpy()
+        elif self.results[FV.WEIGHT].dims == (FC.STATE, FC.TURBINE):
+            w = self.results[FV.WEIGHT].to_numpy()[:, turbine]
+        elif self.results[FV.WEIGHT].dims == (FC.STATE, FC.POINT):
+            w = self.results[FV.WEIGHT].to_numpy()[:, point]
+        else:
+            raise ValueError(
+                f"Wrong dimensions for '{FV.WEIGHT}'. Expecting {(FC.STATE,)}, {(FC.STATE, FC.TURBINE)} or {(FC.STATE, FC.POINT)}, got {self.results[FV.WEIGHT].dims}"
+            )
+
         if add_inf:
             ws_bins = list(ws_bins) + [np.inf]
-        w = self.results[FV.WEIGHT].to_numpy()[:, turbine]
         t = turbine if self._rtype == FC.TURBINE else point
         ws = self.results[ws_var].to_numpy()[:, t]
         wd = self.results[wd_var].to_numpy()[:, t].copy()
@@ -286,7 +295,8 @@ class RosePlotOutput(Output):
 
         llines = [Line2D([0], [0], color=c, lw=10) for c in np.flip(color_list, axis=0)]
         lleg = [
-            f"[{ws_bins[i]:.1f}, {ws_bins[i+1]:.1f})" for i in range(n_wsb - 1, -1, -1)
+            f"[{ws_bins[i]:.1f}, {ws_bins[i + 1]:.1f})"
+            for i in range(n_wsb - 1, -1, -1)
         ]
         lpars = dict(
             loc="upper left",
@@ -449,8 +459,16 @@ class WindRoseBinPlot(Output):
             The plot data
 
         """
+        if self.farm_results[FV.WEIGHT].dims == (FC.STATE,):
+            w = self.farm_results[FV.WEIGHT].to_numpy()
+        elif self.farm_results[FV.WEIGHT].dims == (FC.STATE, FC.TURBINE):
+            w = self.farm_results[FV.WEIGHT].to_numpy()[:, turbine]
+        else:
+            raise ValueError(
+                f"Wrong dimensions for '{FV.WEIGHT}'. Expecting {(FC.STATE,)} or {(FC.STATE, FC.TURBINE)}, got {self.farm_results[FV.WEIGHT].dims}"
+            )
+
         var = self.farm_results[variable].to_numpy()[:, turbine]
-        w = self.farm_results[FV.WEIGHT].to_numpy()[:, turbine]
         ws = self.farm_results[ws_var].to_numpy()[:, turbine]
         wd = self.farm_results[wd_var].to_numpy()[:, turbine].copy()
         wd_delta = 360 / wd_sectors

foxes/output/seq_plugins/__init__.py

@@ -1,2 +1,2 @@
-from .seq_flow_ani_plugin import SeqFlowAnimationPlugin
-from .seq_wake_debug_plugin import SeqWakeDebugPlugin
+from .seq_flow_ani_plugin import SeqFlowAnimationPlugin as SeqFlowAnimationPlugin
+from .seq_wake_debug_plugin import SeqWakeDebugPlugin as SeqWakeDebugPlugin

foxes/output/seq_plugins/seq_flow_ani_plugin.py

@@ -1,5 +1,3 @@
-from copy import deepcopy
-
 from foxes.algorithms.sequential import SequentialPlugin
 
 from ..flow_plots_2d.flow_plots import FlowPlots2D
@@ -116,7 +114,6 @@ class SeqFlowAnimationPlugin(SequentialPlugin):
         fig = ax.get_figure()
         gdata = None
         while len(self._data):
-
             fres, d = self._data.pop(0)
 
             if d[2] is not None:

foxes/output/seq_plugins/seq_wake_debug_plugin.py

@@ -109,7 +109,6 @@ class SeqWakeDebugPlugin(SequentialPlugin):
 
         """
         while len(self._data):
-
             dt, pts, v = self._data.pop(0)
 
             N = len(pts)

foxes/output/slice_data.py

@@ -123,7 +123,6 @@ class SliceData(Output):
         label_map,
         vmin,
         vmax,
-        weight_turbine,
         to_file,
         write_pars,
         ret_states,
@@ -147,12 +146,22 @@ class SliceData(Output):
         del g_pts
 
         # take mean over states:
-        weights = self.fres[FV.WEIGHT][:, weight_turbine].to_numpy()
-        data = {
-            v: np.einsum("s,sp->p", weights, point_results[v].to_numpy())
-            for v in variables
-        }
-        del point_results
+        weights = point_results[FV.WEIGHT].to_numpy()
+        if point_results[FV.WEIGHT].dims == (FC.STATE,):
+            data = {
+                v: np.einsum("s,sp->p", weights, point_results[v].to_numpy())
+                for v in variables
+            }
+        elif point_results[FV.WEIGHT].dims == (FC.STATE, FC.POINT):
+            data = {
+                v: np.einsum("sp,sp->p", weights, point_results[v].to_numpy())
+                for v in variables
+            }
+        else:
+            raise ValueError(
+                f"Wrong dimensions for '{FV.WEIGHT}': Expecting {(FC.STATE,)} or {(FC.STATE, FC.POINT)}, got {point_results[FV.WEIGHT].dims}"
+            )
+        del point_results, weights
 
         # apply data modification:
         a_pos, b_pos, c_pos, data = self._data_mod(
@@ -207,7 +216,6 @@ class SliceData(Output):
         vmax={},
         states_sel=None,
         states_isel=None,
-        weight_turbine=0,
         to_file=None,
         write_pars={},
         ret_states=False,
@@ -260,8 +268,6 @@ class SliceData(Output):
             Reduce to selected states
         states_isel: list, optional
             Reduce to the selected states indices
-        weight_turbine: int, optional
-            Index of the turbine from which to take the weight
         to_file: str, optional
             Write data to this file name
         write_pars: dict
@@ -314,7 +320,6 @@ class SliceData(Output):
             label_map,
             vmin,
             vmax,
-            weight_turbine,
             to_file,
             write_pars,
             ret_states,
@@ -352,7 +357,6 @@ class SliceData(Output):
         vmax={},
         states_sel=None,
         states_isel=None,
-        weight_turbine=0,
         to_file=None,
         write_pars={},
         ret_states=False,
@@ -407,8 +411,6 @@ class SliceData(Output):
             Reduce to selected states
         states_isel: list, optional
             Reduce to the selected states indices
-        weight_turbine: int, optional
-            Index of the turbine from which to take the weight
         to_file: str, optional
             Write data to this file name
         write_pars: dict
@@ -463,7 +465,6 @@ class SliceData(Output):
             label_map,
             vmin,
             vmax,
-            weight_turbine,
             to_file,
             write_pars,
             ret_states,
@@ -501,7 +502,6 @@ class SliceData(Output):
         vmax={},
         states_sel=None,
         states_isel=None,
-        weight_turbine=0,
         to_file=None,
         write_pars={},
         ret_states=False,
@@ -556,8 +556,6 @@ class SliceData(Output):
             Reduce to selected states
         states_isel: list, optional
             Reduce to the selected states indices
-        weight_turbine: int, optional
-            Index of the turbine from which to take the weight
         to_file: str, optional
             Write data to this file name
         write_pars: dict
@@ -612,7 +610,6 @@ class SliceData(Output):
             label_map,
             vmin,
             vmax,
-            weight_turbine,
             to_file,
             write_pars,
             ret_states,

foxes/output/turbine_type_curves.py

@@ -1,4 +1,3 @@
-from tabnanny import verbose
 import matplotlib.pyplot as plt
 import numpy as np
 import pandas as pd
@@ -182,19 +181,19 @@ class TurbineTypeCurves(Output):
             t = f"{vv}, {turbine_type}" if titles[i] is None else titles[i]
             ax.set_title(t)
 
-            l = "Wind speed [m/s]" if x_label is None else x_label
-            ax.set_xlabel(l)
+            lb = "Wind speed [m/s]" if x_label is None else x_label
+            ax.set_xlabel(lb)
 
             if y_labels[i] is None:
                 if v == FV.P:
-                    l = f"Power [kW]"
+                    lb = "Power [kW]"
                 elif v == FV.CT:
-                    l = "ct [-]"
+                    lb = "ct [-]"
                 else:
-                    l = v
+                    lb = v
             else:
-                l = y_labels[i]
-            ax.set_ylabel(l)
+                lb = y_labels[i]
+            ax.set_ylabel(lb)
 
             ax.grid()
 

foxes/utils/__init__.py

@@ -2,23 +2,41 @@
 General utilities.
 """
 
-from .wind_dir import wd2uv, wd2wdvec, wdvec2wd, uv2wd, delta_wd
-from .pandas_utils import PandasFileHelper
-from .xarray_utils import write_nc
-from .subclasses import all_subclasses, new_cls, new_instance
-from .dict import Dict
-from .factory import Factory, FDict, WakeKFactory
-from .data_book import DataBook
-from .cubic_roots import cubic_roots
-from .geopandas_utils import read_shp, shp2csv, read_shp_polygons, shp2geom2d
-from .load import import_module, load_module
-from .exec_python import exec_python
-from .regularize import sqrt_reg
-from .tab_files import read_tab_file
-from .random_xy import random_xy_square
-from .dev_utils import print_mem
-from .wrg_utils import ReaderWRG
+from .wind_dir import wd2uv as wd2uv
+from .wind_dir import wd2wdvec as wd2wdvec
+from .wind_dir import wdvec2wd as wdvec2wd
+from .wind_dir import uv2wd as uv2wd
+from .wind_dir import delta_wd as delta_wd
 
-from . import two_circles
-from . import abl
-from . import geom2d
+from .subclasses import all_subclasses as all_subclasses
+from .subclasses import new_cls as new_cls
+from .subclasses import new_instance as new_instance
+
+from .factory import Factory as Factory
+from .factory import FDict as FDict
+from .factory import WakeKFactory as WakeKFactory
+
+from .geopandas_utils import read_shp as read_shp
+from .geopandas_utils import shp2csv as shp2csv
+from .geopandas_utils import read_shp_polygons as read_shp_polygons
+from .geopandas_utils import shp2geom2d as shp2geom2d
+
+from .load import import_module as import_module
+from .load import load_module as load_module
+
+from .pandas_utils import PandasFileHelper as PandasFileHelper
+from .xarray_utils import write_nc as write_nc
+from .dict import Dict as Dict
+from .data_book import DataBook as DataBook
+from .cubic_roots import cubic_roots as cubic_roots
+from .exec_python import exec_python as exec_python
+from .regularize import sqrt_reg as sqrt_reg
+from .tab_files import read_tab_file as read_tab_file
+from .random_xy import random_xy_square as random_xy_square
+from .dev_utils import print_mem as print_mem
+from .wrg_utils import ReaderWRG as ReaderWRG
+from .weibull import weibull_weights as weibull_weights
+
+from . import two_circles as two_circles
+from . import abl as abl
+from . import geom2d as geom2d

foxes/utils/abl/__init__.py

@@ -2,7 +2,7 @@
 Atmospheric boundary layer functions.
 """
 
-from . import neutral
-from . import stable
-from . import unstable
-from . import sheared
+from . import neutral as neutral
+from . import stable as stable
+from . import unstable as unstable
+from . import sheared as sheared

foxes/utils/cubic_roots.py

@@ -104,7 +104,7 @@ def test_cubic_roots(roots, a0, a1, a2, a3=None, tol=1.0e-12):
         c2 = a2[n]
         c3 = a3[n]
 
-        print(f"Polynomial {n}: a = {(c0,c1,c2,c3)}")
+        print(f"Polynomial {n}: a = {(c0, c1, c2, c3)}")
 
         rts = np.unique(roots[n])
         rts = rts[~np.isnan(rts)]

foxes/utils/data_book.py

@@ -66,9 +66,10 @@ class DataBook:
         except AttributeError:
             contents = list(resources.contents(package))
 
-        check_f = lambda f: any(
-            [len(f) > len(s) and f[-len(s) :] == s for s in file_sfx]
-        )
+        def check_f(f):
+            """little helper function to check file endings"""
+            return any([len(f) > len(s) and f[-len(s) :] == s for s in file_sfx])
+
         contents = [f for f in contents if check_f(f)]
 
         try:

foxes/utils/dict.py

@@ -77,9 +77,9 @@ class Dict(dict):
         """
         try:
             if len(deflt):
-                assert (
-                    len(deflt) == 1
-                ), f"Expecting a single default entry, got {len(deflt)}"
+                assert len(deflt) == 1, (
+                    f"Expecting a single default entry, got {len(deflt)}"
+                )
                 data = self.get(key, deflt[0])
             else:
                 data = self[key]

foxes/utils/exec_python.py

@@ -1,7 +1,7 @@
-import numpy as np
-import pandas as pd
-import xarray as xr
-import matplotlib.pyplot as plt
+import numpy as np  # noqa: F401
+import pandas as pd  # noqa: F401
+import xarray as xr  # noqa: F401
+import matplotlib.pyplot as plt  # noqa: F401
 
 
 def exec_python(s, indicator="%", newline=";", globals=globals(), locals={}):
@@ -38,7 +38,7 @@ def exec_python(s, indicator="%", newline=";", globals=globals(), locals={}):
         L = len(indicator)
         if len(s) > L and s[:L] == indicator:
             a = s[L:]
-            if not indicator in a:
+            if indicator not in a:
                 exec(a, globals, locals)
             else:
                 ilist = a.split(indicator)

foxes/utils/factory.py

@@ -526,9 +526,7 @@ class WakeKFactory:
                 s += f"\n  {v} from {list(f0.options[v])}"
             else:
                 s += f"\n  {v}={f0.hints.get(v, '(value)')}"
-        s += (
-            f"\n  [wake_k]=(None or k<k> or ka<ka> or ka<ka>_kb<kb>, e.g. 004 for 0.04)"
-        )
+        s += "\n  [wake_k]=(None or k<k> or ka<ka> or ka<ka>_kb<kb>, e.g. 004 for 0.04)"
         return s
 
 

foxes/utils/geom2d/__init__.py

@@ -2,8 +2,10 @@
 Geometries in two dimensions.
 """
 
-from .area_geometry import AreaGeometry, InvertedAreaGeometry
-from .area_geometry import AreaUnion, AreaIntersection
-from .polygon import ClosedPolygon
-from .circle import Circle
-from .half_plane import HalfPlane
+from .area_geometry import AreaGeometry as AreaGeometry
+from .area_geometry import InvertedAreaGeometry as InvertedAreaGeometry
+from .area_geometry import AreaUnion as AreaUnion
+from .area_geometry import AreaIntersection as AreaIntersection
+from .polygon import ClosedPolygon as ClosedPolygon
+from .circle import Circle as Circle
+from .half_plane import HalfPlane as HalfPlane