pycontrails 0.52.2__cp312-cp312-win_amd64.whl → 0.53.0__cp312-cp312-win_amd64.whl

pycontrails/datalib/ecmwf/hres_model_level.py

@@ -377,7 +377,7 @@ class HRESModelLevel(ECMWFAPI):
         time = self.forecast_time.strftime("%H:%M:%S")
         steps = self.get_forecast_steps(times)
         # param 152 = log surface pressure, needed for metview level conversion
-        grib_params = set(self.variable_ecmwfids + [152])
+        grib_params = set((*self.variable_ecmwfids, 152))
         return (
             f"retrieve,\n"
             f"class=od,\n"
@@ -473,8 +473,8 @@ class HRESModelLevel(ECMWFAPI):
             LOG.debug("Opening GRIB file")
             fs_ml = mv.read(target)
 
-            # reduce memory overhead by cacheing one timestep at a time
-            for time, step in zip(times, self.get_forecast_steps(times)):
+            # reduce memory overhead by caching one timestep at a time
+            for time, step in zip(times, self.get_forecast_steps(times), strict=True):
                 fs_pl = mv.Fieldset()
                 selection = dict(step=step)
                 lnsp = fs_ml.select(shortName="lnsp", **selection)

pycontrails/datalib/ecmwf/variables.py

@@ -118,7 +118,7 @@ RelativeHumidity = MetVariable(
         "At temperatures below -23°C it is calculated for saturation over ice. "
         "Between -23°C and 0°C this parameter is calculated by interpolating between the ice and"
         " water values using a quadratic function."
-        "See https://www.ecmwf.int/sites/default/files/elibrary/2016/17117-part-iv-physical-processes.pdf#subsection.7.4.2"  # noqa: E501
+        "See https://www.ecmwf.int/sites/default/files/elibrary/2016/17117-part-iv-physical-processes.pdf#subsection.7.4.2"
     ),
 )
 
@@ -166,7 +166,7 @@ TopNetSolarRadiation = MetVariable(
         "The incoming solar radiation is the amount received from the Sun. "
         "The outgoing solar radiation is the amount reflected and scattered by the Earth's"
         " atmosphere and surface"
-        "See https://www.ecmwf.int/sites/default/files/elibrary/2015/18490-radiation-quantities-ecmwf-model-and-mars.pdf"  # noqa: E501
+        "See https://www.ecmwf.int/sites/default/files/elibrary/2015/18490-radiation-quantities-ecmwf-model-and-mars.pdf"
     ),
 )
 
@@ -183,7 +183,7 @@ TopNetThermalRadiation = MetVariable(
         "radiation emitted to space at the top of the atmosphere is commonly known as the Outgoing"
         " Longwave Radiation (OLR). "
         "The top net thermal radiation (this parameter) is equal to the negative of OLR."
-        "See https://www.ecmwf.int/sites/default/files/elibrary/2015/18490-radiation-quantities-ecmwf-model-and-mars.pdf"  # noqa: E501
+        "See https://www.ecmwf.int/sites/default/files/elibrary/2015/18490-radiation-quantities-ecmwf-model-and-mars.pdf"
     ),
 )
 

pycontrails/datalib/gfs/gfs.py

@@ -13,8 +13,9 @@ import hashlib
 import logging
 import pathlib
 import warnings
+from collections.abc import Callable
 from datetime import datetime
-from typing import TYPE_CHECKING, Any, Callable
+from typing import TYPE_CHECKING, Any
 
 import numpy as np
 import pandas as pd
@@ -113,7 +114,7 @@ class GFSForecast(metsource.MetDataSource):
     - `Documentation <https://www.ncei.noaa.gov/products/weather-climate-models/global-forecast>`_
     - `Parameter sets <https://www.nco.ncep.noaa.gov/pmb/products/gfs/>`_
     - `GFS Documentation <https://www.emc.ncep.noaa.gov/emc/pages/numerical_forecast_systems/gfs/documentation.php>`_
