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

pycontrails/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.52.2'
-__version_tuple__ = version_tuple = (0, 52, 2)
+__version__ = version = '0.52.3'
+__version_tuple__ = version_tuple = (0, 52, 3)

pycontrails/core/interpolation.py

@@ -215,7 +215,8 @@ class PycontrailsRegularGridInterpolator(scipy.interpolate.RegularGridInterpolat
 
         if ndim == 1:
             # np.interp could be better ... although that may also promote the dtype
-            return rgi_cython.evaluate_linear_1d(values, indices, norm_distances, out)
+            # 1-d view is required for evaluate_linear_1d
+            return rgi_cython.evaluate_linear_1d(values, indices[0, :], norm_distances[0, :], out)
 
         msg = f"Invalid number of dimensions: {ndim}"
         raise ValueError(msg)

pycontrails/core/met.py

@@ -9,7 +9,15 @@ import pathlib
 import typing
 import warnings
 from abc import ABC, abstractmethod
-from collections.abc import Hashable, Iterable, Iterator, Mapping, MutableMapping, Sequence
+from collections.abc import (
+    Generator,
+    Hashable,
+    Iterable,
+    Iterator,
+    Mapping,
+    MutableMapping,
+    Sequence,
+)
 from contextlib import ExitStack
 from datetime import datetime
 from typing import (
@@ -1502,6 +1510,7 @@ class MetDataArray(MetBase):
         bounds_error: bool = ...,
         fill_value: float | np.float64 | None = ...,
         localize: bool = ...,
+        lowmem: bool = ...,
         indices: interpolation.RGIArtifacts | None = ...,
         return_indices: Literal[False] = ...,
     ) -> npt.NDArray[np.float64]: ...
@@ -1518,6 +1527,7 @@ class MetDataArray(MetBase):
         bounds_error: bool = ...,
         fill_value: float | np.float64 | None = ...,
         localize: bool = ...,
+        lowmem: bool = ...,
         indices: interpolation.RGIArtifacts | None = ...,
         return_indices: Literal[True],
     ) -> tuple[npt.NDArray[np.float64], interpolation.RGIArtifacts]: ...
@@ -1533,6 +1543,7 @@ class MetDataArray(MetBase):
         bounds_error: bool = False,
         fill_value: float | np.float64 | None = np.nan,
         localize: bool = False,
+        lowmem: bool = False,
         indices: interpolation.RGIArtifacts | None = None,
         return_indices: bool = False,
     ) -> npt.NDArray[np.float64] | tuple[npt.NDArray[np.float64], interpolation.RGIArtifacts]:
@@ -1540,7 +1551,9 @@ class MetDataArray(MetBase):
 
         Zero dimensional coordinates are reshaped to 1D arrays.
 
-        Method automatically loads underlying :attr:`data` into memory.
+        If ``lowmem == False``, method automatically loads underlying :attr:`data` into
+        memory. Otherwise, method iterates through smaller subsets of :attr:`data` and releases
+        subsets from memory once interpolation against each subset is finished.
 
         If ``method == "nearest"``, the out array will have the same ``dtype`` as
         the underlying :attr:`data`.
@@ -1586,10 +1599,18 @@ class MetDataArray(MetBase):
         localize: bool, optional
             Experimental. If True, downselect gridded data to smallest bounding box containing
             all points.  By default False.
+        lowmem: bool, optional
+            Experimental. If True, iterate through points binned by the time coordinate of the
+            grided data, and downselect gridded data to the smallest bounding box containing
+            each binned set of point *before loading into memory*. This can significantly reduce
+            memory consumption with large numbers of points at the cost of increased runtime.
+            By default False.
         indices: tuple | None, optional
             Experimental. See :func:`interpolation.interp`. None by default.
         return_indices: bool, optional
             Experimental. See :func:`interpolation.interp`. False by default.
+            Note that values returned differ when ``lowmem=True`` and ``lowmem=False``,
+            so output should only be re-used in calls with the same ``lowmem`` value.
 
         Returns
         -------
