pycontrails 0.41.0__cp39-cp39-macosx_11_0_arm64.whl → 0.42.2__cp39-cp39-macosx_11_0_arm64.whl

pycontrails/core/flightplan.py

@@ -0,0 +1,238 @@
+"""ATC Flight Plan Parser."""
+
+import re
+from typing import Any
+
+
+def to_atc_plan(plan: dict[str, Any]) -> str:
+    """Write dictionary from :func:`parse_atc_plan` as ATC flight plan string.
+
+    Parameters
+    ----------
+    plan: dict[str, Any]
+        Dictionary representation of ATC flight plan returned from :func:`parse_atc_plan`.
+
+    Returns
+    -------
+    str
+        ATC flight plan string conforming to ICAO Doc 4444-ATM/501
+
+    See Also
+    --------
+    :func:`parse_atc_plan`
+    """
+    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'
+    if "destination_icao" in plan and "duration" in plan:
+        ret += f'-{plan["destination_icao"]}{plan["duration"]}'
+    if "alt_icao" in plan:
+        ret += f' {plan["alt_icao"]}'
+    if "second_alt_icao" in plan:
+        ret += f' {plan["second_alt_icao"]}'
+    ret += "\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()])
+
+    if ret[-1] == "\n":
+        ret = ret[:-1]
+
+    return ret
+
+
+def parse_atc_plan(atc_plan: str) -> dict[str, str]:
+    """Parse an ATC flight plan string into a dictionary.
+
+    The route string is not converted to lat/lon in this process.
+
+    Parameters
+    ----------
+    atc_plan : str
+        An ATC flight plan string conforming to ICAO Doc 4444-ATM/501 (Appendix 2)
+
+    Returns
+    -------
+    dict[str, str]
+        A dictionary consisting of parsed components of the ATC flight plan.
+        A full ATC plan will contain the keys:
+
+        - ``callsign``: ICAO flight callsign
+        - ``flight_rules``: Flight rules ("I", "V", "Y", "Z")
+        - ``type_of_flight``: Type of flight ("S", "N", "G", "M", "X")
+        - ``number_aircraft``: The number of aircraft, if more than one
+        - ``type_of_aircraft``: ICAO aircraft type
+        - ``wake_category``: Wake turbulence category
+        - ``equipment``: Radiocommunication, navigation and approach aid equipment and capabilities
+        - ``transponder``: Surveillance equipment and capabilities
+        - ``departure_icao``: ICAO departure airport
+        - ``time``: Estimated off-block (departure) time (UTC)
+        - ``speed_type``: Speed units ("K": km / hr, "N": knots)
+        - ``speed``: Cruise true airspeed in ``speed_type`` units
+        - ``level_type``: Level units ("F", "S", "A", "M")
+        - ``level``: Cruise level
+        - ``route``: Route string
+        - ``destination_icao``: ICAO destination airport
+        - ``duration``: The total estimated elapsed time for the flight plan
+        - ``alt_icao``: ICAO alternate destination airport
+        - ``second_alt_icao``: ICAO second alternate destination airport
+        - ``other_info``: Other information
+        - ``supplementary_info``: Supplementary information
+
+    References
+    ----------
+    - https://applications.icao.int/tools/ATMiKIT/story_content/external_files/story_content/external_files/DOC%204444_PANS%20ATM_en.pdf
+
+    See Also
+    --------
+    :func:`to_atc_plan`
+    """  # noqa: E501
+    atc_plan = atc_plan.replace("\r", "")
+    atc_plan = atc_plan.replace("\n", "")
+    atc_plan = atc_plan.upper()
+    atc_plan = atc_plan.strip()
+
+    if len(atc_plan) == 0:
+        raise ValueError("Empty or invalid flight plan")
+
+    atc_plan = atc_plan.replace("(FPL", "")
+    atc_plan = atc_plan.replace(")", "")
+    atc_plan = atc_plan.replace("--", "-")
+
+    basic = atc_plan.split("-")
+
+    flightplan: dict[str, Any] = {}
+
+    # Callsign
+    if len(basic) > 1:
+        flightplan["callsign"] = basic[1]
+
+    # Flight Rules
+    if len(basic) > 2:
+        flightplan["flight_rules"] = basic[2][0]
+        flightplan["type_of_flight"] = basic[2][1]
+
+    # Aircraft
+    if len(basic) > 3:
+        aircraft = basic[3].split("/")
+        matches = re.match("(\d{1})(\S{3,4})", aircraft[0])
+        if matches:
+            groups = matches.groups()
+        else:
+            groups = ()
+
+        if matches and len(groups) > 2:
+            flightplan["number_aircraft"] = groups[1]
+            flightplan["type_of_aircraft"] = groups[2]
+        else:
+            flightplan["type_of_aircraft"] = aircraft[0]
+
+        if len(aircraft) > 1:
+            flightplan["wake_category"] = aircraft[1]
+
+    # Equipment
+    if len(basic) > 4:
+        equip = basic[4].split("/")
+        flightplan["equipment"] = equip[0]
+        if len(equip) > 1:
+            flightplan["transponder"] = equip[1]
+
+    # Dep. airport info
+    if len(basic) > 5:
+        matches = re.match("(\D*)(\d*)", basic[5])
+        if matches:
+            groups = matches.groups()
+        else:
+            groups = ()
+
+        if len(groups) > 0:
+            flightplan["departure_icao"] = groups[0]
+        if len(groups) > 1:
+            flightplan["time"] = groups[1]
+
+    # Speed and route info
+    if len(basic) > 6:
+        matches = re.match("(\D*)(\d*)(\D*)(\d*)", basic[6])
+        if matches:
+            groups = matches.groups()
+        else:
+            groups = ()
+
+        # match speed and level
+        if len(groups) > 0:
+            flightplan["speed_type"] = groups[0]
+            if len(groups) > 1:
+                flightplan["speed"] = groups[1]
+            if len(groups) > 2:
+                flightplan["level_type"] = groups[2]
+            if len(groups) > 3:
+                flightplan["level"] = groups[3]
+
+            flightplan["route"] = basic[6][len("".join(groups)) :].strip()
+        else:
+            flightplan["route"] = basic[6].strip()
+
+    # Dest. airport info
+    if len(basic) > 7:
+        matches = re.match("(\D{4})(\d{4})", basic[7])
+        if matches:
+            groups = matches.groups()
+        else:
+            groups = ()
+
+        if len(groups) > 0:
+            flightplan["destination_icao"] = groups[0]
+        if len(groups) > 1:
+            flightplan["duration"] = groups[1]
+
+        matches = re.match("(\D{4})(\d{4})(\s{1})(\D{4})", basic[7])
+        if matches:
+            groups = matches.groups()
+        else:
+            groups = ()
+
+        if len(groups) > 3:
+            flightplan["alt_icao"] = groups[3]
+
+        matches = re.match("(\D{4})(\d{4})(\s{1})(\D{4})(\s{1})(\D{4})", basic[7])
+        if matches:
+            groups = matches.groups()
+        else:
+            groups = ()
+
+        if len(groups) > 5:
+            flightplan["second_alt_icao"] = groups[5]
+
+    # Other info
+    if len(basic) > 8:
+        flightplan["other_info"] = basic[8]
+
+    # Supl. Info
+    if len(basic) > 9:
+        sup_match = re.findall("(\D{1}[\/]{1})", basic[9])
+        if len(sup_match) > 0:
+            suplInfo = {}
+            for i in range(len(sup_match) - 1):
+                this_key = sup_match[i]
+                this_idx = basic[9].find(this_key)
+
+                next_key = sup_match[i + 1]
+                next_idx = basic[9].find(next_key)
+
+                val = basic[9][this_idx + 2 : next_idx - 1]
+                suplInfo[this_key[0]] = val
+
+            last_key = sup_match[-1]
+            last_idx = basic[9].find(last_key)
+            suplInfo[last_key[0]] = basic[9][last_idx + 2 :]
+
+            flightplan["supplementary_info"] = suplInfo
+
+    return flightplan

