pycontrails 0.54.4__cp312-cp312-win_amd64.whl → 0.54.6__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.54.4'
-__version_tuple__ = version_tuple = (0, 54, 4)
+__version__ = version = '0.54.6'
+__version_tuple__ = version_tuple = (0, 54, 6)

pycontrails/core/aircraft_performance.py

@@ -96,22 +96,52 @@ class AircraftPerformance(Model):
 
     source: Flight
 
-    @abc.abstractmethod
     @overload
     def eval(self, source: Fleet, **params: Any) -> Fleet: ...
 
-    @abc.abstractmethod
     @overload
     def eval(self, source: Flight, **params: Any) -> Flight: ...
 
-    @abc.abstractmethod
     @overload
     def eval(self, source: None = ..., **params: Any) -> NoReturn: ...
 
-    @abc.abstractmethod
     def eval(self, source: Flight | None = None, **params: Any) -> Flight:
         """Evaluate the aircraft performance model.
 
+        Parameters
+        ----------
+        source : Flight
+            Flight trajectory to evaluate. Can be a :class:`Flight` or :class:`Fleet`.
+        params : Any
+            Override :attr:`params` with keyword arguments.
+
+        Returns
+        -------
+        Flight
+            Flight trajectory with aircraft performance data.
+        """
+        self.update_params(params)
+        self.set_source(source)
+        self.source = self.require_source_type(Flight)
+        self.downselect_met()
+        self.set_source_met()
+        self._cleanup_indices()
+
+        # Calculate true airspeed if not included on source
+        self.ensure_true_airspeed_on_source()
+
+        if isinstance(self.source, Fleet):
+            fls = [self.eval_flight(fl) for fl in self.source.to_flight_list()]
+            self.source = Fleet.from_seq(fls, attrs=self.source.attrs, broadcast_numeric=False)
+            return self.source
+
+        self.source = self.eval_flight(self.source)
+        return self.source
+
+    @abc.abstractmethod
+    def eval_flight(self, fl: Flight) -> Flight:
+        """Evaluate the aircraft performance model on a single flight trajectory.
+
         The implementing model adds the following fields to the source flight:
 
         - ``aircraft_mass``: aircraft mass at each waypoint, [:math:`kg`]
@@ -128,18 +158,6 @@ class AircraftPerformance(Model):
         - ``max_mach``: maximum Mach number
         - ``max_altitude``: maximum altitude, [:math:`m`]
         - ``total_fuel_burn``: total fuel burn, [:math:`kg`]
-
-        Parameters
-        ----------
-        source : Flight
-            Flight trajectory to evaluate.
-        params : Any
-            Override :attr:`params` with keyword arguments.
-
-        Returns
-        -------
-        Flight
-            Flight trajectory with aircraft performance data.
         """
 
     @override

pycontrails/core/airports.py

@@ -162,7 +162,7 @@ def find_nearest_airport(
     ) & airports["latitude"].between((latitude - bbox), (latitude + bbox))
 
     # Find the nearest airport from largest to smallest airport type
-    search_priority = ["large_airport", "medium_airport", "small_airport"]
+    search_priority = ("large_airport", "medium_airport", "small_airport")
 
     for airport_type in search_priority:
         is_airport_type = airports["type"] == airport_type