@@ -1632,10 +1653,29 @@ class MetDataArray(MetBase):
         >>> level = np.linspace(200, 300, 10)
         >>> time = pd.date_range("2022-03-01T14", periods=10, freq="5min")
         >>> mda.interpolate(longitude, latitude, level, time)
+        array([220.44347694, 223.08900738, 225.74338924, 228.41642088,
+               231.10858599, 233.54857391, 235.71504913, 237.86478872,
+               239.99274623, 242.10792167])
+
+        >>> # Can easily switch to alternative low-memory implementation
+        >>> mda.interpolate(longitude, latitude, level, time, lowmem=True)
         array([220.44347694, 223.08900738, 225.74338924, 228.41642088,
                231.10858599, 233.54857391, 235.71504913, 237.86478872,
                239.99274623, 242.10792167])
         """
+        if lowmem:
+            return self._interp_lowmem(
+                longitude,
+                latitude,
+                level,
+                time,
+                method=method,
+                bounds_error=bounds_error,
+                fill_value=fill_value,
+                indices=indices,
+                return_indices=return_indices,
+            )
+
         # Load if necessary
         if not self.in_memory:
             self._check_memory("Interpolation over")
@@ -1660,6 +1700,100 @@ class MetDataArray(MetBase):
             return_indices=return_indices,
         )
 
+    def _interp_lowmem(
+        self,
+        longitude: float | npt.NDArray[np.float64],
+        latitude: float | npt.NDArray[np.float64],
+        level: float | npt.NDArray[np.float64],
+        time: np.datetime64 | npt.NDArray[np.datetime64],
+        *,
+        method: str = "linear",
+        bounds_error: bool = False,
+        fill_value: float | np.float64 | None = np.nan,
+        minimize_memory: bool = False,
+        indices: interpolation.RGIArtifacts | None = None,
+        return_indices: bool = False,
+    ) -> npt.NDArray[np.float64] | tuple[npt.NDArray[np.float64], interpolation.RGIArtifacts]:
+        """Interpolate values against underlying DataArray.
+
+        This method is used by :meth:`interpolate` when ``lowmem=True``.
+        Parameters and return types are identical to :meth:`interpolate`, except
+        that the ``localize`` keyword argument is omitted.
+        """
+        # Convert all inputs to 1d arrays
+        # Not validating against ndim >= 2
+        longitude, latitude, level, time = np.atleast_1d(longitude, latitude, level, time)
+
+        if bounds_error:
+            _lowmem_boundscheck(time, self.data)
+
+        # Create buffers for holding interpolation output
+        # Use np.full rather than np.empty so points not covered
+        # by masks are filled with correct out-of-bounds values.
+        out = np.full(longitude.shape, fill_value, dtype=self.data.dtype)
+        if return_indices:
+            rgi_artifacts = interpolation.RGIArtifacts(
+                xi_indices=np.full((4, longitude.size), -1, dtype=np.int64),
+                norm_distances=np.full((4, longitude.size), np.nan, dtype=np.float64),
+                out_of_bounds=np.full((longitude.size,), True, dtype=np.bool_),
+            )
+
+        # Iterate over portions of points between adjacent time steps in gridded data
+        for mask in _lowmem_masks(time, self.data["time"].values):
+            if mask is None or not np.any(mask):
+                continue
+
+            lon_sl = longitude[mask]
+            lat_sl = latitude[mask]
+            lev_sl = level[mask]
+            t_sl = time[mask]
+            if indices is not None:
+                indices_sl = interpolation.RGIArtifacts(
+                    xi_indices=indices.xi_indices[:, mask],
+                    norm_distances=indices.norm_distances[:, mask],
+                    out_of_bounds=indices.out_of_bounds[mask],
+                )
+            else:
+                indices_sl = None
+
+            coords = {"longitude": lon_sl, "latitude": lat_sl, "level": lev_sl, "time": t_sl}
+            if any(np.all(np.isnan(coord)) for coord in coords.values()):
+                continue
+            da = interpolation._localize(self.data, coords)
+            if not da._in_memory:
+                logger.debug(
+                    "Loading %s MB subset of %s into memory.",
+                    round(da.nbytes / 1_000_000, 2),
+                    da.name,
+                )
+                da.load()
+
+            tmp = interpolation.interp(
+                longitude=lon_sl,
+                latitude=lat_sl,
+                level=lev_sl,
+                time=t_sl,
+                da=da,
+                method=method,
+                bounds_error=bounds_error,
+                fill_value=fill_value,
+                localize=False,  # would be no-op; da is localized already
+                indices=indices_sl,
+                return_indices=return_indices,
+            )
+
+            if return_indices:
+                out[mask], rgi_sl = tmp
+                rgi_artifacts.xi_indices[:, mask] = rgi_sl.xi_indices
+                rgi_artifacts.norm_distances[:, mask] = rgi_sl.norm_distances
+                rgi_artifacts.out_of_bounds[mask] = rgi_sl.out_of_bounds
+            else:
+                out[mask] = tmp
+
+        if return_indices:
+            return out, rgi_artifacts
+        return out
+
     def _check_memory(self, msg_start: str) -> None:
         """Check the memory usage of the underlying data.
 
