pycontrails 0.54.7__cp310-cp310-macosx_11_0_arm64.whl → 0.54.9__cp310-cp310-macosx_11_0_arm64.whl

pycontrails/_version.py

@@ -1,8 +1,13 @@
-# file generated by setuptools_scm
+# file generated by setuptools-scm
 # don't change, don't track in version control
+
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+
 TYPE_CHECKING = False
 if TYPE_CHECKING:
-    from typing import Tuple, Union
+    from typing import Tuple
+    from typing import Union
+
     VERSION_TUPLE = Tuple[Union[int, str], ...]
 else:
     VERSION_TUPLE = object
@@ -12,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.54.7'
-__version_tuple__ = version_tuple = (0, 54, 7)
+__version__ = version = '0.54.9'
+__version_tuple__ = version_tuple = (0, 54, 9)

pycontrails/core/aircraft_performance.py

@@ -4,15 +4,9 @@ from __future__ import annotations
 
 import abc
 import dataclasses
-import sys
 import warnings
 from typing import Any, Generic, NoReturn, overload
 
-if sys.version_info >= (3, 12):
-    from typing import override
-else:
-    from typing_extensions import override
-
 import numpy as np
 import numpy.typing as npt
 
@@ -20,6 +14,7 @@ from pycontrails.core import flight, fuel
 from pycontrails.core.fleet import Fleet
 from pycontrails.core.flight import Flight
 from pycontrails.core.met import MetDataset
+from pycontrails.core.met_var import AirTemperature, EastwardWind, MetVariable, NorthwardWind
 from pycontrails.core.models import Model, ModelParams, interpolate_met
 from pycontrails.core.vector import GeoVectorDataset
 from pycontrails.physics import jet
@@ -97,6 +92,9 @@ class AircraftPerformance(Model):
     """
 
     source: Flight
+    met_variables: tuple[MetVariable, ...] = ()
+    optional_met_variables: tuple[MetVariable, ...] = (AirTemperature, EastwardWind, NorthwardWind)
+    default_params = AircraftPerformanceParams
 
     @overload
     def eval(self, source: Fleet, **params: Any) -> Fleet: ...
@@ -129,7 +127,8 @@ class AircraftPerformance(Model):
         self.set_source_met()
         self._cleanup_indices()
 
-        # Calculate true airspeed if not included on source
+        # Calculate temperature and true airspeed if not included on source
+        self.ensure_air_temperature_on_source()
         self.ensure_true_airspeed_on_source()
 
         if isinstance(self.source, Fleet):
@@ -162,23 +161,6 @@ class AircraftPerformance(Model):
         - ``total_fuel_burn``: total fuel burn, [:math:`kg`]
         """
 