-    """  # noqa: E501
+    """
 
     __slots__ = ("client", "grid", "cachestore", "show_progress", "forecast_time")
 
@@ -495,7 +496,7 @@ class GFSForecast(metsource.MetDataSource):
             GFS dataset
         """
         # translate into netcdf from grib
-        logger.debug(f"Translating {filepath} for timestep {str(t)} into netcdf")
+        logger.debug(f"Translating {filepath} for timestep {t!s} into netcdf")
 
         # get step for timestep
         step = pd.Timedelta(t - self.forecast_time) // pd.Timedelta(1, "h")

pycontrails/datalib/landsat.py

@@ -33,15 +33,6 @@ except ModuleNotFoundError as exc:
         pycontrails_optional_package="sat",
     )
 
-try:
-    import rasterio
-except ModuleNotFoundError as exc:
-    dependencies.raise_module_not_found_error(
-        name="landsat module",
-        package_name="rasterio",
-        module_not_found_error=exc,
-        pycontrails_optional_package="sat",
-    )
 
 #: BigQuery table with imagery metadata
 BQ_TABLE = "bigquery-public-data.cloud_storage_geo_index.landsat_index"
@@ -313,6 +304,16 @@ def _check_band_resolution(bands: set[str]) -> None:
 
 def _read(path: str, meta: str, band: str, processing: str) -> xr.DataArray:
     """Read imagery data from Landsat files."""
+    try:
+        import rasterio
+    except ModuleNotFoundError as exc:
+        dependencies.raise_module_not_found_error(
+            name="landsat module",
+            package_name="rasterio",
+            module_not_found_error=exc,
+            pycontrails_optional_package="sat",
+        )
+
     src = rasterio.open(path)
     img = src.read(1)
     crs = pyproj.CRS.from_epsg(src.crs.to_epsg())

pycontrails/ext/synthetic_flight.py

@@ -417,7 +417,7 @@ class SyntheticFlight:
         times_arr = np.asarray(times).T
         data = [
             {"longitude": lon, "latitude": lat, "level": level, "time": time}
-            for lon, lat, level, time in zip(lons_arr, lats_arr, level, times_arr)
+            for lon, lat, level, time in zip(lons_arr, lats_arr, level, times_arr, strict=True)
         ]
         dfs = [pd.DataFrame(d).dropna() for d in data]
         dfs = [df for df in dfs if len(df) >= self.min_n_waypoints]

pycontrails/models/accf.py

@@ -154,7 +154,7 @@ class ACCF(Model):
     sur_variables = (ecmwf.SurfaceSolarDownwardRadiation, ecmwf.TopNetThermalRadiation)
     default_params = ACCFParams
 
-    short_vars = {v.short_name for v in (*met_variables, *sur_variables)}
+    short_vars = frozenset(v.short_name for v in (*met_variables, *sur_variables))
 
     # This variable won't get used since we are not writing the output
     # anywhere, but the library will complain if it's not defined

pycontrails/models/apcemm/apcemm.py

@@ -84,10 +84,10 @@ class APCEMMParams(models.ModelParams):
     engine_uid: str | None = None
 
     #: Aircraft performance model
-    aircraft_performance: AircraftPerformance = PSFlight()
+    aircraft_performance: AircraftPerformance = dataclasses.field(default_factory=PSFlight)
 
     #: Fuel type
-    fuel: Fuel = JetA()
+    fuel: Fuel = dataclasses.field(default_factory=JetA)
 
     #: List of flight waypoints to simulate in APCEMM.
     #: By default, runs a simulation for every waypoint.
@@ -371,7 +371,7 @@ class APCEMM(models.Model):
     @overload
     def eval(self, source: None = ..., **params: Any) -> NoReturn: ...
 
-    def eval(self, source: Flight | None = None, **params: Any) -> Flight | NoReturn:
+    def eval(self, source: Flight | None = None, **params: Any) -> Flight:
         """Set up and run APCEMM simulations initialized at flight waypoints.
 
         Simulates the formation and evolution of contrails from a Flight