@@ -2656,3 +2790,46 @@ def _add_vertical_coords(data: XArrayType) -> XArrayType:
         data.coords["altitude"] = data.coords["altitude"].astype(dtype, copy=False)
 
     return data
+
+
+def _lowmem_boundscheck(time: npt.NDArray[np.datetime64], da: xr.DataArray) -> None:
+    """Extra bounds check required with low-memory interpolation strategy.
+
+    Because the main loop in `_interp_lowmem` processes points between time steps
+    in gridded data, it will never encounter points that are out-of-bounds in time
+    and may fail to produce requested out-of-bounds errors.
+    """
+    da_time = da["time"].to_numpy()
+    if not np.all((time >= da_time.min()) & (time <= da_time.max())):
+        axis = da.get_axis_num("time")
+        msg = f"One of the requested xi is out of bounds in dimension {axis}"
+        raise ValueError(msg)
+
+
+def _lowmem_masks(
+    time: npt.NDArray[np.datetime64], t_met: npt.NDArray[np.datetime64]
+) -> Generator[npt.NDArray[np.bool_], None, None]:
+    """Generate sequence of masks for low-memory interpolation."""
+    t_met_max = t_met.max()
+    t_met_min = t_met.min()
+    inbounds = (time >= t_met_min) & (time <= t_met_max)
+    if not np.any(inbounds):
+        return
+
+    earliest = np.nanmin(time)
+    istart = 0 if earliest < t_met_min else np.flatnonzero(t_met <= earliest).max()
+    latest = np.nanmax(time)
+    iend = t_met.size - 1 if latest > t_met_max else np.flatnonzero(t_met >= latest).min()
+    if istart == iend:
+        yield inbounds
+        return
+
+    # Sequence of masks covers elements in time in the interval [t_met[istart], t_met[iend]].
+    # The first iteration masks elements in the interval [t_met[istart], t_met[istart+1]]
+    # (inclusive of both endpoints).
+    # Subsequent iterations mask elements in the interval (t_met[i], t_met[i+1]]
+    # (inclusive of right endpoint only).
+    for i in range(istart, iend):
+        mask = ((time >= t_met[i]) if i == istart else (time > t_met[i])) & (time <= t_met[i + 1])
+        if np.any(mask):
+            yield mask

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**
 