-    @override
-    def set_source_met(self, *args: Any, **kwargs: Any) -> None:
-        fill_with_isa = self.params["fill_low_altitude_with_isa_temperature"]
-        if fill_with_isa and (self.met is None or "air_temperature" not in self.met):
-            if "air_temperature" in self.source:
-                _fill_low_altitude_with_isa_temperature(self.source, 0.0)
-            else:
-                self.source["air_temperature"] = self.source.T_isa()
-            fill_with_isa = False  # we've just filled it
-
-        super().set_source_met(*args, **kwargs)
-        if not fill_with_isa:
-            return
-
-        met_level_0 = self.met.data["level"][-1].item()  # type: ignore[union-attr]
-        _fill_low_altitude_with_isa_temperature(self.source, met_level_0)
-
     def simulate_fuel_and_performance(
         self,
         *,
@@ -491,25 +473,57 @@ class AircraftPerformance(Model):
             Derived performance metrics at each waypoint.
         """
 
-    def ensure_true_airspeed_on_source(self) -> npt.NDArray[np.floating]:
+    def ensure_air_temperature_on_source(self) -> None:
+        """Add ``air_temperature`` field to :attr:`source` data if not already present.
+
+        This function operates in-place. If ``air_temperature`` is not already present
+        on :attr:`source`, it is calculated by interpolation from met data.
+        """
+        fill_with_isa = self.params["fill_low_altitude_with_isa_temperature"]
+
+        if "air_temperature" in self.source:
+            if not fill_with_isa:
+                return
+            _fill_low_altitude_with_isa_temperature(self.source, 0.0)
+            return
+
+        temp_available = self.met is not None and "air_temperature" in self.met
+
+        if not temp_available:
+            if fill_with_isa:
+                self.source["air_temperature"] = self.source.T_isa()
+                return
+            msg = (
+                "Cannot compute air temperature without providing met data that includes an "
+                "'air_temperature' variable. Either include met data with 'air_temperature' "
+                "in the model constructor, define 'air_temperature' data on the flight, or set "
+                "'fill_low_altitude_with_isa_temperature' to True."
+            )
+            raise ValueError(msg)
+
+        interpolate_met(self.met, self.source, "air_temperature", **self.interp_kwargs)
+
+        if not fill_with_isa:
+            return
+
+        met_level_0 = self.met.data["level"][-1].item()  # type: ignore[union-attr]
+        _fill_low_altitude_with_isa_temperature(self.source, met_level_0)
+
+    def ensure_true_airspeed_on_source(self) -> None:
         """Add ``true_airspeed`` field to :attr:`source` data if not already present.
 
-        Returns
-        -------
-        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`.
+        This function operates in-place. If ``true_airspeed`` is not already present
+        on :attr:`source`, it is calculated using :meth:`Flight.segment_true_airspeed`.
         """
         tas = self.source.get("true_airspeed")
         fill_with_groundspeed = self.params["fill_low_altitude_with_zero_wind"]
 
         if tas is not None:
             if not fill_with_groundspeed:
-                return tas
+                return
             cond = np.isnan(tas)
             tas[cond] = self.source.segment_groundspeed()[cond]
-            return tas
+            return
 
         # Use current cocip convention: eastward_wind on met, u_wind on source
         wind_available = ("u_wind" in self.source and "v_wind" in self.source) or (
@@ -520,7 +534,7 @@ class AircraftPerformance(Model):
             if fill_with_groundspeed:
                 tas = self.source.segment_groundspeed()
                 self.source["true_airspeed"] = tas
-                return tas
+                return
             msg = (
                 "Cannot compute 'true_airspeed' without 'eastward_wind' and 'northward_wind' "
                 "met data. Either include met data in the model constructor, define "
@@ -545,7 +559,6 @@ class AircraftPerformance(Model):
 
         out = self.source.segment_true_airspeed(u, v)
         self.source["true_airspeed"] = out
-        return out
 
 
 @dataclasses.dataclass

pycontrails/core/cache.py

@@ -266,6 +266,8 @@ class DiskCacheStore(CacheStore):
         >>> # put a file directly
         >>> disk_cache.put("README.md", "test/file.md")
         'test/file.md'
+
+        >>> disk_cache.clear()  # cleanup
         """
 
         if not pathlib.Path(data_path).is_file():
@@ -312,6 +314,8 @@ class DiskCacheStore(CacheStore):
         >>> # returns a path
         >>> disk_cache.get("test/file.md")
         'cache/test/file.md'
+
+        >>> disk_cache.clear()  # cleanup
         """
         return self.path(cache_path)
 

pycontrails/core/flightplan.py

@@ -38,10 +38,13 @@ def to_atc_plan(plan: dict[str, Any]) -> str:
     if "second_alt_icao" in plan:
         ret += f" {plan['second_alt_icao']}"
     ret += "\n"
-    ret += f"-{plan['other_info']})\n"
+    ret += f"-{plan['other_info']}"
     if "supplementary_info" in plan:
+        ret += "\n-"
         ret += " ".join([f"{i[0]}/{i[1]}" for i in plan["supplementary_info"].items()])
 
+    ret += ")"
+
     if ret[-1] == "\n":
         ret = ret[:-1]
 
@@ -194,7 +197,12 @@ def parse_atc_plan(atc_plan: str) -> dict[str, str]:
 
     # Other info
     if len(basic) > 8:
-        flightplan["other_info"] = basic[8]
+        info = basic[8]
+        idx = info.find("DOF")
+        if idx != -1:
+            flightplan["departure_date"] = info[idx + 4 : idx + 10]
+
+        flightplan["other_info"] = info.strip()
 
     # Supl. Info
     if len(basic) > 9:

pycontrails/core/met.py

@@ -2643,19 +2643,24 @@ def downselect(data: XArrayType, bbox: tuple[float, ...]) -> XArrayType:
             "or length 6 [west, south, min-level, east, north, max-level]"
         )
 
+    if west <= east:
+        # Return a view of the data
+        # If data is lazy, this will not load the data
+        return data.sel(
+            longitude=slice(west, east),
+            latitude=slice(south, north),
+            level=slice(level_min, level_max),
+        )
+
+    # In this case, the bbox spans the antimeridian
+    # If data is lazy, this will load the data (data.where is not lazy AFAIK)
     cond = (
         (data["latitude"] >= south)
         & (data["latitude"] <= north)
         & (data["level"] >= level_min)
         & (data["level"] <= level_max)
+        & ((data["longitude"] >= west) | (data["longitude"] <= east))
     )
-
-    # wrapping longitude
-    if west <= east:
-        cond = cond & (data["longitude"] >= west) & (data["longitude"] <= east)
-    else:
-        cond = cond & ((data["longitude"] >= west) | (data["longitude"] <= east))
-
     return data.where(cond, drop=True)
 
 

pycontrails/core/models.py

@@ -706,17 +706,20 @@ class Model(ABC):
     # https://github.com/python/cpython/blob/618b7a8260bb40290d6551f24885931077309590/Lib/collections/__init__.py#L231
     __marker = object()
 
-    def get_source_param(self, key: str, default: Any = __marker, *, set_attr: bool = True) -> Any:
-        """Get source data with default set by parameter key.
+    def get_data_param(
+        self, other: SourceType, key: str, default: Any = __marker, *, set_attr: bool = True
+    ) -> Any:
+        """Get data from other source-compatible object with default set by model parameter key.
 
         Retrieves data with the following hierarchy:
 
-        1. :attr:`source.data[key]`. Returns ``np.ndarray | xr.DataArray``.
-        2. :attr:`source.attrs[key]`
+        1. :attr:`other.data[key]`. Returns ``np.ndarray | xr.DataArray``.
+        2. :attr:`other.attrs[key]`
         3. :attr:`params[key]`
         4. ``default``
 
-        In case 3., the value of :attr:`params[key]` is attached to :attr:`source.attrs[key]`.
+        In case 3., the value of :attr:`params[key]` is attached to :attr:`other.attrs[key]`
+        unless ``set_attr`` is set to False.
 
         Parameters
         ----------
@@ -731,31 +734,33 @@ class Model(ABC):
         Returns
         -------
         Any
-            Value(s) found for key in source data, source attrs, or model params
+            Value(s) found for key in ``other`` data, ``other`` attrs, or model params
 
         Raises
         ------
         KeyError
             Raises KeyError if key is not found in any location and ``default`` is not provided.
 
+
         See Also
         --------
+        - get_source_param
         - GeoVectorDataset.get_data_or_attr
         """
         marker = self.__marker
 
-        out = self.source.data.get(key, marker)
+        out = other.data.get(key, marker)
         if out is not marker:
             return out
 
-        out = self.source.attrs.get(key, marker)
+        out = other.attrs.get(key, marker)
         if out is not marker:
             return out
 
         out = self.params.get(key, marker)
         if out is not marker:
             if set_attr:
-                self.source.attrs[key] = out
+                other.attrs[key] = out
 
             return out
 
@@ -765,6 +770,46 @@ class Model(ABC):
         msg = f"Key '{key}' not found in source data, attrs, or model params"
         raise KeyError(msg)
 
+    def get_source_param(self, key: str, default: Any = __marker, *, set_attr: bool = True) -> Any:
+        """Get source data with default set by parameter key.
+
+        Retrieves data with the following hierarchy:
+
+        1. :attr:`source.data[key]`. Returns ``np.ndarray | xr.DataArray``.
+        2. :attr:`source.attrs[key]`
+        3. :attr:`params[key]`
+        4. ``default``
+
+        In case 3., the value of :attr:`params[key]` is attached to :attr:`source.attrs[key]`
+        unless ``set_attr`` is set to False.
+
+        Parameters
+        ----------
+        key : str
+            Key to retrieve
+        default : Any, optional
+            Default value if key is not found.
+        set_attr : bool, optional
+            If True (default), set :attr:`source.attrs[key]` to :attr:`params[key]` if found.
+            This allows for better post model evaluation tracking.
+
+        Returns
+        -------
+        Any
+            Value(s) found for key in source data, source attrs, or model params
+
+        Raises
+        ------
+        KeyError
+            Raises KeyError if key is not found in any location and ``default`` is not provided.
+
+        See Also
+        --------
+        - get_data_param
+        - GeoVectorDataset.get_data_or_attr
+        """
+        return self.get_data_param(self.source, key, default, set_attr=set_attr)
+
     def _cleanup_indices(self) -> None:
         """Cleanup indices artifacts if ``params["interpolation_use_indices"]`` is True."""
         if self.params["interpolation_use_indices"] and isinstance(self.source, GeoVectorDataset):

pycontrails/core/vector.py

@@ -1067,9 +1067,17 @@ class VectorDataset:
         if out is not marker:
             return out
 
-        out = self.data.get(key, marker)
-        if out is not marker:
-            vals = np.unique(out)
+        arr: np.ndarray = self.data.get(key, marker)  # type: ignore[arg-type]
+        if arr is not marker:
+            try:
+                vals = np.unique(arr)
+            except TypeError:
+                # A TypeError can occur if the arr has object dtype and contains None
+                # Handle this case by returning None
+                if arr.dtype == object and np.all(arr == None):  # noqa: E711
+                    return None
+                raise
+
             if len(vals) == 1:
                 return vals[0]
 

pycontrails/datalib/goes.py

@@ -16,6 +16,7 @@ from __future__ import annotations
 
 import datetime
 import enum
+import os
 import tempfile
 from collections.abc import Iterable
 
@@ -566,9 +567,12 @@ class GOES:
 
 def _load_via_tempfile(data: bytes) -> xr.Dataset:
     """Load xarray dataset via temporary file."""
-    with tempfile.NamedTemporaryFile(buffering=0) as tmp:
+    with tempfile.NamedTemporaryFile(delete=False) as tmp:
         tmp.write(data)
+    try:
         return xr.load_dataset(tmp.name)
+    finally:
+        os.remove(tmp.name)
 
 
 def _concat_c02(ds1: XArrayType, ds2: XArrayType) -> XArrayType:
@@ -660,6 +664,10 @@ def to_true_color(da: xr.DataArray, gamma: float = 2.2) -> npt.NDArray[np.float3
     ----------
     - `Unidata's true color recipe <https://unidata.github.io/python-gallery/examples/mapping_GOES16_TrueColor.html>`_
     """
+    if not np.all(np.isin([1, 2, 3], da["band_id"])):
+        msg = "DataArray must contain bands 1, 2, and 3 for true color"
+        raise ValueError(msg)
+
     red = da.sel(band_id=2).values
     green = da.sel(band_id=3).values
     blue = da.sel(band_id=1).values
@@ -716,6 +724,9 @@ def to_ash(da: xr.DataArray, convention: str = "SEVIRI") -> npt.NDArray[np.float
     array([0.0127004 , 0.22793579, 0.3930847 ], dtype=float32)
     """
     if convention == "standard":
+        if not np.all(np.isin([11, 13, 14, 15], da["band_id"])):
+            msg = "DataArray must contain bands 11, 13, 14, and 15 for standard ash"
+            raise ValueError(msg)
         c11 = da.sel(band_id=11).values  # 8.44
         c13 = da.sel(band_id=13).values  # 10.33
         c14 = da.sel(band_id=14).values  # 11.19
@@ -725,7 +736,10 @@ def to_ash(da: xr.DataArray, convention: str = "SEVIRI") -> npt.NDArray[np.float
         green = c14 - c11
         blue = c13
 
-    elif convention in ["SEVIRI", "MIT"]:  # retain MIT for backwards compatibility
+    elif convention in ("SEVIRI", "MIT"):  # retain MIT for backwards compatibility
+        if not np.all(np.isin([11, 14, 15], da["band_id"])):
+            msg = "DataArray must contain bands 11, 14, and 15 for SEVIRI ash"
+            raise ValueError(msg)
         c11 = da.sel(band_id=11).values  # 8.44
         c14 = da.sel(band_id=14).values  # 11.19
         c15 = da.sel(band_id=15).values  # 12.27
@@ -770,3 +784,133 @@ def _clip_and_scale(
         Clipped and scaled array.
     """
     return (arr.clip(low, high) - low) / (high - low)
+
+
+def parallax_correct(
+    longitude: npt.NDArray[np.floating],
+    latitude: npt.NDArray[np.floating],
+    altitude: npt.NDArray[np.floating],
+    goes_da: xr.DataArray,
+) -> tuple[npt.NDArray[np.floating], npt.NDArray[np.floating]]:
+    r"""Apply parallax correction to WGS84 geodetic coordinates based on satellite perspective.
+
+    This function considers the ray from the satellite to the points of interest and finds
+    the intersection of this ray with the WGS84 ellipsoid. The intersection point is then
+    returned as the corrected longitude and latitude coordinates.
+
+    ::
+
+       @ satellite
+        \
+         \
+          \
+           \
+            \
+             * aircraft
+              \
+               \
+                x parallax corrected aircraft
+        -------------------------  surface
+
+    If the point of interest is not visible from the satellite (ie, on the opposite side of the
+    earth), the function returns nan for the corrected coordinates.
+
+    This function requires the :mod:`pyproj` package to be installed.
+
+    Parameters
+    ----------
+    longitude : npt.NDArray[np.floating]
+        A 1D array of longitudes in degrees.
+    latitude : npt.NDArray[np.floating]
+        A 1D array of latitudes in degrees.
+    altitude : npt.NDArray[np.floating]
+        A 1D array of altitudes in meters.
+    goes_da : xr.DataArray
+        DataArray containing the GOES projection information. Only the ``goes_imager_projection``
+        field of the :attr:`xr.DataArray.attrs` is used.
+
+    Returns
+    -------
+    tuple[npt.NDArray[np.floating], npt.NDArray[np.floating]]
+        A tuple containing the corrected longitude and latitude coordinates.
+
+    """
+    goes_imager_projection = goes_da.attrs["goes_imager_projection"]
+    sat_lon = goes_imager_projection["longitude_of_projection_origin"]
+    sat_lat = goes_imager_projection["latitude_of_projection_origin"]
+    sat_alt = goes_imager_projection["perspective_point_height"]
+
+    try:
+        import pyproj
+    except ModuleNotFoundError as exc:
+        dependencies.raise_module_not_found_error(
+            name="parallax_correct function",
+            package_name="pyproj",
+            module_not_found_error=exc,
+            pycontrails_optional_package="pyproj",
+        )
+
+    # Convert from WGS84 to ECEF coordinates
+    ecef_crs = pyproj.CRS("EPSG:4978")
+    transformer = pyproj.Transformer.from_crs("WGS84", ecef_crs, always_xy=True)
+
+    p0 = np.array(transformer.transform([sat_lon], [sat_lat], [sat_alt]))
+    p1 = np.array(transformer.transform(longitude, latitude, altitude))
+
+    # Major and minor axes of the ellipsoid
+    a = ecef_crs.ellipsoid.semi_major_metre  # type: ignore[union-attr]
+    b = ecef_crs.ellipsoid.semi_minor_metre  # type: ignore[union-attr]
+    intersection = _intersection_with_ellipsoid(p0, p1, a, b)
+
+    # Convert back to WGS84 coordinates
+    inv_transformer = pyproj.Transformer.from_crs(ecef_crs, "WGS84", always_xy=True)
+    return inv_transformer.transform(*intersection)[:2]  # final coord is (close to) 0
+
+
+def _intersection_with_ellipsoid(
+    p0: npt.NDArray[np.floating],
+    p1: npt.NDArray[np.floating],
+    a: float,
+    b: float,
+) -> npt.NDArray[np.floating]:
+    """Find the intersection of a line with the surface of an ellipsoid."""
+    # Calculate the direction vector
+    px, py, pz = p0
+    v = p1 - p0
+    vx, vy, vz = v
+
+    # The line between p0 and p1 in parametric form is p(t) = p0 + t * v
+    # We need to find t such that p(t) lies on the ellipsoid
+    # x^2 / a^2 + y^2 / a^2 + z^2 / b^2 = 1
+    # (px + t * vx)^2 / a^2 + (py + t * vy)^2 / a^2 + (pz + t * vz)^2 / b^2 = 1
+    # Rearranging gives a quadratic in t
+
+    # Calculate the coefficients of this quadratic equation
+    A = vx**2 / a**2 + vy**2 / a**2 + vz**2 / b**2
+    B = 2 * (px * vx / a**2 + py * vy / a**2 + pz * vz / b**2)
+    C = px**2 / a**2 + py**2 / a**2 + pz**2 / b**2 - 1.0
+
+    # Calculate the discriminant
+    D = B**2 - 4 * A * C
+    sqrtD = np.sqrt(D, where=D >= 0, out=np.full_like(D, np.nan))
+
+    # Calculate the two possible solutions for t
+    t0 = (-B + sqrtD) / (2.0 * A)
+    t1 = (-B - sqrtD) / (2.0 * A)
+
+    # Calculate the intersection points
+    intersection0 = p0 + t0 * v
+    intersection1 = p0 + t1 * v
+
+    # Pick the intersection point that is closer to the aircraft (p1)
+    d0 = np.linalg.norm(intersection0 - p1, axis=0)
+    d1 = np.linalg.norm(intersection1 - p1, axis=0)
+    out = np.where(d0 < d1, intersection0, intersection1)
+
+    # Fill the points in which the aircraft is not visible by the satellite with nan
+    # This occurs when the earth is between the satellite and the aircraft
+    # In other words, we can check for t0 < 1 (or t1 < 1)
+    opposite_side = t0 < 1.0
+    out[:, opposite_side] = np.nan
+
+    return out

pycontrails/datalib/spire/spire.py

@@ -75,7 +75,7 @@ class ValidateTrajectoryHandler:
     <LINK HERE TO HOSTED REFERENCE EXAMPLE(S)>.
     """
 
-    CRUISE_ROCD_THRESHOLD_FPS = 4.2  # 4.2 ft/sec ~= 250 ft/min
+    ROCD_THRESHOLD_FPS = 83.25  # 83.25 ft/sec ~= 5000 ft/min
     CRUISE_LOW_ALTITUDE_THRESHOLD_FT = 15000.0  # lowest expected cruise altitude
     INSTANTANEOUS_HIGH_GROUND_SPEED_THRESHOLD_MPS = 350.0  # 350m/sec ~= 780mph ~= 1260kph
     INSTANTANEOUS_LOW_GROUND_SPEED_THRESHOLD_MPS = 45.0  # 45m/sec ~= 100mph ~= 160kph
@@ -473,12 +473,12 @@ class ValidateTrajectoryHandler:
         Evaluate flight altitude profile.
 
         Failure modes include:
-        RocdError
+        FlightAltitudeProfileError
         1) flight climbs above alt threshold,
             then descends below that threshold one or more times,
             before making final descent to land.
 
-        FlightAltitudeProfileError
+        RocdError
         2) rate of instantaneous (between consecutive waypoint) climb or descent is above threshold,
            while aircraft is above the cruise altitude.
         """
@@ -488,15 +488,13 @@ class ValidateTrajectoryHandler:
 
         violations: list[FlightAltitudeProfileError | ROCDError] = []
 
-        # only evaluate rocd errors when at cruising altitude
-        rocd_above_thres = (self._df["rocd_fps"].abs() >= self.CRUISE_ROCD_THRESHOLD_FPS) & (
-            self._df["altitude_baro"] >= self.CRUISE_LOW_ALTITUDE_THRESHOLD_FT
-        )
+        # evaluate ROCD
+        rocd_above_thres = self._df["rocd_fps"].abs() >= self.ROCD_THRESHOLD_FPS
         if rocd_above_thres.any():
             msg = (
                 "Flight trajectory has rate of climb/descent values "
                 "between consecutive waypoints that exceed threshold "
-                f"of {self.CRUISE_ROCD_THRESHOLD_FPS:.3f}ft/sec. "
+                f"of {self.ROCD_THRESHOLD_FPS:.3f}ft/sec. "
                 f"Max value found: {self._df['rocd_fps'].abs().max():.3f}ft/sec"
             )
             violations.append(ROCDError(msg))

pycontrails/ext/synthetic_flight.py

@@ -207,7 +207,7 @@ class SyntheticFlight:
 
     def _id(self) -> int:
         """Get random flight ID."""
-        return self.rng.integers(100_000, 999_999)
+        return self.rng.integers(100_000, 999_999).item()
 
     def _define_aircraft(self) -> None:
         """Define or update instance variables pertaining to flight aircrafts.