pycontrails 0.54.3__tar.gz → 0.54.5__tar.gz

{pycontrails-0.54.3 → pycontrails-0.54.5}/.github/workflows/doctest.yaml

@@ -78,8 +78,8 @@ jobs:
       - name: Test notebooks
         run: make nb-test
 
-      # The doctests require numpy 2.0 or higher
+      # The doctests require numpy 2.2 or higher
       - name: Test docstrings
         run: |
-          pip install "numpy>=2.0"
+          pip install "numpy>=2.2"
           make doctest

{pycontrails-0.54.3 → pycontrails-0.54.5}/.github/workflows/release.yaml

@@ -40,7 +40,7 @@ jobs:
 
       # https://cibuildwheel.readthedocs.io/en/stable/options/#testing
       - name: Build wheels
-        uses: pypa/cibuildwheel@v2.21
+        uses: pypa/cibuildwheel@v2.22
         env:
           CIBW_BUILD: cp310-* cp311-* cp312-* cp313-*
           CIBW_SKIP: '*-win32 *-manylinux_i686 *-musllinux*'

{pycontrails-0.54.3 → pycontrails-0.54.5}/.zenodo.json

@@ -44,6 +44,11 @@
       "name": "Tharun Sankar",
       "affiliation": "Google Research",
       "type": "Researcher"
+    },
+    {
+      "name": "Jakob Smretschnig",
+      "affiliation": "TU Delft",
+      "type": "Researcher"
     }
   ]
 }

{pycontrails-0.54.3 → pycontrails-0.54.5}/CHANGELOG.md

@@ -1,5 +1,71 @@
 # Changelog
 
