pycontrails 0.56.0__cp311-cp311-win_amd64.whl → 0.58.0__cp311-cp311-win_amd64.whl

pycontrails/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.56.0'
-__version_tuple__ = version_tuple = (0, 56, 0)
+__version__ = version = '0.58.0'
+__version_tuple__ = version_tuple = (0, 58, 0)
 
-__commit_id__ = commit_id = 'gec7f244f4'
+__commit_id__ = commit_id = 'g142ff7355'

pycontrails/core/aircraft_performance.py

@@ -550,7 +550,7 @@ class AircraftPerformance(Model):
             if self.met is None:
                 cond = np.isnan(u) & np.isnan(v)
             else:
-                met_level_max = self.met.data["level"][-1].item()  # type: ignore[union-attr]
+                met_level_max = self.met.data["level"][-1].item()
                 cond = self.source.level > met_level_max
 
             # We DON'T overwrite the original u and v arrays already attached to the source

pycontrails/core/cache.py

@@ -189,7 +189,7 @@ class DiskCacheStore(CacheStore):
         self,
         cache_dir: str | pathlib.Path | None = None,
         allow_clear: bool = False,
-    ):
+    ) -> None:
         if cache_dir is None:
             # Avoid unnecessary import of platformdirs (called in _get_user_cache_dir)
             cache_dir = os.getenv("PYCONTRAILS_CACHE_DIR") or _get_user_cache_dir()
@@ -461,7 +461,7 @@ class GCPCacheStore(CacheStore):
         timeout: int = 300,
         show_progress: bool = False,
         chunk_size: int = 64 * 262144,
-    ):
+    ) -> None:
         try:
             from google.cloud import storage
         except ModuleNotFoundError as e:

pycontrails/core/fleet.py

@@ -5,12 +5,7 @@ from __future__ import annotations
 import sys
 import warnings
 from collections.abc import Iterable
-from typing import Any, NoReturn
-
-if sys.version_info >= (3, 11):
-    from typing import Self
-else:
-    from typing_extensions import Self
+from typing import Any, NoReturn, Self
 
 if sys.version_info >= (3, 12):
     from typing import override
@@ -122,7 +117,7 @@ class Fleet(Flight):
         # Set default fl_attrs if not provided
         fl_attrs = fl_attrs or {}
         for flight_id in groups.index:
-            fl_attrs.setdefault(flight_id, {})  # type: ignore[call-overload]
+            fl_attrs.setdefault(flight_id, {})
 
         extra = fl_attrs.keys() - groups.index
         if extra:

pycontrails/core/flight.py

@@ -6,18 +6,13 @@ import enum
 import logging
 import sys
 import warnings
-from typing import TYPE_CHECKING, Any, NoReturn
+from typing import TYPE_CHECKING, Any, NoReturn, Self
 
 if sys.version_info >= (3, 12):
     from typing import override
 else:
     from typing_extensions import override
 
-if sys.version_info >= (3, 11):
-    from typing import Self
-else:
-    from typing_extensions import Self
-
 
 import numpy as np
 import numpy.typing as npt