pycontrails/core/interpolation.py

@@ -74,7 +74,7 @@ class PycontrailsRegularGridInterpolator(scipy.interpolate.RegularGridInterpolat
         self.bounds_error = bounds_error
         self.fill_value = fill_value
 
-    def _prepare_xi_simple(self, xi: npt.NDArray[np.float64]) -> npt.NDArray[np.bool_] | None:
+    def _prepare_xi_simple(self, xi: npt.NDArray[np.float64]) -> npt.NDArray[np.bool_]:
         """Run looser version of :meth:`_prepare_xi`.
 
         Parameters
@@ -84,12 +84,9 @@ class PycontrailsRegularGridInterpolator(scipy.interpolate.RegularGridInterpolat
 
         Returns
         -------
-        npt.NDArray[np.bool_] | None
+        npt.NDArray[np.bool_]
             A 1-dimensional Boolean array indicating which points are out of bounds.
-            If ``bounds_error`` is ``True``, this will be ``None``, indicating that
-            no points are out of bounds. (This is the same convention as
-            :meth:`scipy.interpolate.RegularGridInterpolator._prepare_xi`). If
-            every point is in bounds, this is set to ``None``.
+            If ``bounds_error`` is ``True``, this will be all ``False``.
         """
 
         if self.bounds_error:
@@ -99,12 +96,9 @@ class PycontrailsRegularGridInterpolator(scipy.interpolate.RegularGridInterpolat
                 if not (np.all(p >= g0) and np.all(p <= g1)):
                     raise ValueError(f"One of the requested xi is out of bounds in dimension {i}")
 
-            return None
+            return np.zeros(xi.shape[0], dtype=bool)
 
-        out_of_bounds = self._find_out_of_bounds(xi.T)
-        if not np.any(out_of_bounds):
-            return None
-        return out_of_bounds
+        return self._find_out_of_bounds(xi.T)
 
     def __call__(
         self, xi: npt.NDArray[np.float64], method: str | None = None
@@ -137,7 +131,9 @@ class PycontrailsRegularGridInterpolator(scipy.interpolate.RegularGridInterpolat
         return self._set_out_of_bounds(out, out_of_bounds)
 
     def _set_out_of_bounds(
-        self, out: npt.NDArray[np.float_], out_of_bounds: npt.NDArray[np.bool_] | None
+        self,
+        out: npt.NDArray[np.float_],
+        out_of_bounds: npt.NDArray[np.bool_],
     ) -> npt.NDArray[np.float_]:
         """Set out-of-bounds values to the fill value.
 
@@ -145,7 +141,7 @@ class PycontrailsRegularGridInterpolator(scipy.interpolate.RegularGridInterpolat
         ----------
         out : npt.NDArray[np.float_]
             Values from interpolation. This is modified in-place.
-        out_of_bounds : npt.NDArray[np.bool_] | None
+        out_of_bounds : npt.NDArray[np.bool_]
             A 1-dimensional Boolean array indicating which points are out of bounds.
 
         Returns
@@ -153,7 +149,7 @@ class PycontrailsRegularGridInterpolator(scipy.interpolate.RegularGridInterpolat
         out : npt.NDArray[np.float_]
             A reference to the ``out`` array.
         """
-        if out_of_bounds is not None and self.fill_value is not None:
+        if self.fill_value is not None and np.any(out_of_bounds):
             out[out_of_bounds] = self.fill_value
 
         return out
@@ -557,7 +553,7 @@ class RGIArtifacts:
 
     xi_indices: npt.NDArray[np.int64]
     norm_distances: npt.NDArray[np.float64]
-    out_of_bounds: npt.NDArray[np.bool_] | None
+    out_of_bounds: npt.NDArray[np.bool_]
 
 
 # ------------------------------------------------------------------------------

pycontrails/core/met.py

@@ -416,7 +416,7 @@ class MetBase(ABC, Generic[XArrayType]):
         >>> variables = "air_temperature", "specific_humidity"
         >>> levels = [200, 300]
         >>> era5 = ERA5(times, variables, levels)
-        >>> mds = era5.open_metdataset(xr_kwargs=dict(parallel=False))
+        >>> mds = era5.open_metdataset()
         >>> mds.variables["level"].values  # faster access than mds.data["level"]
         array([200., 300.])
 
@@ -606,7 +606,7 @@ class MetDataset(MetBase):
     >>> era5 = ERA5(time, variables, pressure_levels)
 
     >>> # Open directly as `MetDataset`
-    >>> met = era5.open_metdataset(xr_kwargs=dict(parallel=False))
+    >>> met = era5.open_metdataset()
     >>> # Use `data` attribute to access `xarray` object
     >>> assert isinstance(met.data, xr.Dataset)
 
@@ -992,7 +992,7 @@ class MetDataset(MetBase):
         >>> variables = ["air_temperature", "specific_humidity"]
         >>> levels = [250, 200]
         >>> era5 = ERA5(time=times, variables=variables, pressure_levels=levels)
-        >>> met = era5.open_metdataset(xr_kwargs=dict(parallel=False))
+        >>> met = era5.open_metdataset()
         >>> met.to_vector(transfer_attrs=False)
         GeoVectorDataset [6 keys x 4152960 length, 1 attributes]
             Keys: longitude, latitude, level, time, air_temperature, ..., specific_humidity
@@ -1507,7 +1507,7 @@ class MetDataArray(MetBase):
         >>> variables = "air_temperature"
         >>> levels = [200, 250, 300]
         >>> era5 = ERA5(times, variables, levels)
-        >>> met = era5.open_metdataset(xr_kwargs=dict(parallel=False))
+        >>> met = era5.open_metdataset()
         >>> mda = met["air_temperature"]
 
         >>> # Interpolation at a grid point agrees with value
@@ -1779,7 +1779,7 @@ class MetDataArray(MetBase):
         >>> from pprint import pprint
         >>> from pycontrails.datalib.ecmwf import ERA5
         >>> era5 = ERA5("2022-03-01", variables="air_temperature", pressure_levels=250)
-        >>> mda = era5.open_metdataset(xr_kwargs=dict(parallel=False))["air_temperature"]
+        >>> mda = era5.open_metdataset()["air_temperature"]
         >>> mda.shape
         (1440, 721, 1, 1)
 

pycontrails/core/models.py

@@ -566,6 +566,10 @@ class Model(ABC):
             try:
                 # This case is when self.source is a subgrid of self.met
                 # The call to .sel will raise a KeyError if this is not the case
+
+                # XXX: Sometimes this hangs when using dask!
+                # This issue is somewhat similar to
+                # https://github.com/pydata/xarray/issues/4406
                 self.source[met_key] = da.sel(self.source.coords)
 
             except KeyError: