pycontrails 0.48.0__cp311-cp311-macosx_11_0_arm64.whl → 0.48.1__cp311-cp311-macosx_11_0_arm64.whl

pycontrails/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.48.0'
-__version_tuple__ = version_tuple = (0, 48, 0)
+__version__ = version = '0.48.1'
+__version_tuple__ = version_tuple = (0, 48, 1)

pycontrails/core/met.py

@@ -96,13 +96,14 @@ class MetBase(ABC, Generic[XArrayType]):
         for dim in self.dim_order:
             if dim not in self.data.dims:
                 if dim == "level":
-                    raise ValueError(
+                    msg = (
                         f"Meteorology data must contain dimension '{dim}'. "
                         "For single level data, set 'level' coordinate to constant -1 "
                         "using `ds = ds.expand_dims({'level': [-1]})`"
                     )
                 else:
-                    raise ValueError(f"Meteorology data must contain dimension '{dim}'.")
+                    msg = f"Meteorology data must contain dimension '{dim}'."
+                raise ValueError(msg)
 
     def _validate_longitude(self) -> None:
         """Check longitude bounds.
@@ -196,15 +197,15 @@ class MetBase(ABC, Generic[XArrayType]):
 
         dims_tuple = tuple(self.dim_order)
 
-        def _check_da(da: xr.DataArray, key: str | None = None) -> None:
+        def _check_da(da: xr.DataArray, key: Hashable | None = None) -> None:
             if da.dims != dims_tuple:
                 if key is not None:
                     msg = (
-                        "Data dimension not transposed on variable '{key}'. Initiate with"
-                        " `copy=True`."
+                        f"Data dimension not transposed on variable '{key}'. Initiate with"
+                        " 'copy=True'."
                     )
                 else:
-                    msg = "Data dimension not transposed. Initiate with `copy=True`."
+                    msg = "Data dimension not transposed. Initiate with 'copy=True'."
                 raise ValueError(msg)
 
         data = self.data
@@ -212,7 +213,7 @@ class MetBase(ABC, Generic[XArrayType]):
             _check_da(data)
             return
 
-        for key, da in self.data.data_vars.items():
+        for key, da in self.data.items():
             _check_da(da, key)
 
     def _validate_dims(self) -> None:
@@ -654,11 +655,9 @@ class MetDataset(MetBase):
         attrs: dict[str, Any] | None = None,
         **attrs_kwargs: Any,
     ) -> None:
-        # init cache
         self.cachestore = cachestore
 
-        data.attrs.update(attrs or {})
-        data.attrs.update(attrs_kwargs)
+        data.attrs.update(attrs or {}, **attrs_kwargs)
 
         # if input is already a Dataset, copy into data
         if not isinstance(data, xr.Dataset):
@@ -872,7 +871,7 @@ class MetDataset(MetBase):
             Raises when dataset does not contain variable in ``vars``
         """
         if isinstance(vars, (MetVariable, str)):
-            vars = [vars]
+            vars = (vars,)
 
         met_keys: list[str] = []
         for variable in vars:
@@ -1372,7 +1371,7 @@ class MetDataArray(MetBase):
         """
         if not self.in_memory:
             self._check_memory("Extracting numpy array from")
-            self.data = self.data.load()
+            self.data.load()
 
         return self.data.values
 
@@ -1618,8 +1617,20 @@ class MetDataArray(MetBase):
         )
 
     def _check_memory(self, msg_start: str) -> None:
+        """Check the memory usage of the underlying data.
+
+        If the data is larger than 4 GB, a warning is issued. If the data is
+        larger than 32 GB, a RuntimeError is raised.
+        """
         n_bytes = self.data.nbytes
+        mb = round(n_bytes / int(1e6), 2)
+        logger.debug("Loading %s into memory consumes %s MB.", self.name, mb)
+
         n_gb = n_bytes // int(1e9)
+        if n_gb <= 4:
+            return
+
+        # Prevent something stupid
         msg = (
             f"{msg_start} MetDataArray {self.name} requires loading "
             f"at least {n_gb} GB of data into memory. Downselect data if possible. "
@@ -1627,13 +1638,9 @@ class MetDataArray(MetBase):
             "with the method 'downselect_met'."
         )
 
-        if n_gb > 32:  # Prevent something stupid
+        if n_gb > 32:
             raise RuntimeError(msg)
-        if n_gb > 4:
-            warnings.warn(msg)
-
-        mb = round(n_bytes / int(1e6), 2)
-        logger.debug("Loading %s into memory consumes %s MB.", self.name, mb)
+        warnings.warn(msg)
 
     def save(self, **kwargs: Any) -> list[str]:
         """Save intermediate to :attr:`cachestore` as netcdf.
@@ -2228,24 +2235,29 @@ def _is_zarr(ds: xr.Dataset | xr.DataArray) -> bool:
     return dask0.array.array.array.__class__.__name__ == "ZarrArrayWrapper"
 
 
-def shift_longitude(data: XArrayType) -> XArrayType:
-    """Shift longitude values from [0, 360) to [-180, 180) domain.
+def shift_longitude(data: XArrayType, bound: float = -180.0) -> XArrayType:
+    """Shift longitude values from any input domain to [bound, 360 + bound) domain.
 
     Sorts data by ascending longitude values.
 
+
     Parameters
     ----------
     data : XArrayType
         :class:`xr.Dataset` or :class:`xr.DataArray` with longitude dimension
+    bound : float, optional
+        Lower bound of the domain.
+        Output domain will be [bound, 360 + bound).
+        Defaults to -180, which results in longitude domain [-180, 180).
 
 
     Returns
     -------
     XArrayType
-        :class:`xr.Dataset` or :class:`xr.DataArray` with longitude values on [-180, 180).
+        :class:`xr.Dataset` or :class:`xr.DataArray` with longitude values on [a, 360 + a).
     """
     return data.assign_coords(
-        longitude=((data["longitude"].values + 180.0) % 360.0) - 180.0
+        longitude=((data["longitude"].values - bound) % 360.0) + bound
     ).sortby("longitude", ascending=True)
 
 

pycontrails/core/met_var.py

@@ -2,10 +2,10 @@
 
 from __future__ import annotations
 
-from dataclasses import dataclass
+import dataclasses
 
 
-@dataclass
+@dataclasses.dataclass(frozen=True)
 class MetVariable:
     """Met variable defined using CF, ECMWF, and WMO conventions.
 

pycontrails/core/models.py

@@ -714,6 +714,11 @@ class Model(ABC):
         except KeyError:
             pass
 
+        try:
+            source.attrs["met_source_forecast_time"] = self.met.attrs["forecast_time"]
+        except KeyError:
+            pass
+
 
 def _interp_grid_to_grid(
     met_key: str,

pycontrails/core/vector.py

@@ -18,7 +18,7 @@ from pycontrails.core import coordinates, interpolation
 from pycontrails.core import met as met_module
 from pycontrails.physics import units
 from pycontrails.utils import dependencies
-from pycontrails.utils import json as json_module
+from pycontrails.utils import json as json_utils
 
 logger = logging.getLogger(__name__)
 
@@ -633,6 +633,8 @@ class VectorDataset:
         8  15  18
 
         """
+        vectors = [v for v in vectors if v]  # remove empty vectors
+
         if not vectors:
             return cls()
 
@@ -753,7 +755,7 @@ class VectorDataset:
         str
             Unique hash for flight instance (sha1)
         """
-        _hash = json.dumps(self.data, cls=json_module.NumpyEncoder)
+        _hash = json.dumps(self.data, cls=json_utils.NumpyEncoder)
         return hashlib.sha1(bytes(_hash, "utf-8")).hexdigest()
 
     # ------------
@@ -982,6 +984,104 @@ class VectorDataset:
         df.attrs = self.attrs
         return df
 
+    def to_dict(self) -> dict[str, Any]:
+        """Create dictionary with :attr:`data` and :attr:`attrs`.
+
+        If geo-spatial coordinates (e.g. `"latitude"`, `"longitude"`, `"altitude"`)
+        are present, round to a reasonable precision. If a `"time"` variable is present,
+        round to unix seconds. When the instance is a :class:`GeoVectorDataset`,
+        disregard any `"altitude"` or `"level"` coordinate and only include
+        `"altitude_ft"`in the output.
+
+        Returns
+        -------
+        dict[str, Any]
+            Dictionary with :attr:`data` and :attr:`attrs`.
+
+        See Also
+        --------
+        :meth:`from_dict`
+
+        Examples
+        --------
+        >>> import pprint
+        >>> from pycontrails import Flight
+        >>> fl = Flight(
+        ...     longitude=[-100, -110],
+        ...     latitude=[40, 50],
+        ...     level=[200, 200],
+        ...     time=[np.datetime64("2020-01-01T09"), np.datetime64("2020-01-01T09:30")],
+        ...     aircraft_type="B737",
+        ... )
+        >>> fl = fl.resample_and_fill("5T")
+        >>> pprint.pprint(fl.to_dict())
+        {'aircraft_type': 'B737',
+         'altitude_ft': [38661.0, 38661.0, 38661.0, 38661.0, 38661.0, 38661.0, 38661.0],
+         'crs': 'EPSG:4326',
+         'latitude': [40.0, 41.724, 43.428, 45.111, 46.769, 48.399, 50.0],
+         'longitude': [-100.0,
+                       -101.441,
+                       -102.959,
+                       -104.563,
+                       -106.267,
+                       -108.076,
+                       -110.0],
+         'time': [1577869200,
+                  1577869500,
+                  1577869800,
+                  1577870100,
+                  1577870400,
+                  1577870700,
+                  1577871000]}
+        """
+        np_encoder = json_utils.NumpyEncoder()
+
+        # round latitude, longitude, and altitude
+        precision = {"longitude": 3, "latitude": 3, "altitude_ft": 0}
+
+        def encode(key: str, obj: Any) -> Any:
+            # Try to handle some pandas objects
+            if hasattr(obj, "to_numpy"):
+                obj = obj.to_numpy()
+
+            # Convert numpy objects to python objects
+            if isinstance(obj, (np.ndarray, np.generic)):
+
+                # round time to unix seconds
+                if key == "time":
+                    return np_encoder.default(obj.astype("datetime64[s]").astype(int))
+
+                # round specific keys in precision
+                try:
+                    d = precision[key]
+                except KeyError:
+                    return np_encoder.default(obj)
+
+                return np_encoder.default(obj.astype(float).round(d))
+
+            # Pass through everything else
+            return obj
+
+        data = {k: encode(k, v) for k, v in self.data.items()}
+        attrs = {k: encode(k, v) for k, v in self.attrs.items()}
+
+        # Only include one of the vertical coordinate keys
+        if isinstance(self, GeoVectorDataset):
+            data.pop("altitude", None)
+            data.pop("level", None)
+            if "altitude_ft" not in data:
+                data["altitude_ft"] = self.altitude_ft.round(precision["altitude_ft"]).tolist()
+
+        # Issue warning if any keys are duplicated
+        common_keys = data.keys() & attrs.keys()
+        if common_keys:
+            warnings.warn(
+                f"Found duplicate keys in data and attrs: {common_keys}. "
+                "Data keys will overwrite attrs keys in returned dictionary."
+            )
+
+        return {**attrs, **data}
+
     @classmethod
     def create_empty(
         cls: Type[VectorDatasetType],
@@ -1010,6 +1110,42 @@ class VectorDataset:
         """
         return cls(data=_empty_vector_dict(keys or set()), attrs=attrs, copy=False, **attrs_kwargs)
 
+    @classmethod
+    def from_dict(
+        cls: Type[VectorDatasetType], obj: dict[str, Any], copy: bool = True, **obj_kwargs: Any
+    ) -> VectorDatasetType:
+        """Create instance from dict representation containing data and attrs.
+
+        Parameters
+        ----------
+        obj : dict[str, Any]
+            Dict representation of VectorDataset (e.g. :meth:`to_dict`)
+        copy : bool, optional
+            Passed to VectorDataset constructor.
+            Defaults to True.
+        **obj_kwargs : Any
+            Additional properties passed as keyword arguments.
+
+        Returns
+        -------
+        VectorDatasetType
+            VectorDataset instance.
+
+        See Also
+        --------
+        :meth:`to_dict`
+        """
+        data = {}
+        attrs = {}
+
+        for k, v in {**obj, **obj_kwargs}.items():
+            if isinstance(v, (list, np.ndarray)):
+                data[k] = v
+            else:
+                attrs[k] = v
+
+        return cls(data=data, attrs=attrs, copy=copy)
+
     def generate_splits(
         self: VectorDatasetType, n_splits: int, copy: bool = True
     ) -> Generator[VectorDatasetType, None, None]:
@@ -1182,7 +1318,7 @@ class GeoVectorDataset(VectorDataset):
         if not np.issubdtype(time.dtype, np.datetime64):
             warnings.warn("Time data is not np.datetime64. Attempting to coerce.")
             try:
-                pd_time = pd.to_datetime(self["time"])
+                pd_time = _handle_time_column(pd.Series(self["time"]))
             except ValueError as e:
                 raise ValueError("Could not coerce time data to datetime64.") from e
             np_time = pd_time.to_numpy(dtype="datetime64[ns]")
@@ -1790,7 +1926,7 @@ class GeoVectorDataset(VectorDataset):
         dict[str, Any]
             Python representation of GeoJSON FeatureCollection
         """
-        return json_module.dataframe_to_geojson_points(self.dataframe)
+        return json_utils.dataframe_to_geojson_points(self.dataframe)
 
     def to_pseudo_mercator(self: GeoVectorDatasetType, copy: bool = True) -> GeoVectorDatasetType:
         """Convert data from :attr:`attrs["crs"]` to Pseudo Mercator (EPSG:3857).
@@ -1913,29 +2049,112 @@ def vector_to_lon_lat_grid(
 
 
 def _handle_time_column(time: pd.Series) -> pd.Series:
+    """Ensure that pd.Series has compatible Timestamps.
+
+    Parameters
+    ----------
+    time : pd.Series
+        Pandas dataframe column labeled "time".
+
+
+    Returns
+    -------
+    pd.Series
+        Parsed pandas time series.
+
+
+    Raises
+    ------
+    ValueError
+        When time series can't be parsed, or is not timezone naive.
+    """
     if not hasattr(time, "dt"):
-        # If the time column is a string, we try to convert it to a datetime
-        # If it fails (for example, a unix integer time), we raise an error
-        # and let the user figure it out.
-        try:
-            return pd.to_datetime(time)
-        except ValueError as exc:
-            raise ValueError(
-                "The 'time' field must hold datetime-like values. "
-                'Try data["time"] = pd.to_datetime(data["time"], unit=...) '
-                "with the appropriate unit."
-            ) from exc
+        time = _parse_pandas_time(time)
 
+    # Translate all times to UTC and then remove timezone.
     # If the time column contains a timezone, the call to `to_numpy`
-    # will convert it to an array of object. We do not want this, so
-    # we raise an error in this case. Timezone issues are complicated,
-    # and so it is better for the user to handle them rather than try
-    # to address them here.
+    # will convert it to an array of object.
+    # Note `.tz_convert(None)` automatically converts to UTC first.
     if time.dt.tz is not None:
-        raise ValueError(
-            "The 'time' field must be timezone naive. "
-            "This can be achieved with: "
-            'data["time"] = data["time"].dt.tz_localize(None)'
-        )
+        time = time.dt.tz_convert(None)
 
     return time
+
+
+def _parse_pandas_time(time: pd.Series) -> pd.Series:
+    """Parse pandas dataframe column labelled "time".
+
+    Parameters
+    ----------
+    time : pd.Series
+        Time series
+
+    Returns
+    -------
+    pd.Series
+        Parsed time series
+
+    Raises
+    ------
+    ValueError
+        When series values can't be inferred.
+    """
+    try:
+        # If the time series is a string, try to convert it to a datetime
+        if time.dtype == "O":
+            return pd.to_datetime(time)
+
+        # If the time is an int, try to parse it as unix time
+        if np.issubdtype(time.dtype, np.integer):
+            return _parse_unix_time(time)
+
+        raise ValueError("Unsupported time format")
+
+    except ValueError as exc:
+        raise ValueError(
+            "The 'time' field must hold datetime-like values. "
+            'Try data["time"] = pd.to_datetime(data["time"], unit=...) '
+            "with the appropriate unit."
+        ) from exc
+
+
+def _parse_unix_time(time: list[int] | npt.NDArray[np.int_] | pd.Series) -> pd.Series:
+    """Parse array of int times as unix epoch timestamps.
+
+    Attempts to parse the time in "s", "ms", "us", "ns"
+
+
+    Parameters
+    ----------
+    time : list[int] | npt.NDArray[np.int_] | pd.Series
+        Sequence of unix timestamps
+
+
+    Returns
+    -------
+    pd.Series
+        Series of timezone naive pandas Timestamps
+
+    Raises
+    ------
+    ValueError
+        When unable to parse time as unix epoch timestamp
+    """
+    units = "s", "ms", "us", "ns"
+    for unit in units:
+        try:
+            out = pd.to_datetime(time, unit=unit, utc=True)
+        except ValueError:
+            continue
+
+        # make timezone naive
+        out = out.dt.tz_convert(None)
+
+        # make sure time is reasonable
+        if (pd.Timestamp("1980-01-01") <= out).all() and (out <= pd.Timestamp("2030-01-01")).all():
+            return out
+
+    raise ValueError(
+        f"Unable to parse time parameter '{time}' as unix epoch timestamp between "
+        "1980-01-01 and 2030-01-01"
+    )

pycontrails/models/cocip/cocip.py

@@ -403,14 +403,13 @@ class Cocip(Model):
         self.contrail_list = []
         self._simulate_contrail_evolution()
 
-        self._cleanup_indices()
-
         if not self.contrail_list:
             logger.debug("No contrails formed by %s", label)
             return self._fill_empty_flight_results(return_flight_list)
 
         logger.debug("Complete contrail simulation for %s", label)
 
+        self._cleanup_indices()
         self._bundle_results()
 
         if return_flight_list:
@@ -1098,12 +1097,20 @@ class Cocip(Model):
 
     @overrides
     def _cleanup_indices(self) -> None:
-        if self.params["interpolation_use_indices"]:
+        """Cleanup interpolation artifacts."""
+
+        if not self.params["interpolation_use_indices"]:
+            return
+
+        if hasattr(self, "contrail_list"):
             for contrail in self.contrail_list:
                 contrail._invalidate_indices()
-            self.source._invalidate_indices()
-            self._sac_flight._invalidate_indices()
+
+        self.source._invalidate_indices()
+        self._sac_flight._invalidate_indices()
+        if hasattr(self, "_downwash_flight"):
             self._downwash_flight._invalidate_indices()
+        if hasattr(self, "_downwash_contrail"):
             self._downwash_contrail._invalidate_indices()
 
     def _bundle_results(self) -> None:
@@ -1115,7 +1122,9 @@ class Cocip(Model):
         self.contrail = pd.concat(dfs)
 
         # add age in hours to the contrail waypoint outputs
-        self.contrail["age_hours"] = self.contrail["age"] / np.timedelta64(1, "h")
+        age_hours = np.empty_like(self.contrail["ef"])
+        np.divide(self.contrail["age"], np.timedelta64(1, "h"), out=age_hours)
+        self.contrail["age_hours"] = age_hours
 
         if self.params["verbose_outputs"]:
             # Compute dt_integration -- logic is somewhat complicated, but
@@ -1140,10 +1149,9 @@ class Cocip(Model):
 
             self.contrail = seq_index.set_index("index")
 
-        # ---
-        # Create contrail xr.Dataset (self.contrail_dataset)
-        # ---
-        if self.params["verbose_outputs"]:
+            # ---
+            # Create contrail xr.Dataset (self.contrail_dataset)
+            # ---
             if isinstance(self.source, Fleet):
                 self.contrail_dataset = xr.Dataset.from_dataframe(
                     self.contrail.set_index(["flight_id", "timestep", "waypoint"])
@@ -1250,9 +1258,11 @@ class Cocip(Model):
         Flight or list[Flight]
             Flight or list of Flight objects with empty variables.
         """
+        self._cleanup_indices()
 
         intersection = self.source.data.pop("_met_intersection")
-        zeros_and_nans = np.where(intersection, 0.0, np.nan)
+        zeros_and_nans = np.zeros(intersection.shape, dtype=np.float32)
+        zeros_and_nans[~intersection] = np.nan
         self.source["ef"] = zeros_and_nans.copy()
         self.source["persistent_1"] = zeros_and_nans.copy()
         self.source["cocip"] = np.sign(zeros_and_nans)

pycontrails/models/cocip/wake_vortex.py

@@ -54,22 +54,24 @@ def max_downward_displacement(
     - :cite:`holzapfelProbabilisticTwoPhaseWake2003`
     - :cite:`schumannContrailCirrusPrediction2012`
     """
-    wingspan_arr = np.broadcast_to(wingspan, true_airspeed.shape)
-    aircraft_mass_arr = np.broadcast_to(aircraft_mass, true_airspeed.shape)
-
     rho_air = thermo.rho_d(air_temperature, air_pressure)
     n_bv = thermo.brunt_vaisala_frequency(air_pressure, air_temperature, dT_dz)
-    t_0 = effective_time_scale(wingspan, true_airspeed, aircraft_mass_arr, rho_air)
+    t_0 = effective_time_scale(wingspan, true_airspeed, aircraft_mass, rho_air)
 
     dz_max_strong = downward_displacement_strongly_stratified(
-        wingspan, true_airspeed, aircraft_mass_arr, rho_air, n_bv
+        wingspan, true_airspeed, aircraft_mass, rho_air, n_bv
     )
 
     is_weakly_stratified = n_bv * t_0 < 0.8
+    if isinstance(wingspan, np.ndarray):
+        wingspan = wingspan[is_weakly_stratified]
+    if isinstance(aircraft_mass, np.ndarray):
+        aircraft_mass = aircraft_mass[is_weakly_stratified]
+
     dz_max_weak = downward_displacement_weakly_stratified(
-        wingspan=wingspan_arr[is_weakly_stratified],
+        wingspan=wingspan,
         true_airspeed=true_airspeed[is_weakly_stratified],
-        aircraft_mass=aircraft_mass_arr[is_weakly_stratified],
+        aircraft_mass=aircraft_mass,
         rho_air=rho_air[is_weakly_stratified],
         n_bv=n_bv[is_weakly_stratified],
         dz_max_strong=dz_max_strong[is_weakly_stratified],

{pycontrails-0.48.0.dist-info → pycontrails-0.48.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pycontrails
-Version: 0.48.0
+Version: 0.48.1
 Summary: Python library for modeling aviation climate impacts
 Author-email: Breakthrough Energy <py@contrails.org>
 License: Apache-2.0
@@ -86,6 +86,7 @@ Provides-Extra: goes
 Requires-Dist: cartopy >=0.22 ; extra == 'goes'
 Requires-Dist: gcsfs >=2022.3 ; extra == 'goes'
 Requires-Dist: h5netcdf >=1.2 ; extra == 'goes'
+Requires-Dist: aiohttp >=3.9.0b0 ; (python_version >= "3.12") and extra == 'goes'
 Provides-Extra: jupyter
 Requires-Dist: ipywidgets >=7.6 ; extra == 'jupyter'
 Requires-Dist: jupyterlab >=2.2 ; extra == 'jupyter'

{pycontrails-0.48.0.dist-info → pycontrails-0.48.1.dist-info}/RECORD

@@ -1,15 +1,15 @@
-pycontrails-0.48.0.dist-info/RECORD,,
-pycontrails-0.48.0.dist-info/LICENSE,sha256=gJ-h7SFFD1mCfR6a7HILvEtodDT6Iig8bLXdgqR6ucA,10175
-pycontrails-0.48.0.dist-info/WHEEL,sha256=eaDTbMedWofVq8IZjew9qeAkoA5Sw2MOU2ppdIRr1Jg,110
-pycontrails-0.48.0.dist-info/NOTICE,sha256=gKI8DcN1WhiXB2SFRKDogcjONldGubTvBxiOYdC4CXU,1926
-pycontrails-0.48.0.dist-info/top_level.txt,sha256=Z8J1R_AiBAyCVjNw6jYLdrA68PrQqTg0t3_Yek_IZ0Q,29
-pycontrails-0.48.0.dist-info/METADATA,sha256=-b5B_zHhhBDG8UAYHm0xU-UK0sS0TWBkO0N0RgH53Ds,8341
-pycontrails/_version.py,sha256=3Sop74OqdDpsMps8WICrEiEBc2DX5k-krBUU75aKjsA,413
+pycontrails-0.48.1.dist-info/RECORD,,
+pycontrails-0.48.1.dist-info/LICENSE,sha256=gJ-h7SFFD1mCfR6a7HILvEtodDT6Iig8bLXdgqR6ucA,10175
+pycontrails-0.48.1.dist-info/WHEEL,sha256=2nXsVu36abDiNGsH9Fliml6zEeomzRt7eNy1CE_Eupc,110
+pycontrails-0.48.1.dist-info/NOTICE,sha256=gKI8DcN1WhiXB2SFRKDogcjONldGubTvBxiOYdC4CXU,1926
+pycontrails-0.48.1.dist-info/top_level.txt,sha256=Z8J1R_AiBAyCVjNw6jYLdrA68PrQqTg0t3_Yek_IZ0Q,29
+pycontrails-0.48.1.dist-info/METADATA,sha256=-DmCMG3RmYaxq1sX_lfwfKAv8gV7naDqpKTadgpTCcI,8423
+pycontrails/_version.py,sha256=SmV-QgndmfqQSl3EnRtXH5ks2pvcWLjNDwIDauQbrGk,413
 pycontrails/__init__.py,sha256=jQlqY1c5d9cKwN5ItqaQdJdhAWnQbHIk4TX6QI-CYww,1962
 pycontrails/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pycontrails/core/rgi_cython.cpython-311-darwin.so,sha256=SBlC1D7Wwa9Jm1oStE3KYgKqw7UmvnsL9DfWBug1LTU,316269
-pycontrails/core/vector.py,sha256=9tSK20AudBN_QHSEagPXyX82JvOdIN-TVrThbhNiNtI,64075
-pycontrails/core/models.py,sha256=q6jv6sqepNYbJSpIZvxggNGUwWzNJjVHxGNiH14fjkA,38163
+pycontrails/core/rgi_cython.cpython-311-darwin.so,sha256=xLdjU0utSeBmWGbDPVbgJkBdHL1VJz9dTi27O7ILX-Y,316269
+pycontrails/core/vector.py,sha256=dHWUnsJasIHldRUtHy00zhONJH1pV8fgJ6sKJHIJrNk,70400
+pycontrails/core/models.py,sha256=MtaujNXbUd0fWINWPqCIqOoWD6jv_sU649D7COavHpc,38306
 pycontrails/core/interpolation.py,sha256=C275gTrX-GJWfMm6gd2LiD-fKSHmMmDFrq--Pn5w_x4,23703
 pycontrails/core/fleet.py,sha256=Zxp23KPV2yugiY210wOLelI66HJLrjEDYa2y8JP1CmY,13278
 pycontrails/core/flight.py,sha256=QJCbVvY5P0JncjfxOHMme1uU3SPXAbs8hXHSRJKJCM4,71895
@@ -19,10 +19,10 @@ pycontrails/core/datalib.py,sha256=L_n0ns2Yspy2NswBJ5fIa5x8vJKdBxknsdWTYL14Jew,2
 pycontrails/core/cache.py,sha256=FvE50YK8dddydozpQHe-XxE1tj8xT5SWcb2LtLj-dC0,28453
 pycontrails/core/__init__.py,sha256=4ZE7x1gMa_Q7GcgcWpPP9fQ-sTulCXWmMjsCJ0odakY,840
 pycontrails/core/flightplan.py,sha256=7BwYPPo4QfqCIWzBwXD848xg34Ggza4ldi4VUogWVYQ,7643
-pycontrails/core/met.py,sha256=gd0oUeFtCASZ311tZOplxYCdSkm6hWuLyMzjjv1empo,88828
+pycontrails/core/met.py,sha256=q1ZyinJ5pzin111ALRqruJV8b1TfoLKq5C5MZTrGDJc,89239
 pycontrails/core/aircraft_performance.py,sha256=8Ig0vWMIe_EDOK4KUhOlzzjkmbvpXz6z0_0f_xZCacI,22149
 pycontrails/core/airports.py,sha256=5D0VF9DxleQlVOmMW-P8_fVVkob-aB3doO1Co2XNFss,6766
-pycontrails/core/met_var.py,sha256=uHIrcO46572QFhHXtC3yRFzDRRyQXmwrVEtfuft-w8s,9185
+pycontrails/core/met_var.py,sha256=zyXWI_9dRS4FfH1Io_k0YcIxZIsp8y4YPiC_Oayi_gs,9195
 pycontrails/core/coordinates.py,sha256=ALGzFXjr4poFsqflg8D0kzUTC5bBjsVcXwiHfEsw7vs,5098
 pycontrails/datalib/goes.py,sha256=2JQ8C3iUtSl6hDjVivv4VB3oCRXxuT3ciB0OCFF2lIE,26150
 pycontrails/datalib/__init__.py,sha256=s5b8W6scXgespKZjPcaC-8jyLd3FqZqN0BZccLxaGuE,237
@@ -67,11 +67,11 @@ pycontrails/models/humidity_scaling/__init__.py,sha256=nqsab_j9BCwMbTfCn4BjXMdhI
 pycontrails/models/humidity_scaling/quantiles/era5-quantiles.pq,sha256=tfYhbafF9Z-gGCg6VQ1YBlOaK_01e65Dc6s9b-hQ6Zo,286375
 pycontrails/models/cocip/radiative_forcing.py,sha256=_dJ6_OM4fBvmhgL6MoDObhfTAUEXx-JzKqb5htYe1H8,44799
 pycontrails/models/cocip/wind_shear.py,sha256=Pr6ZBMnuWK380uzX2mSx0wkNXnufuCjOmV5vpUStRv0,3852
-pycontrails/models/cocip/cocip.py,sha256=nNES6_ylQwsz98ifcbLemVel0eJNborf1HdAlN_Wbi8,91394
+pycontrails/models/cocip/cocip.py,sha256=AMA5I_eR3m959Gfh7VXDy1L9laernIQ_PTV2Kdp3HCc,91752
 pycontrails/models/cocip/output_formats.py,sha256=UKzVc2R4Ij8uAsJbOFz1O9SZo9N5-mG0YfBLI6e_SZA,77118
 pycontrails/models/cocip/__init__.py,sha256=7Wy_CnmVqg_Gpg2UhIlisJOJ3naL6c5BBzTSJqdbiM4,902
 pycontrails/models/cocip/cocip_params.py,sha256=rvOvE028yEs4H0WEPRyYx2kk8PDjvPmNkk43wUu-YRM,10295
-pycontrails/models/cocip/wake_vortex.py,sha256=6_JJvH01988nSJPSpUyg1TyDKr8qWKy6hlbU3iBpMsU,13319
+pycontrails/models/cocip/wake_vortex.py,sha256=HclCU7CuNK_OkkhinWvZB5ipucyGnEsJ3q-_4E6bC5c,13314
 pycontrails/models/cocip/cocip_uncertainty.py,sha256=wJ43NJr3YZX92GiMhY6LUVni9qbsqKg0duCRSS_r_mw,11782
 pycontrails/models/cocip/radiative_heating.py,sha256=PngrHriQDSX1iDKu1v2g9NPRe4w6eGi6123xJD6itz8,18712
 pycontrails/models/cocip/contrail_properties.py,sha256=yMqDbAg751orkqPSKlUlnItsoa9JC8lcfxzeoGc8yEk,56007

{pycontrails-0.48.0.dist-info → pycontrails-0.48.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.2)
+Generator: bdist_wheel (0.41.3)
 Root-Is-Purelib: false
 Tag: cp311-cp311-macosx_11_0_arm64