@@ -2138,7 +2133,7 @@ def segment_rocd(
     T_correction[:-1] = (air_temperature[:-1] + air_temperature[1:]) / (T_isa[:-1] + T_isa[1:])
     T_correction[-1] = np.nan
 
-    return T_correction * out  # type: ignore[return-value]
+    return T_correction * out
 
 
 def _resample_to_freq_or_time(

pycontrails/core/interpolation.py

@@ -26,57 +26,74 @@ class PycontrailsRegularGridInterpolator(scipy.interpolate.RegularGridInterpolat
 
     This class is a thin wrapper around the
     :class:`scipy.interpolate.RegularGridInterpolator` in order to make typical
-    ``pycontrails`` use-cases more efficient.
+    ``pycontrails`` linear interpolation use-cases more performant:
 
-    #. Avoid ``RegularGridInterpolator`` constructor validation. In :func:`interp`,
-    parameters are carefully crafted to fit into the intended form, thereby making
-    validation unnecessary.
+    #. Avoid ``RegularGridInterpolator`` constructor validation when `method="linear"`.
+       In :func:`interp`, parameters are carefully crafted to fit into the intended form,
+       thereby making validation unnecessary.
     #. Override the :meth:`_evaluate_linear` method with a faster implementation. See
-    the :meth:`_evaluate_linear` docstring for more information.
+       the :meth:`_evaluate_linear` docstring for more information.
 
-    This class should not be used directly. Instead, use the :func:`interp` function.
+    **This class should not be used directly. Instead, use the ``interp`` function.**
 
     .. versionchanged:: 0.40.0
 
         The :meth:`_evaluate_linear` method now uses a Cython implementation. The dtype
         of the output is now consistent with the dtype of the underlying :attr:`values`
 
+    .. versionchanged:: 0.58.0
+
+        Any ``method`` other than ``"linear"`` now uses the
+        :class:`scipy.interpolate.RegularGridInterpolator` implementation. This
+        allows for greater flexibility in the ``method`` parameter.
+
     Parameters
     ----------
     points : tuple[npt.NDArray[np.floating], ...]
         Coordinates of the grid points.
     values : npt.NDArray[np.floating]
         Grid values. The shape of this array must be compatible with the
-        coordinates. An error is raised if the dtype is not ``np.float32``
-        or ``np.float64``.
+        coordinates.
     method : str
         Passed into :class:`scipy.interpolate.RegularGridInterpolator`
     bounds_error : bool
         Passed into :class:`scipy.interpolate.RegularGridInterpolator`
     fill_value : float | np.float64 | None
         Passed into :class:`scipy.interpolate.RegularGridInterpolator`
+
+    See Also
+    --------
+    scipy.interpolate.RegularGridInterpolator
+    interp
     """
 
     def __init__(
         self,
         points: tuple[npt.NDArray[np.floating], ...],
         values: npt.NDArray[np.floating],
+        *,
         method: str,
         bounds_error: bool,
         fill_value: float | np.float64 | None,
-    ):
-        if values.dtype not in (np.float32, np.float64):
-            msg = f"values must be a float array, not {values.dtype}"
-            raise ValueError(msg)
-
+    ) -> None:
+        if method != "linear" or values.dtype not in (np.float32, np.float64):
+            # Slow path: use parent class
+            super().__init__(
+                points,
+                values,
+                method=method,
+                bounds_error=bounds_error,
+                fill_value=fill_value,
+            )
+            return
+
+        # Fast path: no validation
         self.grid = points
         self.values = values
-        # TODO: consider supporting updated tensor-product spline methods
-        # see https://github.com/scipy/scipy/releases/tag/v1.13.0
-        self.method = _pick_method(scipy.__version__, method)
+        self.method = method
         self.bounds_error = bounds_error
         self.fill_value = fill_value
-        self._spline = None
+        self._spline = None  # XXX: setting private attribute on RGI
 
     def _prepare_xi_simple(self, xi: npt.NDArray[np.floating]) -> npt.NDArray[np.bool_]:
         """Run looser version of :meth:`_prepare_xi`.
@@ -103,7 +120,7 @@ class PycontrailsRegularGridInterpolator(scipy.interpolate.RegularGridInterpolat
 
             return np.zeros(xi.shape[0], dtype=bool)
 
-        return self._find_out_of_bounds(xi.T)
+        return self._find_out_of_bounds(xi.T)  # XXX: calling private method on RGI
 
     def __call__(
         self, xi: npt.NDArray[np.floating], method: str | None = None
@@ -130,7 +147,7 @@ class PycontrailsRegularGridInterpolator(scipy.interpolate.RegularGridInterpolat
             return super().__call__(xi, method)
 
         out_of_bounds = self._prepare_xi_simple(xi)
-        xi_indices, norm_distances = rgi_cython.find_indices(self.grid, xi.T)
+        xi_indices, norm_distances = self._find_indices(xi.T)  # XXX: calling private method on RGI
 
         out = self._evaluate_linear(xi_indices, norm_distances)
         return self._set_out_of_bounds(out, out_of_bounds)
@@ -223,45 +240,6 @@ class PycontrailsRegularGridInterpolator(scipy.interpolate.RegularGridInterpolat
         raise ValueError(msg)
 
 
-def _pick_method(scipy_version: str, method: str) -> str:
-    """Select an interpolation method.
-
-    For scipy versions 1.13.0 and later, fall back on legacy implementations
-    of tensor-product spline methods. The default implementations in 1.13.0
-    and later are incompatible with this class.
-
-    Parameters
-    ----------
-    scipy_version : str
-        scipy version (major.minor.patch)
-
-    method : str
-        Interpolation method. Passed into :class:`scipy.interpolate.RegularGridInterpolator`
-        as-is unless ``scipy_version`` is 1.13.0 or later and ``method`` is ``"slinear"``,
-        ``"cubic"``, or ``"quintic"``. In this case, ``"_legacy"`` is appended to ``method``.
-
-    Returns
-    -------
-    str
-        Interpolation method adjusted for compatibility with this class.
-    """
-    if method == "linear":
-        return method
-
-    try:
-        version = scipy_version.split(".")
-        major = int(version[0])
-        minor = int(version[1])
-    except (IndexError, ValueError) as exc:
-        msg = f"Failed to parse major and minor version from {scipy_version}"
-        raise ValueError(msg) from exc
-
-    reimplemented_methods = ["slinear", "cubic", "quintic"]
-    if major > 1 or ((major == 1 and minor >= 13) and method in reimplemented_methods):
-        return method + "_legacy"
-    return method
-
-
 def _floatize_time(
     time: npt.NDArray[np.datetime64], offset: np.datetime64
 ) -> npt.NDArray[np.floating]:
@@ -431,7 +409,7 @@ def interp(
         Include ``indices`` and ``return_indices`` experimental parameters.
         Currently, nan values in ``longitude``, ``latitude``, ``level``, or ``time``
         are always propagated through to the output, regardless of ``bounds_error``.
-        In other words, a ValueError for an out of bounds coordinate is only raised
+        In other words, a ``ValueError`` for an out of bounds coordinate is only raised
         if a non-nan value is out of bounds.
 
     .. versionchanged:: 0.40.0
@@ -480,9 +458,9 @@ def interp(
 
     See Also
     --------
-    - :meth:`MetDataArray.interpolate`
-    - :func:`scipy.interpolate.interpn`
-    - :class:`scipy.interpolate.RegularGridInterpolator`
+    pycontrails.MetDataArray.interpolate
+    scipy.interpolate.interpn
+    scipy.interpolate.RegularGridInterpolator
     """
     if localize:
         coords = {"longitude": longitude, "latitude": latitude, "level": level, "time": time}
@@ -579,7 +557,7 @@ def _linear_interp_with_indices(
     if indices is None:
         assert xi is not None, "xi must be provided if indices is None"
         out_of_bounds = interp._prepare_xi_simple(xi)
-        xi_indices, norm_distances = rgi_cython.find_indices(interp.grid, xi.T)
+        xi_indices, norm_distances = interp._find_indices(xi.T)
         indices = RGIArtifacts(xi_indices, norm_distances, out_of_bounds)
 
     out = interp._evaluate_linear(indices.xi_indices, indices.norm_distances)
@@ -606,7 +584,7 @@ class EmissionsProfileInterpolator:
 
     This class simply wraps :func:`numpy.interp` with fixed values for the
     ``xp`` and ``fp`` arguments. Unlike :class:`xarray.DataArray` interpolation,
-    the `numpy.interp` automatically clips values outside the range of the
+    the :func:`numpy.interp` automatically clips values outside the range of the
     ``xp`` array.
 
     Parameters

pycontrails/core/met.py

@@ -26,15 +26,11 @@ from typing import (
     Any,
     Generic,
     Literal,
+    Self,
     TypeVar,
     overload,
 )
 
-if sys.version_info >= (3, 11):
-    from typing import Self
-else:
-    from typing_extensions import Self
-
 if sys.version_info >= (3, 12):
     from typing import override
 else:
@@ -211,14 +207,22 @@ class MetBase(ABC, Generic[XArrayType]):
         Raises
         ------
         ValueError
-            If one of the coordinates is not sorted.
+            If one of the coordinates is not sorted or contains duplicate values.
         """
         indexes = self.indexes
-        if not np.all(np.diff(indexes["time"]) > np.timedelta64(0, "ns")):
-            raise ValueError("Coordinate 'time' not sorted. Instantiate with 'copy=True'.")
-        for coord in self.dim_order[:3]:  # exclude time, the 4th dimension
-            if not np.all(np.diff(indexes[coord]) > 0.0):
-                raise ValueError(f"Coordinate '{coord}' not sorted. Instantiate with 'copy=True'.")
+        for coord in self.dim_order:
+            arr = indexes[coord]
+            d = np.diff(arr)
+            zero = np.zeros((), dtype=d.dtype)  # ensure same dtype
+
+            if np.any(d <= zero):
+                if np.any(d == zero):
+                    msg = f"Coordinate '{coord}' contains duplicate values."
+                else:
+                    msg = f"Coordinate '{coord}' not sorted."
+
+                msg += " Instantiate with 'copy=True'."
+                raise ValueError(msg)
 
     def _validate_transpose(self) -> None:
         """Check that data is transposed according to :attr:`dim_order`."""
@@ -271,6 +275,10 @@ class MetBase(ABC, Generic[XArrayType]):
             Auxiliary coordinates (altitude and air_pressure) are now cast to the same
             dtype as the underlying grid data.
 
+        .. versionchanged:: 0.58.0
+
+            Duplicate dimension values are dropped, keeping the first occurrence.
+
 
         Parameters
         ----------
@@ -297,6 +305,18 @@ class MetBase(ABC, Generic[XArrayType]):
         # sortby to ensure each coordinate has ascending order
         self.data = self.data.sortby(list(self.dim_order), ascending=True)
 
+        # Drop any duplicated dimension values
+        indexes = self.indexes
+        for coord in self.dim_order:
+            arr = indexes[coord]
+            d = np.diff(arr)
+            zero = np.zeros((), dtype=d.dtype)  # ensure same dtype
+
+            if np.any(d == zero):
+                # Remove duplicates
+                filt = np.r_[True, d > zero]  # prepend True keeps the first occurrence
+                self.data = self.data.isel({coord: filt})
+
         if not self.is_wrapped:
             # Ensure longitude is contained in interval [-180, 180)
             # If longitude has value at 180, we might not want to shift it?
@@ -1087,7 +1107,7 @@ class MetDataset(MetBase):
             out[key] = da.values.ravel()  # type: ignore[index]
 
         if transfer_attrs:
-            out.attrs.update(self.attrs)  # type: ignore[arg-type]
+            out.attrs.update(self.attrs)
 
         return out
 
@@ -1300,7 +1320,7 @@ class MetDataset(MetBase):
         coords: dict[str, np.ndarray] = {}
         for key, val in input_data.items():
             dtype = "datetime64[ns]" if key == "time" else COORD_DTYPE
-            arr: np.ndarray = np.asarray(val, dtype=dtype)  # type: ignore[call-overload]
+            arr: np.ndarray = np.asarray(val, dtype=dtype)
 
             if arr.ndim == 0:
                 arr = arr.reshape(1)
@@ -1889,7 +1909,7 @@ class MetDataArray(MetBase):
         if not self.binary:
             raise NotImplementedError("proportion method is only implemented for binary fields")
 
-        return self.data.sum().values.item() / self.data.count().values.item()  # type: ignore[operator]
+        return self.data.sum().values.item() / self.data.count().values.item()
 
     def find_edges(self) -> Self:
         """Find edges of regions.
@@ -2598,9 +2618,9 @@ def _extract_2d_arr_and_altitude(
     except KeyError:
         altitude = None
     else:
-        altitude = round(altitude)  # type: ignore[call-overload]
+        altitude = round(altitude)
 
-    return arr, altitude  # type: ignore[return-value]
+    return arr, altitude
 
 
 def downselect(data: XArrayType, bbox: tuple[float, ...]) -> XArrayType:

pycontrails/core/polygon.py

@@ -238,7 +238,7 @@ def _contours_to_polygons(
                 latitude=latitude,
                 precision=precision,
                 buffer=buffer,
-                i=child_i,  # type: ignore[arg-type]
+                i=child_i,
             )
 
             candidate = shapely.Polygon(polygon.exterior, [h.exterior for h in holes])
@@ -354,11 +354,11 @@ def find_multipolygon(
         return shapely.MultiPolygon()
 
     assert len(hierarchy) == 1
-    hierarchy = hierarchy[0]  # type: ignore[index]
+    hierarchy = hierarchy[0]
 
     polygons = _contours_to_polygons(
         contours,  # type: ignore[arg-type]
-        hierarchy,  # type: ignore[arg-type]
+        hierarchy,
         min_area,
         convex_hull,
         epsilon,

pycontrails/core/vector.py

@@ -8,12 +8,7 @@ import logging
 import sys
 import warnings
 from collections.abc import Generator, Iterable, Iterator, Sequence
-from typing import Any, overload
-
-if sys.version_info >= (3, 11):
-    from typing import Self
-else:
-    from typing_extensions import Self
+from typing import Any, Self, overload
 
 if sys.version_info >= (3, 12):
     from typing import override
@@ -315,7 +310,7 @@ class VectorDataset:  # noqa: PLW1641
         # Set attributes: always shallow copy
         # -----------------------------------
 
-        self.attrs = AttrDict(attrs or {})  # type: ignore[arg-type]
+        self.attrs = AttrDict(attrs or {})
         self.attrs.update(attrs_kwargs)
 
     @classmethod
@@ -1389,7 +1384,7 @@ class GeoVectorDataset(VectorDataset):
         ):
             keys = *self.required_keys, "altitude"
             self.data = VectorDataDict(_empty_vector_dict(keys))
-            self.attrs = AttrDict(attrs or {})  # type: ignore[arg-type]
+            self.attrs = AttrDict(attrs or {})
             self.attrs.update(attrs_kwargs)
             return
 

pycontrails/datalib/_met_utils/metsource.py

@@ -175,16 +175,13 @@ def parse_pressure_levels(
 
     out = arr.tolist()
     if supported is None:
-        return out  # type: ignore[return-value]
+        return out
 
-    if missing := set(out).difference(supported):  # type: ignore[arg-type]
-        msg = (
-            f"Pressure levels {sorted(missing)} are not supported. "  # type: ignore[type-var]
-            f"Supported levels: {supported}"
-        )
+    if missing := set(out).difference(supported):
+        msg = f"Pressure levels {sorted(missing)} are not supported. Supported levels: {supported}"
         raise ValueError(msg)
 
-    return out  # type: ignore[return-value]
+    return out
 
 
 def parse_variables(variables: VariableInput, supported: list[MetVariable]) -> list[MetVariable]:

pycontrails/datalib/ecmwf/common.py

@@ -61,14 +61,14 @@ class ECMWFAPI(metsource.MetDataSource):
 
         # downselect times
         if not self.timesteps:
-            self.timesteps = ds["time"].values.astype("datetime64[ns]").tolist()  # type: ignore[assignment]
+            self.timesteps = ds["time"].values.astype("datetime64[ns]").tolist()
         else:
             try:
                 ds = ds.sel(time=self.timesteps)
             except KeyError as exc:
                 # this snippet shows the missing times for convenience
                 np_timesteps = {np.datetime64(t, "ns") for t in self.timesteps}
-                missing_times = sorted(np_timesteps.difference(ds["time"].values))  # type: ignore[type-var]
+                missing_times = sorted(np_timesteps.difference(ds["time"].values))
                 msg = f"Input dataset is missing time coordinates {[str(t) for t in missing_times]}"
                 raise KeyError(msg) from exc
 

pycontrails/datalib/ecmwf/hres.py

@@ -708,7 +708,7 @@ class HRES(ECMWFAPI):
 
         # set forecast time if it's not defined (this occurs when only the paths param is provided)
         if not hasattr(self, "forecast_time"):
-            self.forecast_time = ds["time"].values.astype("datetime64[s]").tolist()  # type: ignore[assignment]
+            self.forecast_time = ds["time"].values.astype("datetime64[s]").tolist()
 
         # check that forecast_time is correct if defined
         # note the "time" coordinate here is the HRES forecast_time
@@ -723,7 +723,7 @@ class HRES(ECMWFAPI):
         # set timesteps if not defined
         # note that "time" is now the actual timestep coordinates
         if not self.timesteps:
-            self.timesteps = ds["time"].values.astype("datetime64[s]").tolist()  # type: ignore[assignment]
+            self.timesteps = ds["time"].values.astype("datetime64[s]").tolist()
 
         self.cache_dataset(ds)
 

pycontrails/datalib/ecmwf/ifs.py

@@ -149,7 +149,7 @@ class IFS(metsource.MetDataSource):
         else:
             # set timesteps from dataset "time" coordinates
             # np.datetime64 doesn't covert to list[datetime] unless its unit is us
-            self.timesteps = ds["time"].values.astype("datetime64[us]").tolist()  # type: ignore[assignment]
+            self.timesteps = ds["time"].values.astype("datetime64[us]").tolist()
 
         # downselect hyam/hybm coefficients by the "lev" coordinate
         # (this is a 1-indexed verison of nhym)