+## v0.54.5
+
+### Features
+
+- This release brings a number of very minor performance improvements to the low-level pycontrails data structures (`VectorDataset` and `MetDataset`). Cumulatively, these changes should bring in a small but nontrivial speedup (~5%) when running a model such as `Cocip` or `DryAdvection` on a single `Flight` source.
+  - Core `Flight` methods such as `copy`, `filter`, and `downselect_met` are now ~10x faster for typical use cases.
+  - Converting between `Fleet` and `Flight` instances via `Fleet.from_seq` and `Fleet.to_flight_list` are also ~5x faster.
+- Implement low-memory met-downselection logic in `DryAdvection`. This is the same logic used in `CocipGrid` to reduce memory consumption by only loading the necessary time slices of the `met` data into memory. If `met` is already loaded into memory, this change will have no effect.
+
+### Breaking Changes
+
+- Remove the `copy` parameter from `GeovectorDataset.downselect_met`. This method always returns a view of the original dataset.
+- Remove the `validate` parameter in  the `MetDataArray` constructor. Input data is now always validated.
+
+### Fixes
+
+- Make slightly more explicit when data is copied in the `VectorDataset` constructor: data is now always shallow-copied, and the `copy` parameter governs whether to copy the underlying arrays.
+- Call `downselect_met` in `DryAdvection.eval`. (This was previously forgotten.)
+- Fix minor bug in `CocipGrid` downselect met logic introduced in v0.54.4. This bug may have caused some met slices to be reloaded when running `CocipGrid.eval` with lazily-loaded `met` and `rad` data.
+
+### Internals
+
+- Add internal `VectorDataset._from_fastpath` and `MetDataset._from_fastpath` class methods to skip data validation.
+- Define `__slots__` on `MetBase`, `MetDataset`, `MetDataArray`, and `AttrDict`.
+- When `MetDataset` and `MetDataArray` shared a common implementation, move the implementation to `MetBase`. This was the case for the `copy`, `downselect`, and `wrap_longitude` methods.
+
+## v0.54.4
+
+### Features
+
+- Improve the `_altitude_interpolation` function used within `Flight.resample_and_fill` and ensure that it is consistent with the [existing GAIA publication](https://acp.copernicus.org/articles/24/725/2024/) The function `_altitude_interpolation` now accounts for various scenarios. For example:
+
+  1. Flight will automatically climb to an assumed cruise altitude if the first and next known waypoints are at very low altitudes with a large time gap.
+  1. If there are large time gaps between known waypoints with a small altitude difference, then the flight will climb at the mid-point of the segment.
+  1. If there are large time gaps and positive altitude difference, then the flight will climb at the start of its interpolation until the known cruising altitude and start its cruise phase.
+  1. If there are large time gaps and negative altitude difference, then the flight will continue cruising and only starts to descend towards the end of the interpolation.
+  1. If there is a shallow climb (ROCD < 500 ft/min), then always assume that the flight will climb at the next time step.
+  1. If there is a shallow descent (-250 < ROCD < 0 ft/min), then always assume that the flight will descend at the final time step.
+
+  Conditions (3) to (6) are based on the logic that the aircraft will generally prefer to climb to a higher altitude as early as possible, and descend to a lower altitude as late as possible, because a higher altitude can reduce drag and fuel consumption.
+
+### Breaking changes
+
+- Remove the optional input parameter `climb_descend_at_end` in `Flight.resample_and_fill`. See the description of the new `_altitude_interpolation` function for the rationale behind this change.
+- Remove the `copy` argument from `Fleet.from_seq`. This argument was redundant and not used effectively in the implementation. The `Fleet.from_seq` method always returns a copy of the input sequence.
+
+### Fixes
+
+- Fix the `ERA5` interface when making a pressure-level request with a single pressure level. This change accommodates CDS-Beta server behavior. Previously, a ValueError was raised in this case.
+- Bypass the ValueError raised by `dask.array.gradient` when the input array is not correctly chunk along the level dimension. Previously, `Cocip` would raise an error when computing tau cirrus in the case that the `met` data had single chunks along the level dimension.
+- Fix the `CocipGrid` met downselection process to accommodate cases where `dt_integration` is as large as the time step of the met data. Previously, due to out-of-bounds interpolation, the output of `CocipGrid(met=met, rad=rad, dt_integration="1 hour")` was zero everywhere when the `met` and `rad` data had a time step of 1 hour.
+- By default, don't interpolate air temperature when running the `DryAdvection` model in a point-wise manner (no wind-shear simulation).
+- Use native python types (as opposed to `numpy` scalars) in the `PSAircraftEngineParams` dataclass.
+- Ensure the `PSGrid` model maintains the precision of the `source`. Previously, float32 precision was lost per [NEP 50](https://numpy.org/neps/nep-0050-scalar-promotion.html).
+- Fix `Fleet.resample_and_fill` when the the "flight_id" field is included on `Fleet.data` (as opposed to `Fleet.fl_attrs`). Previously, this would raise a ValueError.
+- Use the supplied `nominal_rocd` parameter in `Flight.resample_and_fill` rather than `constants.nominal_rocd` (the default value of this parameter).
+
+### Internals
+
+- Add new `AdvectionBuffers` dataclass to override the zero-like values used in `ModelParams` with the buffer previously used in `CocipParams`. This is now a base class for `CocipParams` and `DryAdvectionParams`. In particular, the `DryAdvection` now uses nonzero values for the met downselect buffers.
+- Change the order of advected points returned by `DryAdvection` to be consistent with the input order at each time step.
+- Add the `RUF` ruleset for linting and formatting the codebase.
+- Update type hints for `numpy` 2.2 compatibility. Additional changes may be required after the next iteration of the `numpy` 2.2 series.
+- Relax the tolerance passed into `scipy.optimize.newton` in `ps_nominal_grid` to avoid some convergence warnings. (These warnings were more distracting than informative.)
+- Remove the `_verify_altitude` check in `Flight.resample_and_fill`. This was often triggered by a flight with corrupt waypoints (ie, independent from the logic in `Flight.resample_and_fill`).
+
 ## v0.54.3
 
 ### Breaking changes

{pycontrails-0.54.3 → pycontrails-0.54.5}/Makefile

@@ -218,6 +218,7 @@ nb-check-links:
 	python -m pytest --check-links \
 		--check-links-ignore "https://doi.org/10.1021/acs.est.9b05608" \
 		--check-links-ignore "https://doi.org/10.1021/acs.est.2c05781" \
+		--check-links-ignore "https://doi.org/10.1175/JAMC-D-11-0242.1" \
 		--check-links-ignore "https://github.com/contrailcirrus/pycontrails-bada" \
 		--check-links-ignore "https://ourairports.com" \
 		--check-links-ignore "https://www.ncei.noaa.gov/products/weather-climate-models/global-forecast" \

{pycontrails-0.54.3 → pycontrails-0.54.5}/NOTICE

@@ -1,4 +1,4 @@
-Copyright (c) 2021-2023 Breakthrough Energy
+Copyright (c) 2021-present Breakthrough Energy
 
 
 Attribution

{pycontrails-0.54.3/pycontrails.egg-info → pycontrails-0.54.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pycontrails
-Version: 0.54.3
+Version: 0.54.5
 Summary: Python library for modeling aviation climate impacts
 Author-email: Breakthrough Energy <py@contrails.org>
 License: Apache-2.0
@@ -49,7 +49,7 @@ 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.6.2; extra == "dev"
+Requires-Dist: ruff==0.8.0; extra == "dev"
 Requires-Dist: setuptools; extra == "dev"
 Provides-Extra: docs
 Requires-Dist: doc8>=1.1; extra == "docs"

{pycontrails-0.54.3 → pycontrails-0.54.5}/docs/conf.py

@@ -172,10 +172,12 @@ autodoc_typehints = "none"
 # autodoc options
 autoclass_content = "class"  # only include docstring from Class (not __init__ method)
 autodoc_inherit_docstrings = True
+# https://www.sphinx-doc.org/en/master/usage/extensions/autodoc.html#confval-autodoc_default_options
 autodoc_default_options = {
     "members": None,  # means yes/true/on
     "undoc-members": None,
     "show-inheritance": None,
+    "inherited-members": None,
 }
 
 # Add references in bibtex format here

{pycontrails-0.54.3 → pycontrails-0.54.5}/docs/notebooks/ECMWF.ipynb

@@ -3242,8 +3242,7 @@
     "\n",
     "### Access\n",
     "\n",
-    "Users within ECMWF Member and Co-operating States may contact their Computing Representative to obtain access to MARS. \n",
-    "All other users may [request a username and password](https://accounts.ecmwf.int/auth/realms/ecmwf/protocol/openid-connect/registrations?client_id=apps&response_type=code&scope=openid%20email&redirect_uri=https://www.ecmwf.int) and then [get an api key](https://api.ecmwf.int/v1/key/).\n",
+    "Users within ECMWF Member and Co-operating States may contact their Computing Representative to obtain access to MARS. All other users may [request a username and password](https://confluence.ecmwf.int/display/WEBAPI/Access+MARS) and then [get an api key](https://api.ecmwf.int/v1/key/).\n",
     "\n",
     "Provide `url`, `key`, and `email` credentials on input, or see [ECMWF API Client documentation](https://github.com/ecmwf/ecmwf-api-client#configure) to configure  local `~/.ecmwfapirc` file:\n",
     "\n",

{pycontrails-0.54.3 → pycontrails-0.54.5}/pycontrails/__init__.py

@@ -1,7 +1,7 @@
 """
 ``pycontrails`` public API.
 
-Copyright 2021-2023 Breakthrough Energy
+Copyright 2021-present Breakthrough Energy
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -60,8 +60,8 @@ __all__ = [
     "HydrogenFuel",
     "JetA",
     "MetDataArray",
-    "MetDataset",
     "MetDataSource",
+    "MetDataset",
     "MetVariable",
     "Model",
     "ModelParams",

{pycontrails-0.54.3 → pycontrails-0.54.5}/pycontrails/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.54.3'
-__version_tuple__ = version_tuple = (0, 54, 3)
+__version__ = version = '0.54.5'
+__version_tuple__ = version_tuple = (0, 54, 5)

{pycontrails-0.54.3 → pycontrails-0.54.5}/pycontrails/core/aircraft_performance.py

@@ -163,14 +163,14 @@ class AircraftPerformance(Model):
         self,
         *,
         aircraft_type: str,
-        altitude_ft: npt.NDArray[np.float64],
+        altitude_ft: npt.NDArray[np.floating],
         time: npt.NDArray[np.datetime64],
-        true_airspeed: npt.NDArray[np.float64],
-        air_temperature: npt.NDArray[np.float64],
-        aircraft_mass: npt.NDArray[np.float64] | float | None,
-        thrust: npt.NDArray[np.float64] | float | None,
-        engine_efficiency: npt.NDArray[np.float64] | float | None,
-        fuel_flow: npt.NDArray[np.float64] | float | None,
+        true_airspeed: npt.NDArray[np.floating],
+        air_temperature: npt.NDArray[np.floating],
+        aircraft_mass: npt.NDArray[np.floating] | float | None,
+        thrust: npt.NDArray[np.floating] | float | None,
+        engine_efficiency: npt.NDArray[np.floating] | float | None,
+        fuel_flow: npt.NDArray[np.floating] | float | None,
         q_fuel: float,
         n_iter: int,
         amass_oew: float,
@@ -192,21 +192,21 @@ class AircraftPerformance(Model):
         ----------
         aircraft_type: str
             Aircraft type designator used to query the underlying model database.
-        altitude_ft: npt.NDArray[np.float64]
+        altitude_ft: npt.NDArray[np.floating]
             Altitude at each waypoint, [:math:`ft`]
         time: npt.NDArray[np.datetime64]
             Waypoint time in ``np.datetime64`` format.
-        true_airspeed: npt.NDArray[np.float64]
+        true_airspeed: npt.NDArray[np.floating]
             True airspeed for each waypoint, [:math:`m s^{-1}`]
-        air_temperature : npt.NDArray[np.float64]
+        air_temperature : npt.NDArray[np.floating]
             Ambient temperature for each waypoint, [:math:`K`]
-        aircraft_mass : npt.NDArray[np.float64] | float | None
+        aircraft_mass : npt.NDArray[np.floating] | float | None
             Override the aircraft_mass at each waypoint, [:math:`kg`].
-        thrust : npt.NDArray[np.float64] | float | None
+        thrust : npt.NDArray[np.floating] | float | None
             Override the thrust setting at each waypoint, [:math: `N`].
-        engine_efficiency : npt.NDArray[np.float64] | float | None
+        engine_efficiency : npt.NDArray[np.floating] | float | None
             Override the engine efficiency at each waypoint.
-        fuel_flow : npt.NDArray[np.float64] | float | None
+        fuel_flow : npt.NDArray[np.floating] | float | None
             Override the fuel flow at each waypoint, [:math:`kg s^{-1}`].
         q_fuel : float
             Lower calorific value (LCV) of fuel, [:math:`J \ kg_{fuel}^{-1}`].
@@ -280,14 +280,14 @@ class AircraftPerformance(Model):
         self,
         *,
         aircraft_type: str,
-        altitude_ft: npt.NDArray[np.float64],
+        altitude_ft: npt.NDArray[np.floating],
         time: npt.NDArray[np.datetime64],
-        true_airspeed: npt.NDArray[np.float64],
-        air_temperature: npt.NDArray[np.float64],
-        aircraft_mass: npt.NDArray[np.float64] | float,
-        thrust: npt.NDArray[np.float64] | float | None,
-        engine_efficiency: npt.NDArray[np.float64] | float | None,
-        fuel_flow: npt.NDArray[np.float64] | float | None,
+        true_airspeed: npt.NDArray[np.floating],
+        air_temperature: npt.NDArray[np.floating],
+        aircraft_mass: npt.NDArray[np.floating] | float,
+        thrust: npt.NDArray[np.floating] | float | None,
+        engine_efficiency: npt.NDArray[np.floating] | float | None,
+        fuel_flow: npt.NDArray[np.floating] | float | None,
         q_fuel: float,
         **kwargs: Any,
     ) -> AircraftPerformanceData:
@@ -332,13 +332,13 @@ class AircraftPerformance(Model):
         self,
         *,
         aircraft_type: str,
-        altitude_ft: npt.NDArray[np.float64],
+        altitude_ft: npt.NDArray[np.floating],
         time: npt.NDArray[np.datetime64],
-        true_airspeed: npt.NDArray[np.float64],
-        air_temperature: npt.NDArray[np.float64],
-        thrust: npt.NDArray[np.float64] | float | None,
-        engine_efficiency: npt.NDArray[np.float64] | float | None,
-        fuel_flow: npt.NDArray[np.float64] | float | None,
+        true_airspeed: npt.NDArray[np.floating],
+        air_temperature: npt.NDArray[np.floating],
+        thrust: npt.NDArray[np.floating] | float | None,
+        engine_efficiency: npt.NDArray[np.floating] | float | None,
+        fuel_flow: npt.NDArray[np.floating] | float | None,
         q_fuel: float,
         n_iter: int,
         amass_oew: float,
@@ -351,7 +351,7 @@ class AircraftPerformance(Model):
         # Variable aircraft_mass will change dynamically after each iteration
         # Set the initial aircraft mass depending on a possible load factor
 
-        aircraft_mass: npt.NDArray[np.float64] | float
+        aircraft_mass: npt.NDArray[np.floating] | float
         if takeoff_mass is not None:
             aircraft_mass = takeoff_mass
         else:
@@ -411,14 +411,14 @@ class AircraftPerformance(Model):
         self,
         *,
         aircraft_type: str,
-        altitude_ft: npt.NDArray[np.float64],
-        air_temperature: npt.NDArray[np.float64],
+        altitude_ft: npt.NDArray[np.floating],
+        air_temperature: npt.NDArray[np.floating],
         time: npt.NDArray[np.datetime64] | None,
-        true_airspeed: npt.NDArray[np.float64] | float | None,
-        aircraft_mass: npt.NDArray[np.float64] | float,
-        engine_efficiency: npt.NDArray[np.float64] | float | None,
-        fuel_flow: npt.NDArray[np.float64] | float | None,
-        thrust: npt.NDArray[np.float64] | float | None,
+        true_airspeed: npt.NDArray[np.floating] | float | None,
+        aircraft_mass: npt.NDArray[np.floating] | float,
+        engine_efficiency: npt.NDArray[np.floating] | float | None,
+        fuel_flow: npt.NDArray[np.floating] | float | None,
+        thrust: npt.NDArray[np.floating] | float | None,
         q_fuel: float,
         **kwargs: Any,
     ) -> AircraftPerformanceData:
@@ -441,24 +441,24 @@ class AircraftPerformance(Model):
         ----------
         aircraft_type : str
             Used to query the underlying model database for aircraft engine parameters.
-        altitude_ft : npt.NDArray[np.float64]
+        altitude_ft : npt.NDArray[np.floating]
             Altitude at each waypoint, [:math:`ft`]
-        air_temperature : npt.NDArray[np.float64]
+        air_temperature : npt.NDArray[np.floating]
             Ambient temperature for each waypoint, [:math:`K`]
         time: npt.NDArray[np.datetime64] | None
             Waypoint time in ``np.datetime64`` format. If None, only drag force
             will is used in thrust calculations (ie, no vertical change and constant
             horizontal change). In addition, aircraft is assumed to be in cruise.
-        true_airspeed : npt.NDArray[np.float64] | float | None
+        true_airspeed : npt.NDArray[np.floating] | float | None
             True airspeed for each waypoint, [:math:`m s^{-1}`].
             If None, a nominal value is used.
-        aircraft_mass : npt.NDArray[np.float64] | float
+        aircraft_mass : npt.NDArray[np.floating] | float
             Aircraft mass for each waypoint, [:math:`kg`].
-        engine_efficiency : npt.NDArray[np.float64] | float | None
+        engine_efficiency : npt.NDArray[np.floating] | float | None
             Override the engine efficiency at each waypoint.
-        fuel_flow : npt.NDArray[np.float64] | float | None
+        fuel_flow : npt.NDArray[np.floating] | float | None
             Override the fuel flow at each waypoint, [:math:`kg s^{-1}`].
-        thrust : npt.NDArray[np.float64] | float | None
+        thrust : npt.NDArray[np.floating] | float | None
             Override the thrust setting at each waypoint, [:math: `N`].
         q_fuel : float
             Lower calorific value (LCV) of fuel, [:math:`J \ kg_{fuel}^{-1}`].
@@ -471,12 +471,12 @@ class AircraftPerformance(Model):
             Derived performance metrics at each waypoint.
         """
 
-    def ensure_true_airspeed_on_source(self) -> npt.NDArray[np.float64]:
+    def ensure_true_airspeed_on_source(self) -> npt.NDArray[np.floating]:
         """Add ``true_airspeed`` field to :attr:`source` data if not already present.
 
         Returns
         -------
-        npt.NDArray[np.float64]
+        npt.NDArray[np.floating]
             True airspeed, [:math:`m s^{-1}`]. If ``true_airspeed`` is already present
             on :attr:`source`, this is returned directly. Otherwise, it is calculated
             using :meth:`Flight.segment_true_airspeed`.
@@ -529,30 +529,30 @@ class AircraftPerformanceData:
 
     Parameters
     ----------
-    fuel_flow : npt.NDArray[np.float64]
+    fuel_flow : npt.NDArray[np.floating]
         Fuel mass flow rate for each waypoint, [:math:`kg s^{-1}`]
-    aircraft_mass : npt.NDArray[np.float64]
+    aircraft_mass : npt.NDArray[np.floating]
         Aircraft mass for each waypoint, [:math:`kg`]
-    true_airspeed : npt.NDArray[np.float64]
+    true_airspeed : npt.NDArray[np.floating]
         True airspeed at each waypoint, [:math: `m s^{-1}`]
-    fuel_burn: npt.NDArray[np.float64]
+    fuel_burn: npt.NDArray[np.floating]
         Fuel consumption for each waypoint, [:math:`kg`]. Set to an array of
         all nan values if it cannot be computed (ie, working with gridpoints).
-    thrust: npt.NDArray[np.float64]
+    thrust: npt.NDArray[np.floating]
         Thrust force, [:math:`N`]
-    engine_efficiency: npt.NDArray[np.float64]
+    engine_efficiency: npt.NDArray[np.floating]
         Overall propulsion efficiency for each waypoint
-    rocd : npt.NDArray[np.float64]
+    rocd : npt.NDArray[np.floating]
         Rate of climb and descent, [:math:`ft min^{-1}`]
     """
 
-    fuel_flow: npt.NDArray[np.float64]
-    aircraft_mass: npt.NDArray[np.float64]
-    true_airspeed: npt.NDArray[np.float64]
-    fuel_burn: npt.NDArray[np.float64]
-    thrust: npt.NDArray[np.float64]
-    engine_efficiency: npt.NDArray[np.float64]
-    rocd: npt.NDArray[np.float64]
+    fuel_flow: npt.NDArray[np.floating]
+    aircraft_mass: npt.NDArray[np.floating]
+    true_airspeed: npt.NDArray[np.floating]
+    fuel_burn: npt.NDArray[np.floating]
+    thrust: npt.NDArray[np.floating]
+    engine_efficiency: npt.NDArray[np.floating]
+    rocd: npt.NDArray[np.floating]
 
 
 # --------------------------------

{pycontrails-0.54.3 → pycontrails-0.54.5}/pycontrails/core/cache.py

@@ -43,7 +43,7 @@ def _get_user_cache_dir() -> str:
 class CacheStore(ABC):
     """Abstract cache storage class for storing staged and intermediate data."""
 
-    __slots__ = ("cache_dir", "allow_clear")
+    __slots__ = ("allow_clear", "cache_dir")
     cache_dir: str
     allow_clear: bool
 
@@ -426,15 +426,15 @@ class GCPCacheStore(CacheStore):
     """
 
     __slots__ = (
-        "project",
+        "_bucket",
+        "_client",
+        "_disk_cache",
         "bucket",
+        "chunk_size",
+        "project",
         "read_only",
-        "timeout",
         "show_progress",
-        "chunk_size",
-        "_disk_cache",
-        "_client",
-        "_bucket",
+        "timeout",
     )
     project: str | None
     bucket: str

{pycontrails-0.54.3 → pycontrails-0.54.5}/pycontrails/core/fleet.py

@@ -32,7 +32,7 @@ class Fleet(Flight):
     Flight waypoints are merged into a single :class:`Flight`-like object.
     """
 
-    __slots__ = ("fl_attrs", "final_waypoints")
+    __slots__ = ("final_waypoints", "fl_attrs")
 
     def __init__(
         self,
@@ -132,19 +132,20 @@ class Fleet(Flight):
         return final_waypoints, fl_attrs
 
     @override
-    def copy(self, **kwargs: Any) -> Fleet:
-        kwargs.setdefault("fuel", self.fuel)
+    def copy(self, **kwargs: Any) -> Self:
         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) -> Fleet:
-        kwargs.setdefault("fuel", self.fuel)
-
+    def filter(self, mask: npt.NDArray[np.bool_], copy: bool = True, **kwargs: Any) -> Self:
         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
@@ -162,7 +163,6 @@ class Fleet(Flight):
         cls,
         seq: Iterable[Flight],
         broadcast_numeric: bool = True,
-        copy: bool = True,
         attrs: dict[str, Any] | None = None,
     ) -> Self:
         """Instantiate a :class:`Fleet` instance from an iterable of :class:`Flight`.
@@ -177,8 +177,6 @@ class Fleet(Flight):
             An iterable of :class:`Flight` instances.
         broadcast_numeric : bool, optional
             If True, broadcast numeric attributes to data variables.
-        copy : bool, optional
-            If True, make copy of each flight instance in ``seq``.
         attrs : dict[str, Any] | None, optional
             Global attribute to attach to instance.
 
@@ -190,15 +188,16 @@ class Fleet(Flight):
             in ``seq``.
         """
 
-        def _maybe_copy(fl: Flight) -> Flight:
-            return fl.copy() if copy else fl
+        # Create a shallow copy because we add additional keys in _validate_fl
+        def _shallow_copy(fl: Flight) -> Flight:
+            return Flight._from_fastpath(fl.data, fl.attrs, fuel=fl.fuel)
 
         def _maybe_warn(fl: Flight) -> Flight:
             if not fl:
                 warnings.warn("Empty flight found in sequence. It will be filtered out.")
             return fl
 
-        seq = tuple(_maybe_copy(fl) for fl in seq if _maybe_warn(fl))
+        seq = tuple(_shallow_copy(fl) for fl in seq if _maybe_warn(fl))
 
         if not seq:
             msg = "Cannot create Fleet from empty sequence."
@@ -220,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:
@@ -249,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()
@@ -265,12 +283,12 @@ class Fleet(Flight):
 
     def segment_true_airspeed(
         self,
-        u_wind: npt.NDArray[np.float64] | float = 0.0,
-        v_wind: npt.NDArray[np.float64] | float = 0.0,
+        u_wind: npt.NDArray[np.floating] | float = 0.0,
+        v_wind: npt.NDArray[np.floating] | float = 0.0,
         smooth: bool = True,
         window_length: int = 7,
         polyorder: int = 1,
-    ) -> npt.NDArray[np.float64]:
+    ) -> npt.NDArray[np.floating]:
         """Calculate the true airspeed [:math:`m / s`] from the ground speed and horizontal winds.
 
         Because Flight.segment_true_airspeed uses a smoothing pattern, waypoints in :attr:`data`
@@ -302,7 +320,7 @@ class Fleet(Flight):
             self[key] = v_wind
 
         # Calculate TAS on each flight individually
-        def calc_tas(fl: Flight) -> npt.NDArray[np.float64]:
+        def calc_tas(fl: Flight) -> npt.NDArray[np.floating]:
             u = fl.get("__u_wind", u_wind)
             v = fl.get("__v_wind", v_wind)
 
@@ -325,19 +343,27 @@ class Fleet(Flight):
         return np.concatenate(tas)
 
     @override
-    def segment_groundspeed(self, *args: Any, **kwargs: Any) -> npt.NDArray[np.float64]:
+    def segment_groundspeed(self, *args: Any, **kwargs: Any) -> npt.NDArray[np.floating]:
         fls = self.to_flight_list(copy=False)
         gs = [fl.segment_groundspeed(*args, **kwargs) for fl in fls]
         return np.concatenate(gs)
 
     @override
-    def resample_and_fill(self, *args: Any, **kwargs: Any) -> Fleet:
+    def resample_and_fill(self, *args: Any, **kwargs: Any) -> Self:
         flights = self.to_flight_list(copy=False)
+
+        # We need to ensure that each flight has an flight_id attrs field
+        # When we call fl.resample_and_fill, any flight_id data field
+        # will be lost, so the call to Fleet.from_seq will fail.
+        for fl in flights:
+            if "flight_id" not in fl.attrs:
+                fl.attrs["flight_id"] = _extract_flight_id(fl)
+
         flights = [fl.resample_and_fill(*args, **kwargs) for fl in flights]
-        return type(self).from_seq(flights, copy=False, broadcast_numeric=False, attrs=self.attrs)
+        return type(self).from_seq(flights, broadcast_numeric=False, attrs=self.attrs)
 
     @override
-    def segment_length(self) -> npt.NDArray[np.float64]:
+    def segment_length(self) -> npt.NDArray[np.floating]:
         return np.where(self.final_waypoints, np.nan, super().segment_length())
 
     @property
@@ -346,11 +372,11 @@ class Fleet(Flight):
         return np.nanmax(self.segment_length()).item()
 
     @override
-    def segment_azimuth(self) -> npt.NDArray[np.float64]:
+    def segment_azimuth(self) -> npt.NDArray[np.floating]:
         return np.where(self.final_waypoints, np.nan, super().segment_azimuth())
 
     @override
-    def segment_angle(self) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]]:
+    def segment_angle(self) -> tuple[npt.NDArray[np.floating], npt.NDArray[np.floating]]:
         sin_a, cos_a = super().segment_angle()
         sin_a[self.final_waypoints] = np.nan
         cos_a[self.final_waypoints] = np.nan
@@ -368,8 +394,7 @@ class Fleet(Flight):
         force_filter: bool = False,
         drop: bool = True,
         keep_original_index: bool = False,
-        climb_descend_at_end: bool = False,
-    ) -> Flight:
+    ) -> NoReturn:
         msg = "Only implemented for Flight instances"
         raise NotImplementedError(msg)