@@ -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.concat((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."""
 

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
@@ -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-0.52.2.dist-info → pycontrails-0.52.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pycontrails
-Version: 0.52.2
+Version: 0.52.3
 Summary: Python library for modeling aviation climate impacts
 Author-email: Breakthrough Energy <py@contrails.org>
 License: Apache-2.0
@@ -27,92 +27,92 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: NOTICE
-Requires-Dist: dask >=2022.3
-Requires-Dist: numpy >=1.22
-Requires-Dist: overrides >=6.1
-Requires-Dist: pandas >=2.2
-Requires-Dist: scipy >=1.10
-Requires-Dist: xarray >=2022.3
+Requires-Dist: dask>=2022.3
+Requires-Dist: numpy>=1.22
+Requires-Dist: overrides>=6.1
+Requires-Dist: pandas>=2.2
+Requires-Dist: scipy>=1.10
+Requires-Dist: xarray>=2022.3
 Provides-Extra: complete
-Requires-Dist: pycontrails[ecmwf,gcp,gfs,jupyter,pyproj,sat,vis,zarr] ; extra == 'complete'
+Requires-Dist: pycontrails[ecmwf,gcp,gfs,jupyter,pyproj,sat,vis,zarr]; extra == "complete"
 Provides-Extra: dev
-Requires-Dist: black[jupyter] ==24.4.2 ; extra == 'dev'
-Requires-Dist: dep-license ; extra == 'dev'
-Requires-Dist: fastparquet >=0.8 ; extra == 'dev'
-Requires-Dist: ipdb >=0.13 ; extra == 'dev'
-Requires-Dist: memory-profiler ; extra == 'dev'
-Requires-Dist: mypy >=1.8 ; extra == 'dev'
-Requires-Dist: mypy-extensions >=1.0 ; extra == 'dev'
-Requires-Dist: platformdirs >=3.0 ; extra == 'dev'
-Requires-Dist: pre-commit >=2.10 ; extra == 'dev'
-Requires-Dist: psutil ; extra == 'dev'
-Requires-Dist: pyarrow >=5.0 ; extra == 'dev'
-Requires-Dist: pytest >=8.2 ; extra == 'dev'
-Requires-Dist: pytest-cov >=2.11 ; extra == 'dev'
-Requires-Dist: requests >=2.25 ; extra == 'dev'
-Requires-Dist: ruff ==0.5.3 ; extra == 'dev'
-Requires-Dist: setuptools ; extra == 'dev'
+Requires-Dist: black[jupyter]==24.4.2; extra == "dev"
+Requires-Dist: dep-license; extra == "dev"
+Requires-Dist: fastparquet>=0.8; extra == "dev"
+Requires-Dist: ipdb>=0.13; extra == "dev"
+Requires-Dist: memory-profiler; extra == "dev"
+Requires-Dist: mypy>=1.8; extra == "dev"
+Requires-Dist: mypy-extensions>=1.0; extra == "dev"
+Requires-Dist: platformdirs>=3.0; extra == "dev"
+Requires-Dist: pre-commit>=2.10; extra == "dev"
+Requires-Dist: psutil; extra == "dev"
+Requires-Dist: pyarrow>=5.0; extra == "dev"
+Requires-Dist: pytest>=8.2; extra == "dev"
+Requires-Dist: pytest-cov>=2.11; extra == "dev"
+Requires-Dist: requests>=2.25; extra == "dev"
+Requires-Dist: ruff==0.5.3; extra == "dev"
+Requires-Dist: setuptools; extra == "dev"
 Provides-Extra: docs
-Requires-Dist: doc8 >=1.1 ; extra == 'docs'
-Requires-Dist: furo >=2023.3 ; extra == 'docs'
-Requires-Dist: myst-parser >=1.0 ; extra == 'docs'
-Requires-Dist: nb-clean >=3.2 ; extra == 'docs'
-Requires-Dist: nbsphinx >=0.9 ; extra == 'docs'
-Requires-Dist: nbval !=0.10.0,>=0.9.6 ; extra == 'docs'
-Requires-Dist: pytest-check-links >=0.8.0 ; extra == 'docs'
-Requires-Dist: sphinx >=4.2 ; extra == 'docs'
-Requires-Dist: sphinx-autobuild >=0.7 ; extra == 'docs'
-Requires-Dist: sphinxcontrib-bibtex >=2.2 ; extra == 'docs'
-Requires-Dist: sphinx-copybutton >=0.5 ; extra == 'docs'
-Requires-Dist: sphinxext.opengraph >=0.8 ; extra == 'docs'
+Requires-Dist: doc8>=1.1; extra == "docs"
+Requires-Dist: furo>=2023.3; extra == "docs"
+Requires-Dist: myst-parser>=1.0; extra == "docs"
+Requires-Dist: nb-clean>=3.2; extra == "docs"
+Requires-Dist: nbsphinx>=0.9; extra == "docs"
+Requires-Dist: nbval!=0.10.0,>=0.9.6; extra == "docs"
+Requires-Dist: pytest-check-links>=0.8.0; extra == "docs"
+Requires-Dist: sphinx>=4.2; extra == "docs"
+Requires-Dist: sphinx-autobuild>=0.7; extra == "docs"
+Requires-Dist: sphinxcontrib-bibtex>=2.2; extra == "docs"
+Requires-Dist: sphinx-copybutton>=0.5; extra == "docs"
+Requires-Dist: sphinxext.opengraph>=0.8; extra == "docs"
 Provides-Extra: ecmwf
-Requires-Dist: cdsapi >=0.4 ; extra == 'ecmwf'
-Requires-Dist: cfgrib >=0.9 ; extra == 'ecmwf'
-Requires-Dist: eccodes >=1.4 ; extra == 'ecmwf'
-Requires-Dist: ecmwf-api-client >=1.6 ; extra == 'ecmwf'
-Requires-Dist: netcdf4 >=1.6.1 ; extra == 'ecmwf'
-Requires-Dist: platformdirs >=3.0 ; extra == 'ecmwf'
-Requires-Dist: requests >=2.25 ; extra == 'ecmwf'
-Requires-Dist: lxml >=5.1.0 ; extra == 'ecmwf'
+Requires-Dist: cdsapi>=0.4; extra == "ecmwf"
+Requires-Dist: cfgrib>=0.9; extra == "ecmwf"
+Requires-Dist: eccodes>=1.4; extra == "ecmwf"
+Requires-Dist: ecmwf-api-client>=1.6; extra == "ecmwf"
+Requires-Dist: netcdf4>=1.6.1; extra == "ecmwf"
+Requires-Dist: platformdirs>=3.0; extra == "ecmwf"
+Requires-Dist: requests>=2.25; extra == "ecmwf"
+Requires-Dist: lxml>=5.1.0; extra == "ecmwf"
 Provides-Extra: gcp
-Requires-Dist: google-cloud-storage >=2.1 ; extra == 'gcp'
-Requires-Dist: platformdirs >=3.0 ; extra == 'gcp'
-Requires-Dist: tqdm >=4.61 ; extra == 'gcp'
+Requires-Dist: google-cloud-storage>=2.1; extra == "gcp"
+Requires-Dist: platformdirs>=3.0; extra == "gcp"
+Requires-Dist: tqdm>=4.61; extra == "gcp"
 Provides-Extra: gfs
-Requires-Dist: boto3 >=1.20 ; extra == 'gfs'
-Requires-Dist: cfgrib >=0.9 ; extra == 'gfs'
-Requires-Dist: eccodes >=1.4 ; extra == 'gfs'
-Requires-Dist: platformdirs >=3.0 ; extra == 'gfs'
-Requires-Dist: tqdm >=4.61 ; extra == 'gfs'
+Requires-Dist: boto3>=1.20; extra == "gfs"
+Requires-Dist: cfgrib>=0.9; extra == "gfs"
+Requires-Dist: eccodes>=1.4; extra == "gfs"
+Requires-Dist: platformdirs>=3.0; extra == "gfs"
+Requires-Dist: tqdm>=4.61; extra == "gfs"
 Provides-Extra: jupyter
-Requires-Dist: ipywidgets >=7.6 ; extra == 'jupyter'
-Requires-Dist: jupyterlab >=2.2 ; extra == 'jupyter'
+Requires-Dist: ipywidgets>=7.6; extra == "jupyter"
+Requires-Dist: jupyterlab>=2.2; extra == "jupyter"
 Provides-Extra: open3d
-Requires-Dist: open3d >=0.14 ; extra == 'open3d'
+Requires-Dist: open3d>=0.14; extra == "open3d"
 Provides-Extra: pyproj
-Requires-Dist: pyproj >=3.5 ; extra == 'pyproj'
+Requires-Dist: pyproj>=3.5; extra == "pyproj"
 Provides-Extra: sat
-Requires-Dist: cartopy >=0.22 ; extra == 'sat'
-Requires-Dist: db-dtypes >=1.2 ; extra == 'sat'
-Requires-Dist: gcsfs >=2022.3 ; extra == 'sat'
-Requires-Dist: geojson >=3.1 ; extra == 'sat'
-Requires-Dist: google-cloud-bigquery >=3.23 ; extra == 'sat'
-Requires-Dist: google-cloud-bigquery-storage >=2.25 ; extra == 'sat'
-Requires-Dist: pillow >=10.3 ; extra == 'sat'
-Requires-Dist: pyproj >=3.5 ; extra == 'sat'
-Requires-Dist: rasterio >=1.3 ; extra == 'sat'
-Requires-Dist: scikit-image >=0.18 ; extra == 'sat'
+Requires-Dist: cartopy>=0.22; extra == "sat"
+Requires-Dist: db-dtypes>=1.2; extra == "sat"
+Requires-Dist: gcsfs>=2022.3; extra == "sat"
+Requires-Dist: geojson>=3.1; extra == "sat"
+Requires-Dist: google-cloud-bigquery>=3.23; extra == "sat"
+Requires-Dist: google-cloud-bigquery-storage>=2.25; extra == "sat"
+Requires-Dist: pillow>=10.3; extra == "sat"
+Requires-Dist: pyproj>=3.5; extra == "sat"
+Requires-Dist: rasterio>=1.3; extra == "sat"
+Requires-Dist: scikit-image>=0.18; extra == "sat"
 Provides-Extra: vis
-Requires-Dist: matplotlib >=3.3 ; extra == 'vis'
-Requires-Dist: opencv-python-headless >=4.5 ; extra == 'vis'
-Requires-Dist: scikit-learn >=0.23 ; extra == 'vis'
-Requires-Dist: scikit-image >=0.18 ; extra == 'vis'
-Requires-Dist: seaborn >=0.11 ; extra == 'vis'
-Requires-Dist: shapely >=2.0 ; extra == 'vis'
+Requires-Dist: matplotlib>=3.3; extra == "vis"
+Requires-Dist: opencv-python-headless>=4.5; extra == "vis"
+Requires-Dist: scikit-learn>=0.23; extra == "vis"
+Requires-Dist: scikit-image>=0.18; extra == "vis"
+Requires-Dist: seaborn>=0.11; extra == "vis"
+Requires-Dist: shapely>=2.0; extra == "vis"
 Provides-Extra: zarr
-Requires-Dist: fsspec >=2022.7.1 ; extra == 'zarr'
-Requires-Dist: gcsfs >=2022.7.1 ; extra == 'zarr'
-Requires-Dist: zarr >=2.12 ; extra == 'zarr'
+Requires-Dist: fsspec>=2022.7.1; extra == "zarr"
+Requires-Dist: gcsfs>=2022.7.1; extra == "zarr"
+Requires-Dist: zarr>=2.12; extra == "zarr"
 
 # pycontrails
 

{pycontrails-0.52.2.dist-info → pycontrails-0.52.3.dist-info}/RECORD

@@ -1,5 +1,5 @@
 pycontrails/__init__.py,sha256=EpPulx2dBYpqZNsyh6HTwGGnFsvBVHBXabG5VInwSg4,2071
-pycontrails/_version.py,sha256=4pmj8jsxVwfVqZJgR1h1AgtFc2HbrVerdrhzrtIYe-U,429
+pycontrails/_version.py,sha256=DwcfPcd9EyaZVcBfypzp-ZYnJMP7npcKts9iUv9NVh0,429
 pycontrails/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pycontrails/core/__init__.py,sha256=X0DX2FGboPN_svwN2xiBzoPpHhDtg0oKFjXQfmCqMWU,886
 pycontrails/core/aircraft_performance.py,sha256=osV68kKLpvnzBX8fqZcBefbKoYqTxhAf2EWLRdTA7Ec,26748
@@ -10,12 +10,12 @@ pycontrails/core/fleet.py,sha256=vB1XHcajtTLlelY_u72SAYUCt3h2smzqZIpeLFJaW0M,166
 pycontrails/core/flight.py,sha256=lLqS0lWLCaN8YPusi1AzPZqtyHr4dZTYJ9SC3rosd7Q,87453
 pycontrails/core/flightplan.py,sha256=cpMZ6VCYbfwh3vnew2XgVEHnqBx1NzeAhrTVCvlbbss,7569
 pycontrails/core/fuel.py,sha256=06YUDhvC8Rx6KbUXRB9qLTsJX2V7tLbzjwAfDH0R6l8,4472
-pycontrails/core/interpolation.py,sha256=JY97IkHIgLRExxHN0B28R2CM5xXRYB1n4xT3gr4xPgU,26238
-pycontrails/core/met.py,sha256=ihIP3kxat_OpgsUwVtol-esctzoaWtTCbHCFkMa3RB8,96625
+pycontrails/core/interpolation.py,sha256=FnaVFT9OQXNLTx3FjUgqkgXVohn1JL0fdQTgEAPBgag,26309
+pycontrails/core/met.py,sha256=WOaIOZkLI7ocqK0pzEv01zhQ7-l0G_t39dppj4Iqfvw,104160
 pycontrails/core/met_var.py,sha256=JzB7UhBLQyU4TuKZqemhpBHA6Dbt89BPYO2sYBLMkL4,9504
 pycontrails/core/models.py,sha256=D5pnAxejpDbHfh_wszxTA4cq6dr2L0Sn3OBmSL4zSsA,40491
 pycontrails/core/polygon.py,sha256=F403uzql_c47MPM2Qdmec6WwtFaXZyb48h-4gK-K4EU,18577
-pycontrails/core/rgi_cython.cp312-win_amd64.pyd,sha256=GPWcLucRIhHAUx_vOk6cgFUW2Z7Al3o2lQ5b6nHhEbA,264704
+pycontrails/core/rgi_cython.cp312-win_amd64.pyd,sha256=wa7z0fJ5CEorJu7Pir8ZUjY_sSw-_oD2fUnYxMHbYRA,265216
 pycontrails/core/vector.py,sha256=YdzU47DSilECjYAvqZb2M_Lgs7OP7JvrDceneq4cKCU,73762
 pycontrails/datalib/__init__.py,sha256=Q2RrnjwtFzfsmJ2tEojDCzDMkd8R0MYw4mQz3YwUsqI,381
 pycontrails/datalib/goes.py,sha256=UMxXXCiRL6SHY5_3cXs8GmG19eeKOOi3gKCimkyZSuc,27305
@@ -58,11 +58,11 @@ pycontrails/models/apcemm/inputs.py,sha256=zHRSWVVlwYw6ms7PpC0p0I-xFsRDUVY9eDZ1g
 pycontrails/models/apcemm/utils.py,sha256=6pKQbS5EAzTnI_edVtUvGrzM0xwNq1t9MBGgCRJtg_0,17531
 pycontrails/models/apcemm/static/apcemm_yaml_template.yaml,sha256=A3H_FWVOtqkZhG91TWLdblMKaLWIcjRMsKqkfTN6mB4,6928
 pycontrails/models/cocip/__init__.py,sha256=miDxSFxN9PzL_ieSJb3BYeHmbKqZwGicCz1scNB5eW0,991
-pycontrails/models/cocip/cocip.py,sha256=wnzAoBxKnmGhJcUDYeWuHCmnjRfDCJmE20UYpUPnkBI,99731
-pycontrails/models/cocip/cocip_params.py,sha256=T4IseK6KtY4hG3BuGZBtFgM90HCYecUXsb_QVEK6uGo,11670
+pycontrails/models/cocip/cocip.py,sha256=BpHdEw3T9lICO9AvxpWO9tAU73APvUfMqKR4QakdSlo,102726
+pycontrails/models/cocip/cocip_params.py,sha256=JwQl8FLcp4l5-MLiMQhPsxHL8jKXg2ymWXD7Jbn3zTQ,13002
 pycontrails/models/cocip/cocip_uncertainty.py,sha256=7W586BJEAY_wpSpfVdcdX-HpZG4twk3cMLhUR2ELTMA,12176
 pycontrails/models/cocip/contrail_properties.py,sha256=u6SvucHC6VtF2kujfSVFTfv0263t5uYpNOUJZAroEzc,57111
-pycontrails/models/cocip/output_formats.py,sha256=kJ2qexnl4yBZJpgxHGHvIjiH5CRWFx9quOiL-DEQvOw,85604
+pycontrails/models/cocip/output_formats.py,sha256=cmkFDo66K-2cZuH1uutJSIw0EqcOPD9Dj5bXSoyXsh4,85906
 pycontrails/models/cocip/radiative_forcing.py,sha256=SYmQ8lL8gpWbf6he2C9mKSjODtytbFcdnMdBM-LtBKE,46206
 pycontrails/models/cocip/radiative_heating.py,sha256=N7FTR20luERmokprdqMOl-d8-cTYZZ2ZSsTdxZnLHfs,19368
 pycontrails/models/cocip/unterstrasser_wake_vortex.py,sha256=Ymz-uO9vVhLIFwT9yuF5g1g3hcT-XWdryLsebSBqoVU,14976
@@ -101,9 +101,9 @@ pycontrails/utils/iteration.py,sha256=En2YY4NiNwCNtAVO8HL6tv9byBGKs8MKSI7R8P-gZy
 pycontrails/utils/json.py,sha256=xCv71CKVZNHk4MyoYC-hl7dXObXXbI7P8gcNCn3AUoU,6172
 pycontrails/utils/temp.py,sha256=5XXqQoEfWjz1OrhoOBZD5vkkCFeuq9LpZkyhc38gIeY,1159
 pycontrails/utils/types.py,sha256=gNG9cSZ3djW7jufg0h1fXM3kD24sBY6ENE6wsxY_Q6o,4937
-pycontrails-0.52.2.dist-info/LICENSE,sha256=HVr8JnZfTaA-12BfKUQZi5hdrB3awOwLWs5X_ga5QzA,10353
-pycontrails-0.52.2.dist-info/METADATA,sha256=rxyQhAnaf7KzOKQA_15Z0_H2zL2E_I7V5qbK7XcHASA,9488
-pycontrails-0.52.2.dist-info/NOTICE,sha256=qYeNEp8OjDK5jSW3hTlr9LQRjZeEhXQm0zDei5UFaYs,1969
-pycontrails-0.52.2.dist-info/WHEEL,sha256=KNRoynpGu-d6mheJI-zfvcGl1iN-y8BewbiCDXsF3cY,101
-pycontrails-0.52.2.dist-info/top_level.txt,sha256=Z8J1R_AiBAyCVjNw6jYLdrA68PrQqTg0t3_Yek_IZ0Q,29
-pycontrails-0.52.2.dist-info/RECORD,,
+pycontrails-0.52.3.dist-info/LICENSE,sha256=HVr8JnZfTaA-12BfKUQZi5hdrB3awOwLWs5X_ga5QzA,10353
+pycontrails-0.52.3.dist-info/METADATA,sha256=WcCq_h2VOQZQdue96yM1vAEvn9KRdxl3siBcaS9bGrI,9351
+pycontrails-0.52.3.dist-info/NOTICE,sha256=qYeNEp8OjDK5jSW3hTlr9LQRjZeEhXQm0zDei5UFaYs,1969
+pycontrails-0.52.3.dist-info/WHEEL,sha256=KNRoynpGu-d6mheJI-zfvcGl1iN-y8BewbiCDXsF3cY,101
+pycontrails-0.52.3.dist-info/top_level.txt,sha256=Z8J1R_AiBAyCVjNw6jYLdrA68PrQqTg0t3_Yek_IZ0Q,29
+pycontrails-0.52.3.dist-info/RECORD,,