@@ -776,8 +776,8 @@ class APCEMM(models.Model):
         # Compute azimuth
         # Use forward and backward differences for first and last waypoints
         # and centered differences elsewhere
-        ileft = [0] + list(range(self.source.size - 1))
-        iright = list(range(1, self.source.size)) + [self.source.size - 1]
+        ileft = [0, *range(self.source.size - 1)]
+        iright = [*range(1, self.source.size), self.source.size - 1]
         lon0 = self.source["longitude"][ileft]
         lat0 = self.source["latitude"][ileft]
         lon1 = self.source["longitude"][iright]

pycontrails/models/cocip/cocip.py

@@ -148,7 +148,6 @@ class Cocip(Model):
 
     This implementation is regression tested against
     results from :cite:`teohAviationContrailClimate2022`.
-    See `tests/benchmark/north-atlantic-study/validate.py`.
 
     **Outputs**
 
@@ -336,7 +335,7 @@ class Cocip(Model):
         self,
         source: Flight | Sequence[Flight] | None = None,
         **params: Any,
-    ) -> Flight | list[Flight] | NoReturn:
+    ) -> Flight | list[Flight]:
         """Run CoCiP simulation on flight.
 
         Simulates the formation and evolution of contrails from a Flight
@@ -549,6 +548,8 @@ class Cocip(Model):
         verbose_outputs = self.params["verbose_outputs"]
 
         interp_kwargs = self.interp_kwargs
+        if self.params["preprocess_lowmem"]:
+            interp_kwargs["lowmem"] = True
         interpolate_met(met, self.source, "air_temperature", **interp_kwargs)
         interpolate_met(met, self.source, "specific_humidity", **interp_kwargs)
         interpolate_met(met, self.source, "eastward_wind", "u_wind", **interp_kwargs)
@@ -750,6 +751,8 @@ class Cocip(Model):
 
         # get full met grid or flight data interpolated to the pressure level `p_dz`
         interp_kwargs = self.interp_kwargs
+        if self.params["preprocess_lowmem"]:
+            interp_kwargs["lowmem"] = True
         air_temperature_lower = interpolate_met(
             met,
             self._sac_flight,
@@ -861,6 +864,8 @@ class Cocip(Model):
 
         # get met post wake vortex along initial contrail
         interp_kwargs = self.interp_kwargs
+        if self.params["preprocess_lowmem"]:
+            interp_kwargs["lowmem"] = True
         air_temperature_1 = interpolate_met(met, contrail_1, "air_temperature", **interp_kwargs)
         interpolate_met(met, contrail_1, "specific_humidity", **interp_kwargs)
 
@@ -952,11 +957,14 @@ class Cocip(Model):
             )
             logger.debug("None are filtered out!")
 
-    def _simulate_contrail_evolution(self) -> None:
-        """Simulate contrail evolution."""
-        # Calculate all properties for "downwash_contrail" which is
-        # a contrail representation of the waypoints of the downwash flight.
-        # The downwash_contrail has already been filtered for initial persistent waypoints.
+    def _process_downwash_flight(self) -> tuple[MetDataset | None, MetDataset | None]:
+        """Create and calculate properties of contrails created by downwash vortex.
+
+        ``_downwash_contrail`` is a contrail representation of the waypoints of
+        ``_downwash_flight``, which has already been filtered for initial persistent waypoints.
+
+        Returns MetDatasets for subsequent use if ``preprocess_lowmem=False``.
+        """
         self._downwash_contrail = self._create_downwash_contrail()
         buffers = {
             f"{coord}_buffer": self.params[f"met_{coord}_buffer"]
@@ -971,6 +979,8 @@ class Cocip(Model):
         calc_timestep_geometry(self._downwash_contrail)
 
         interp_kwargs = self.interp_kwargs
+        if self.params["preprocess_lowmem"]:
+            interp_kwargs["lowmem"] = True
         calc_timestep_meteorology(self._downwash_contrail, met, self.params, **interp_kwargs)
         calc_shortwave_radiation(rad, self._downwash_contrail, **interp_kwargs)
         calc_outgoing_longwave_radiation(rad, self._downwash_contrail, **interp_kwargs)
@@ -985,6 +995,16 @@ class Cocip(Model):
         # Intersect with rad dataset
         calc_radiative_properties(self._downwash_contrail, self.params)
 
+        if self.params["preprocess_lowmem"]:
+            return None, None
+        return met, rad
+
+    def _simulate_contrail_evolution(self) -> None:
+        """Simulate contrail evolution."""
+
+        met, rad = self._process_downwash_flight()
+        interp_kwargs = self.interp_kwargs
+
         contrail_contrail_overlapping = self.params["contrail_contrail_overlapping"]
         if contrail_contrail_overlapping and not isinstance(self.source, Fleet):
             warnings.warn("Contrail-Contrail Overlapping is only valid for Fleet mode.")
@@ -1022,22 +1042,7 @@ class Cocip(Model):
                 continue
 
             # Update met, rad slices as needed
-            # We need to both interpolate latest_contrail, as well as the "contrail_2"
-            # created by calc_timestep_contrail_evolution. This "contrail_2" object
-            # has constant time at "time_end", hence the buffer we apply below.
-            # After the downwash_contrails is all used up, these updates are intended
-            # to happen once each hour
-            buffers["time_buffer"] = (
-                np.timedelta64(0, "ns"),
-                time_end - latest_contrail["time"].max(),
-            )
-            if time_end > met.indexes["time"].to_numpy()[-1]:
-                logger.debug("Downselect met at time_end %s within Cocip evolution", time_end)
-                met = latest_contrail.downselect_met(self.met, **buffers, copy=False)
-                met = add_tau_cirrus(met)
-            if time_end > rad.indexes["time"].to_numpy()[-1]:
-                logger.debug("Downselect rad at time_end %s within Cocip evolution", time_end)
-                rad = latest_contrail.downselect_met(self.rad, **buffers, copy=False)
+            met, rad = self._maybe_downselect_met_rad(met, rad, latest_contrail, time_end)
 
             # Recalculate latest_contrail with new values
             # NOTE: We are doing a substantial amount of redundant computation here
@@ -1075,6 +1080,75 @@ class Cocip(Model):
 
             self.contrail_list.append(final_contrail)
 
+    def _maybe_downselect_met_rad(
+        self,
+        met: MetDataset | None,
+        rad: MetDataset | None,
+        latest_contrail: GeoVectorDataset,
+        time_end: np.datetime64,
+    ) -> tuple[MetDataset, MetDataset]:
+        """Downselect ``self.met`` and ``self.rad`` if necessary to cover ``time_end``.
+
+        If current ``met`` and ``rad`` slices to not include ``time_end``, new slices are selected
+        from ``self.met`` and ``self.rad``. Downselection in space will cover
+        - locations of current contrails (``latest_contrail``),
+        - locations of additional contrails that will be loaded from ``self._downwash_flight``
+          before the new slices expire,
+        plus a user-defined buffer.
+        """
+        if met is None or time_end > met.indexes["time"].to_numpy()[-1]:
+            logger.debug("Downselect met at time_end %s within Cocip evolution", time_end)
+            met = self._definitely_downselect_met_or_rad(self.met, latest_contrail, time_end)
+            met = add_tau_cirrus(met)
+
+        if rad is None or time_end > rad.indexes["time"].to_numpy()[-1]:
+            logger.debug("Downselect rad at time_end %s within Cocip evolution", time_end)
+            rad = self._definitely_downselect_met_or_rad(self.rad, latest_contrail, time_end)
+
+        return met, rad
+
+    def _definitely_downselect_met_or_rad(
+        self, met: MetDataset, latest_contrail: GeoVectorDataset, time_end: np.datetime64
+    ) -> MetDataset:
+        """Perform downselection when required by :meth:`_maybe_downselect_met_rad`.
+
+        Downselects ``met`` (which should be one of ``self.met`` or ``self.rad``)
+        to cover ``time_end``. Downselection in space covers
+        - locations of current contrails (``latest_contrail``),
+        - locations of additional contrails that will be loaded from ``self._downwash_flight``
+          before the new slices expire,
+        plus a user-defined buffer, as described in :meth:`_maybe_downselect_met_rad`.
+        """
+        # compute lookahead for future contrails from downwash_flight
+        met_time = met.indexes["time"].to_numpy()
+        mask = met_time >= time_end
+        lookahead = np.min(met_time[mask]) if np.any(mask) else time_end
+
+        # create vector for downselection based on current + future contrails
+        future_contrails = self._downwash_flight.filter(
+            (self._downwash_flight["time"] >= time_end)
+            & (self._downwash_flight["time"] <= lookahead),
+            copy=False,
+        )
+        vector = GeoVectorDataset(
+            {
+                key: np.concatenate((latest_contrail[key], future_contrails[key]))
+                for key in ("longitude", "latitude", "level", "time")
+            }
+        )
+
+        # compute time buffer to ensure downselection extends to time_end
+        buffers = {
+            f"{coord}_buffer": self.params[f"met_{coord}_buffer"]
+            for coord in ("longitude", "latitude", "level")
+        }
+        buffers["time_buffer"] = (
+            np.timedelta64(0, "ns"),
+            max(np.timedelta64(0, "ns"), time_end - vector["time"].max()),
+        )
+
+        return vector.downselect_met(met, **buffers, copy=False)
+
     def _create_downwash_contrail(self) -> GeoVectorDataset:
         """Get Contrail representation of downwash flight."""
 
@@ -1442,7 +1516,7 @@ def _process_rad(rad: MetDataset) -> MetDataset:
     -----
     - https://www.ecmwf.int/sites/default/files/elibrary/2015/18490-radiation-quantities-ecmwf-model-and-mars.pdf
     - https://confluence.ecmwf.int/pages/viewpage.action?pageId=155337784
-    """  # noqa: E501
+    """
     # If the time coordinate has already been shifted, early return
     if "shift_radiation_time" in rad["time"].attrs:
         return rad

pycontrails/models/cocip/cocip_params.py

@@ -84,6 +84,27 @@ class CocipParams(ModelParams):
     #: Humidity scaling
     humidity_scaling: HumidityScaling | None = None
 
+    #: Experimental. If ``True``, attempt to reduce memory consumption during
+    #: aircraft performance and initial contrail formation/persistent calculations
+    #: by calling :meth:`MetDataArray.interpolate` with ``lowmem=True``.
+    #:
+    #: **IMPORTANT**:
+    #:
+    #: * Memory optimizations used when ``proprocess_lowmem=True`` are designed for
+    #:   meteorology backed by dask arrays with a chunk size of 1 along
+    #:   the time dimension. This option may degrade performance if dask if not used
+    #:   or if chunks contain more than a single time step.
+    #: * The impact on runtime of setting ``preprocess_lowmem=True`` depends on how
+    #:   meteorology data is chunked. Runtime is likely to increase if meteorology
+    #:   data is chunked in time only, but may decrease if meteorology data is also
+    #:   chunked in longitude, latitude, and level.
+    #: * Changes to data access patterns with ``preprocess_lowmem=True`` alter locations
+    #:   where interpolation is in- vs out-of-bounds. As a consequence,
+    #:   Cocip output with ``preprocess_lowmem=True`` is only guaranteed to match output
+    #:   with ``preprocess_lowmem=False`` when run with ``interpolation_bounds_error=True``
+    #:   to ensure no out-of-bounds interpolation occurs.
+    preprocess_lowmem: bool = False
+
     # --------------
     # Downselect met
     # --------------

pycontrails/models/cocip/output_formats.py

@@ -24,7 +24,6 @@ import pathlib
 import warnings
 from collections.abc import Hashable
 
-import matplotlib.pyplot as plt
 import numpy as np
 import numpy.typing as npt
 import pandas as pd
@@ -639,7 +638,7 @@ def regional_statistics(da_var: xr.DataArray, *, agg: str) -> pd.Series:
     -----
     - The spatial bounding box for each region is defined in Teoh et al. (2023)
     - Teoh, R., Engberg, Z., Shapiro, M., Dray, L., and Stettler, M.: A high-resolution Global
-        Aviation emissions Inventory based on ADS-B (GAIA) for 2019–2021, EGUsphere [preprint],
+        Aviation emissions Inventory based on ADS-B (GAIA) for 2019-2021, EGUsphere [preprint],
         https://doi.org/10.5194/egusphere-2023-724, 2023.
     """
     if (agg == "mean") and (len(da_var.time) > 1):