@@ -171,7 +171,7 @@ def find_nearest_airport(
         if len(nearest_airports) == 1:
             return nearest_airports["icao_code"].values[0]
 
-        elif len(nearest_airports) > 1:
+        if len(nearest_airports) > 1:
             distance = distance_to_airports(
                 nearest_airports,
                 longitude,
@@ -181,8 +181,7 @@ def find_nearest_airport(
             i_nearest = np.argmin(distance)
             return nearest_airports["icao_code"].values[i_nearest]
 
-        else:
-            continue
+        continue
 
     return None
 

pycontrails/core/fleet.py

@@ -133,18 +133,19 @@ class Fleet(Flight):
 
     @override
     def copy(self, **kwargs: Any) -> Self:
-        kwargs.setdefault("fuel", self.fuel)
         kwargs.setdefault("fl_attrs", self.fl_attrs)
+        kwargs.setdefault("final_waypoints", self.final_waypoints)
         return super().copy(**kwargs)
 
     @override
     def filter(self, mask: npt.NDArray[np.bool_], copy: bool = True, **kwargs: Any) -> Self:
-        kwargs.setdefault("fuel", self.fuel)
-
         flight_ids = set(np.unique(self["flight_id"][mask]))
         fl_attrs = {k: v for k, v in self.fl_attrs.items() if k in flight_ids}
         kwargs.setdefault("fl_attrs", fl_attrs)
 
+        final_waypoints = np.array(self.final_waypoints[mask], copy=copy)
+        kwargs.setdefault("final_waypoints", final_waypoints)
+
         return super().filter(mask, copy=copy, **kwargs)
 
     @override
@@ -187,8 +188,9 @@ class Fleet(Flight):
             in ``seq``.
         """
 
+        # Create a shallow copy because we add additional keys in _validate_fl
         def _shallow_copy(fl: Flight) -> Flight:
-            return Flight(VectorDataDict(fl.data), attrs=fl.attrs, copy=False, fuel=fl.fuel)
+            return Flight._from_fastpath(fl.data, fl.attrs, fuel=fl.fuel)
 
         def _maybe_warn(fl: Flight) -> Flight:
             if not fl:
@@ -217,7 +219,18 @@ class Fleet(Flight):
             )
 
         data = {var: np.concatenate([fl[var] for fl in seq]) for var in seq[0]}
-        return cls(data=data, attrs=attrs, copy=False, fuel=fuel, fl_attrs=fl_attrs)
+
+        final_waypoints = np.zeros(data["time"].size, dtype=bool)
+        final_waypoint_indices = np.cumsum([fl.size for fl in seq]) - 1
+        final_waypoints[final_waypoint_indices] = True
+
+        return cls._from_fastpath(
+            data,
+            attrs,
+            fuel=fuel,
+            fl_attrs=fl_attrs,
+            final_waypoints=final_waypoints,
+        )
 
     @property
     def n_flights(self) -> int:
@@ -246,11 +259,19 @@ class Fleet(Flight):
             List of Flights in the same order as was passed into the ``Fleet`` instance.
         """
         indices = self.dataframe.groupby("flight_id", sort=False).indices
+        if copy:
+            return [
+                Flight._from_fastpath(
+                    {k: v[idx] for k, v in self.data.items()},
+                    self.fl_attrs[flight_id],
+                    fuel=self.fuel,
+                ).copy()
+                for flight_id, idx in indices.items()
+            ]
         return [
-            Flight(
-                data=VectorDataDict({k: v[idx] for k, v in self.data.items()}),
-                attrs=self.fl_attrs[flight_id],
-                copy=copy,
+            Flight._from_fastpath(
+                {k: v[idx] for k, v in self.data.items()},
+                self.fl_attrs[flight_id],
                 fuel=self.fuel,
             )
             for flight_id, idx in indices.items()

pycontrails/core/flight.py

@@ -891,7 +891,7 @@ class Flight(GeoVectorDataset):
         """
         methods = "geodesic", "linear"
         if fill_method not in methods:
-            raise ValueError(f'Unknown `fill_method`. Supported  methods: {", ".join(methods)}')
+            raise ValueError(f"Unknown `fill_method`. Supported  methods: {', '.join(methods)}")
 
         # STEP 0: If self is empty, return an empty flight
         if not self:
@@ -957,7 +957,12 @@ class Flight(GeoVectorDataset):
                 msg = f"{msg} Pass 'keep_original_index=True' to keep the original index."
             warnings.warn(msg)
 
-        return type(self)(data=df, attrs=self.attrs, fuel=self.fuel)
+        # Reorder columns (this is unimportant but makes the output more canonical)
+        coord_names = ("longitude", "latitude", "altitude", "time")
+        df = df[[*coord_names, *[c for c in df.columns if c not in set(coord_names)]]]
+
+        data = {k: v.to_numpy() for k, v in df.items()}
+        return type(self)._from_fastpath(data, attrs=self.attrs, fuel=self.fuel)
 
     def clean_and_resample(
         self,
@@ -1977,9 +1982,7 @@ def filter_altitude(
             result[i0:i1] = altitude_filt[i0:i1]
 
     # reapply Savitzky-Golay filter to smooth climb and descent
-    result = _sg_filter(result, window_length=kernel_size)
-
-    return result
+    return _sg_filter(result, window_length=kernel_size)
 
 
 def segment_duration(

pycontrails/core/flightplan.py

@@ -21,24 +21,24 @@ def to_atc_plan(plan: dict[str, Any]) -> str:
     --------
     :func:`parse_atc_plan`
     """
-    ret = f'(FPL-{plan["callsign"]}-{plan["flight_rules"]}'
-    ret += f'{plan["type_of_flight"]}\n'
+    ret = f"(FPL-{plan['callsign']}-{plan['flight_rules']}"
+    ret += f"{plan['type_of_flight']}\n"
     ret += "-"
     if "number_aircraft" in plan and plan["number_aircraft"] <= 10:
         ret += plan["number_aircraft"]
-    ret += f'{plan["type_of_aircraft"]}/{plan["wake_category"]}-'
-    ret += f'{plan["equipment"]}/{plan["transponder"]}\n'
-    ret += f'-{plan["departure_icao"]}{plan["time"]}\n'
-    ret += f'-{plan["speed_type"]}{plan["speed"]}{plan["level_type"]}'
-    ret += f'{plan["level"]} {plan["route"]}\n'
+    ret += f"{plan['type_of_aircraft']}/{plan['wake_category']}-"
+    ret += f"{plan['equipment']}/{plan['transponder']}\n"
+    ret += f"-{plan['departure_icao']}{plan['time']}\n"
+    ret += f"-{plan['speed_type']}{plan['speed']}{plan['level_type']}"
+    ret += f"{plan['level']} {plan['route']}\n"
     if "destination_icao" in plan and "duration" in plan:
-        ret += f'-{plan["destination_icao"]}{plan["duration"]}'
+        ret += f"-{plan['destination_icao']}{plan['duration']}"
     if "alt_icao" in plan:
-        ret += f' {plan["alt_icao"]}'
+        ret += f" {plan['alt_icao']}"
     if "second_alt_icao" in plan:
-        ret += f' {plan["second_alt_icao"]}'
+        ret += f" {plan['second_alt_icao']}"
     ret += "\n"
-    ret += f'-{plan["other_info"]})\n'
+    ret += f"-{plan['other_info']})\n"
     if "supplementary_info" in plan:
         ret += " ".join([f"{i[0]}/{i[1]}" for i in plan["supplementary_info"].items()])
 

pycontrails/core/interpolation.py

@@ -245,6 +245,9 @@ def _pick_method(scipy_version: str, method: str) -> str:
     str
         Interpolation method adjusted for compatibility with this class.
     """
+    if method == "linear":
+        return method
+
     try:
         version = scipy_version.split(".")
         major = int(version[0])
@@ -486,15 +489,15 @@ def interp(
         da = _localize(da, coords)
 
     indexes = da._indexes
-    x = indexes["longitude"].index.to_numpy()  # type: ignore[attr-defined]
-    y = indexes["latitude"].index.to_numpy()  # type: ignore[attr-defined]
-    z = indexes["level"].index.to_numpy()  # type: ignore[attr-defined]
+    x = indexes["longitude"].index.values  # type: ignore[attr-defined]
+    y = indexes["latitude"].index.values  # type: ignore[attr-defined]
+    z = indexes["level"].index.values  # type: ignore[attr-defined]
     if any(v.dtype != np.float64 for v in (x, y, z)):
         msg = "da must have float64 dtype for longitude, latitude, and level coordinates"
         raise ValueError(msg)
 
     # Convert t and time to float64
-    t = indexes["time"].index.to_numpy()  # type: ignore[attr-defined]
+    t = indexes["time"].index.values  # type: ignore[attr-defined]
     offset = t[0]
     t = _floatize_time(t, offset)