@@ -716,7 +715,7 @@ def _regional_data_arrays(da_global: xr.DataArray) -> dict[str, xr.DataArray]:
     -----
     - The spatial bounding box for each region is defined in Teoh et al. (2023)
     - Teoh, R., Engberg, Z., Shapiro, M., Dray, L., and Stettler, M.: A high-resolution Global
-        Aviation emissions Inventory based on ADS-B (GAIA) for 2019–2021, EGUsphere [preprint],
+        Aviation emissions Inventory based on ADS-B (GAIA) for 2019-2021, EGUsphere [preprint],
         https://doi.org/10.5194/egusphere-2023-724, 2023.
     """
     return {
@@ -2141,7 +2140,17 @@ def compare_cocip_with_goes(
             name="compare_cocip_with_goes function",
             package_name="cartopy",
             module_not_found_error=e,
-            pycontrails_optional_package="goes",
+            pycontrails_optional_package="sat",
+        )
+
+    try:
+        import matplotlib.pyplot as plt
+    except ModuleNotFoundError as e:
+        dependencies.raise_module_not_found_error(
+            name="compare_cocip_with_goes function",
+            package_name="matplotlib",
+            module_not_found_error=e,
+            pycontrails_optional_package="vis",
         )
 
     # Round `time` to nearest GOES image time slice

pycontrails/models/cocip/radiative_forcing.py

@@ -10,6 +10,7 @@ References
 from __future__ import annotations
 
 import dataclasses
+import itertools
 
 import numpy as np
 import numpy.typing as npt
@@ -941,7 +942,7 @@ def contrail_contrail_overlap_radiative_effects(
     References
     ----------
     - Schumann et al. (2021) Air traffic and contrail changes over Europe during COVID-19:
-        A model study, Atmos. Chem. Phys., 21, 7429–7450, https://doi.org/10.5194/ACP-21-7429-2021.
+        A model study, Atmos. Chem. Phys., 21, 7429-7450, https://doi.org/10.5194/ACP-21-7429-2021.
     - Teoh et al. (2023) Global aviation contrail climate effects from 2019 to 2021.
 
     Notes
@@ -999,8 +1000,7 @@ def contrail_contrail_overlap_radiative_effects(
     # Account for contrail overlapping starting from bottom to top layers
     altitude_layers = np.arange(min_altitude_m, max_altitude_m + 1.0, dz_overlap_m)
 
-    # TODO: replace zip with itertools.pairwise after we drop python3.9 support
-    for alt_layer0, alt_layer1 in zip(altitude_layers, altitude_layers[1:]):
+    for alt_layer0, alt_layer1 in itertools.pairwise(altitude_layers):
         is_in_layer = (altitude >= alt_layer0) & (altitude < alt_layer1)
 
         # Get contrail waypoints at current altitude layer

pycontrails/models/cocipgrid/cocip_grid.py

@@ -143,7 +143,7 @@ class CocipGrid(models.Model):
 
     def eval(
         self, source: GeoVectorDataset | MetDataset | None = None, **params: Any
-    ) -> GeoVectorDataset | MetDataset | NoReturn:
+    ) -> GeoVectorDataset | MetDataset:
         """Run CoCiP simulation on a 4d coordinate grid or arbitrary set of 4d points.
 
         If the :attr:`params` ``verbose_outputs_evolution`` is True, the model holds
@@ -446,9 +446,9 @@ class CocipGrid(models.Model):
         if ap_model := self.params["aircraft_performance"]:
             attrs["ap_model"] = type(ap_model).__name__
 
-        if isinstance(azimuth, (np.floating, np.integer)):
+        if isinstance(azimuth, np.floating | np.integer):
             attrs["azimuth"] = azimuth.item()
-        elif isinstance(azimuth, (float, int)):
+        elif isinstance(azimuth, float | int):
             attrs["azimuth"] = azimuth
 
         if isinstance(self.source, MetDataset):
@@ -897,7 +897,7 @@ def _setdefault_from_params(key: str, vector: GeoVectorDataset, params: dict[str
     if scalar is None:
         return
 
-    if not isinstance(scalar, (int, float)):
+    if not isinstance(scalar, int | float):
         msg = (
             f"Parameter {key} must be a scalar. For non-scalar values, directly "
             "set the data on the 'source'."

pycontrails/models/ps_model/ps_model.py

@@ -312,7 +312,7 @@ class PSFlight(AircraftPerformance):
                 atyp_param.wing_surface_area,
                 q_fuel,
             )
-        elif isinstance(fuel_flow, (int, float)):
+        elif isinstance(fuel_flow, int | float):
             fuel_flow = np.full_like(true_airspeed, fuel_flow)
 
         # Flight phase
@@ -339,11 +339,11 @@ class PSFlight(AircraftPerformance):
 
         # XXX: Explicitly broadcast scalar inputs as needed to keep a consistent
         # output spec.
-        if isinstance(aircraft_mass, (int, float)):
+        if isinstance(aircraft_mass, int | float):
             aircraft_mass = np.full_like(true_airspeed, aircraft_mass)
-        if isinstance(engine_efficiency, (int, float)):
+        if isinstance(engine_efficiency, int | float):
             engine_efficiency = np.full_like(true_airspeed, engine_efficiency)
-        if isinstance(thrust, (int, float)):
+        if isinstance(thrust, int | float):
             thrust = np.full_like(true_airspeed, thrust)
 
         return AircraftPerformanceData(

pycontrails/models/sac.py

@@ -150,7 +150,7 @@ class SAC(Model):
         if scale_humidity:
             for k, v in humidity_scaling.description.items():
                 self.source.attrs[f"humidity_scaling_{k}"] = v
-        if isinstance(engine_efficiency, (int, float)):
+        if isinstance(engine_efficiency, int | float):
             self.source.attrs["engine_efficiency"] = engine_efficiency
 
         return self.source
@@ -236,7 +236,7 @@ def T_sat_liquid(G: ArrayLike) -> ArrayLike:
     # This comment is pasted several places in `pycontrails` -- they should all be
     # addressed at the same time.
     log_ = np.log(G - 0.053)
-    return -46.46 - constants.absolute_zero + 9.43 * log_ + 0.72 * log_**2  # type: ignore[return-value]  # noqa: E501
+    return -46.46 - constants.absolute_zero + 9.43 * log_ + 0.72 * log_**2  # type: ignore[return-value]
 
 
 def _e_sat_liquid_prime(T: ArrayScalarLike) -> ArrayScalarLike:

pycontrails/physics/thermo.py

@@ -163,7 +163,7 @@ def e_sat_liquid(T: ArrayScalarLike) -> ArrayScalarLike:
     # 6.1121 * np.exp((18.678 * (T - 273.15) / 234.5) * (T - 273.15) / (257.14 + (T - 273.15)))
 
     # Magnus Tetens (Murray, 1967)
-    # 6.1078 * np.exp(17.269388 * (T - 273.16) / (T – 35.86))
+    # 6.1078 * np.exp(17.269388 * (T - 273.16) / (T - 35.86))
 
     # Guide to Meteorological Instruments and Methods of Observation (CIMO Guide) (WMO, 2008)
     # 6.112 * np.exp(17.62 * (T - 273.15) / (243.12 + T - 273.15))

pycontrails/utils/json.py

@@ -48,23 +48,21 @@ class NumpyEncoder(json.JSONEncoder):
         """
         if isinstance(
             obj,
-            (
-                np.int_,
-                np.intc,
-                np.intp,
-                np.int8,
-                np.int16,
-                np.int32,
-                np.int64,
-                np.uint8,
-                np.uint16,
-                np.uint32,
-                np.uint64,
-            ),
+            np.int_
+            | np.intc
+            | np.intp
+            | np.int8
+            | np.int16
+            | np.int32
+            | np.int64
+            | np.uint8
+            | np.uint16
+            | np.uint32
+            | np.uint64,
         ):
             return int(obj)
 
-        if isinstance(obj, (np.float16, np.float32, np.float64)):
+        if isinstance(obj, np.float16 | np.float32 | np.float64):
             return float(obj)
 
         # TODO: this is not easily reversible - np.timedelta64(str(np.timedelta64(1, "h"))) raises
@@ -74,10 +72,10 @@ class NumpyEncoder(json.JSONEncoder):
         if isinstance(obj, (np.datetime64)):
             return str(obj)
 
-        if isinstance(obj, (np.complex64, np.complex128)):
+        if isinstance(obj, np.complex64 | np.complex128):
             return {"real": obj.real, "imag": obj.imag}
 
-        if isinstance(obj, (np.ndarray,)):
+        if isinstance(obj, np.ndarray):
             return obj.tolist()
 
         if isinstance(obj, (np.bool_)):
@@ -86,7 +84,7 @@ class NumpyEncoder(json.JSONEncoder):
         if isinstance(obj, (np.void)):
             return None
 
-        if isinstance(obj, (pd.Series, pd.Index)):
+        if isinstance(obj, pd.Series | pd.Index):
             return obj.to_numpy().tolist()
 
         try:
@@ -146,7 +144,7 @@ def dataframe_to_geojson_points(
         )
 
     # downselect dataframe
-    cols = ["longitude", "latitude", "altitude", "time"] + properties
+    cols = ["longitude", "latitude", "altitude", "time", *properties]
     df = df[cols]
 
     # filter out coords with nan values, or filter just on "filter_nan" labels

pycontrails/utils/types.py

@@ -3,8 +3,9 @@
 from __future__ import annotations
 
 import functools
+from collections.abc import Callable
 from datetime import datetime
-from typing import Any, Callable, TypeVar, Union
+from typing import Any, TypeVar
 
 import numpy as np
 import numpy.typing as npt
@@ -12,11 +13,11 @@ import pandas as pd
 import xarray as xr
 
 #: Array like (np.ndarray, xr.DataArray)
-ArrayLike = TypeVar("ArrayLike", np.ndarray, xr.DataArray, Union[xr.DataArray, np.ndarray])
+ArrayLike = TypeVar("ArrayLike", np.ndarray, xr.DataArray, xr.DataArray | np.ndarray)
 
 #: Array or Float (np.ndarray, float)
 ArrayOrFloat = TypeVar(
-    "ArrayOrFloat", npt.NDArray[np.float64], float, Union[float, npt.NDArray[np.float64]]
+    "ArrayOrFloat", npt.NDArray[np.float64], float, float | npt.NDArray[np.float64]
 )
 
 #: Array like input (np.ndarray, xr.DataArray, np.float64, float)
@@ -26,8 +27,8 @@ ArrayScalarLike = TypeVar(
     xr.DataArray,
     np.float64,
     float,
-    Union[np.ndarray, float],
-    Union[xr.DataArray, np.ndarray],
+    np.ndarray | float,
+    xr.DataArray | np.ndarray,
 )
 
 #: Datetime like input (datetime, pd.Timestamp, np.datetime64)
@@ -71,7 +72,7 @@ def support_arraylike(
             return ret
 
         # Keep python native numeric types native
-        if isinstance(arr, (float, int, np.float64)):
+        if isinstance(arr, float | int | np.float64):
             return ret.item()
 
         # Recreate pd.Series