pycontrails 0.57.0__cp311-cp311-macosx_11_0_arm64.whl → 0.59.0__cp311-cp311-macosx_11_0_arm64.whl

pycontrails/datalib/ecmwf/hres.py

@@ -708,7 +708,7 @@ class HRES(ECMWFAPI):
 
         # set forecast time if it's not defined (this occurs when only the paths param is provided)
         if not hasattr(self, "forecast_time"):
-            self.forecast_time = ds["time"].values.astype("datetime64[s]").tolist()  # type: ignore[assignment]
+            self.forecast_time = ds["time"].values.astype("datetime64[s]").tolist()
 
         # check that forecast_time is correct if defined
         # note the "time" coordinate here is the HRES forecast_time
@@ -723,7 +723,7 @@ class HRES(ECMWFAPI):
         # set timesteps if not defined
         # note that "time" is now the actual timestep coordinates
         if not self.timesteps:
-            self.timesteps = ds["time"].values.astype("datetime64[s]").tolist()  # type: ignore[assignment]
+            self.timesteps = ds["time"].values.astype("datetime64[s]").tolist()
 
         self.cache_dataset(ds)
 

pycontrails/datalib/ecmwf/ifs.py

@@ -149,7 +149,7 @@ class IFS(metsource.MetDataSource):
         else:
             # set timesteps from dataset "time" coordinates
             # np.datetime64 doesn't covert to list[datetime] unless its unit is us
-            self.timesteps = ds["time"].values.astype("datetime64[us]").tolist()  # type: ignore[assignment]
+            self.timesteps = ds["time"].values.astype("datetime64[us]").tolist()
 
         # downselect hyam/hybm coefficients by the "lev" coordinate
         # (this is a 1-indexed verison of nhym)

pycontrails/datalib/ecmwf/model_levels.py

@@ -139,9 +139,9 @@ def model_level_pressure(sp: xr.DataArray, model_levels: npt.ArrayLike) -> xr.Da
             [564.02437124, 560.81744834, 557.61052544, 554.40360254],
             [551.19667964, 547.98975674, 544.78283384, 541.57591094]]])
     Coordinates:
+      * model_level  (model_level) int64 16B 80 100
       * longitude    (longitude) float64 32B -180.0 -60.0 60.0 180.0
       * latitude     (latitude) float64 32B -90.0 -30.0 30.0 90.0
-      * model_level  (model_level) int64 16B 80 100
 
     See Also
     --------

pycontrails/datalib/gfs/gfs.py

@@ -595,7 +595,7 @@ class GFSForecast(metsource.MetDataSource):
         else:
             # set timesteps from dataset "time" coordinates
             # np.datetime64 doesn't covert to list[datetime] unless its unit is us
-            self.timesteps = ds["time"].values.astype("datetime64[us]").tolist()  # type: ignore[assignment]
+            self.timesteps = ds["time"].values.astype("datetime64[us]").tolist()
 
         # if "level" is not in dims and
         # length of the requested pressure levels is 1

pycontrails/datalib/goes.py

@@ -308,9 +308,14 @@ def gcs_goes_path(
     fs = fs or gcsfs.GCSFileSystem(token="anon")
     rpaths = fs.glob(rpath)
 
-    out = [r for r in rpaths if _extract_band_from_rpath(r) in bands]
-    if not out:
-        raise RuntimeError(f"No data found for {time} in {region} for bands {bands}")
+    out = []
+    for r in rpaths:
+        if (band := _extract_band_from_rpath(r)) in bands:
+            out.append(r)
+            bands.remove(band)
+
+    if bands:
+        raise FileNotFoundError(f"No data found for {time} in {region} for bands {bands}")
     return out
 
 
@@ -427,6 +432,8 @@ class GOES:
 
     """
 
+    __slots__ = ("bands", "bucket", "cachestore", "fs", "region")
+
     __marker = object()
 
     def __init__(

pycontrails/datalib/gruan.py

@@ -0,0 +1,343 @@
+"""Support for accessing `GRUAN <https://www.gruan.org/>`_ data over FTP."""
+
+import datetime
+import ftplib
+import functools
+import os
+import tempfile
+from concurrent import futures
+
+import xarray as xr
+
+from pycontrails.core import cache
+
+#: GRUAN FTP server address
+FTP_SERVER = "ftp.ncdc.noaa.gov"
+
+#: Base path for GRUAN data on the FTP server
+FTP_BASE_PATH = "/pub/data/gruan/processing/level2"
+
+#: All available GRUAN products and sites on the FTP server as of 2025-10
+#: This is simply the hardcoded output of :func:`available_sites` at that time to
+#: avoid a lookup that changes infrequently.
+AVAILABLE_PRODUCTS_TO_SITES = {
+    "RS-11G-GDP.1": ["SYO", "TAT", "NYA", "LIN"],
+    "RS41-EDT.1": ["LIN", "POT", "SNG"],
+    "RS92-GDP.1": ["BOU", "CAB", "LIN", "PAY", "POT", "SOD", "TAT"],
+    "RS92-GDP.2": [
+        "BAR",
+        "BEL",
+        "BOU",
+        "CAB",
+        "DAR",
+        "GRA",
+        "LAU",
+        "LIN",
+        "MAN",
+        "NAU",
+        "NYA",
+        "PAY",
+        "POT",
+        "REU",
+        "SGP",
+        "SOD",
+        "TAT",
+        "TEN",
+        "GVN",
+    ],
+    "RS92-PROFILE-BETA.2": ["BOU", "CAB", "LIN", "POT", "SOD", "TAT"],
+    "RS92-PROFILE-BETA.3": ["BOU", "CAB", "LIN", "POT", "SOD", "TAT"],
+}
+
+
+def extract_gruan_time(filename: str) -> tuple[datetime.datetime, int]:
+    """Extract launch time and revision number from a GRUAN filename.
+
+    Parameters
+    ----------
+    filename : str
+        GRUAN filename, e.g. "LIN-RS-01_2_RS92-GDP_002_20210125T132400_1-000-001.nc"
+
+    Returns
+    -------
+    tuple[datetime.datetime, int]
+        Launch time as a datetime object and revision number as an integer.
+    """
+    parts = filename.split("_")
+    if len(parts) != 6:
+        raise ValueError(f"Unexpected filename format: {filename}")
+    time_part = parts[4]
+    try:
+        time = datetime.datetime.strptime(time_part, "%Y%m%dT%H%M%S")
+    except ValueError as e:
+        raise ValueError(f"Unexpected time segment: {time_part}") from e
+
+    revision_part = parts[5].removesuffix(".nc")
+    if not revision_part[-3:].isdigit():
+        raise ValueError(f"Unexpected revision segment: {revision_part}")
+    revision = int(revision_part[-3:])
+
+    return time, revision
+
+
+def _fetch_product_tree(prod: str) -> dict[str, list[str]]:
+    result = {}
+    with ftplib.FTP(FTP_SERVER) as ftp:
+        ftp.login()
+        prod_path = f"{FTP_BASE_PATH}/{prod}"
+        versions = [v.split("/")[-1] for v in ftp.nlst(prod_path)]
+
+        for v in versions:
+            version_path = f"{prod_path}/{v}"
+            sites = [s.split("/")[-1] for s in ftp.nlst(version_path)]
+
+            key = f"{prod}.{int(v.split('-')[-1])}"
+            result[key] = sites
+    return result
+
+
+@functools.cache
+def available_sites() -> dict[str, list[str]]:
+    """Get a list of available GRUAN sites for each supported product.
+
+    The :attr:`GRUAN.AVAILABLE` is a hardcoded snapshot of this data. The data returned
+    by this function does not change frequently, so it is cached for efficiency.
+
+    Returns
+    -------
+    dict[str, list[str]]
+        Mapping of product names to lists of available site identifiers.
+    """
+    with ftplib.FTP(FTP_SERVER) as ftp:
+        ftp.login()
+        files = [p.split("/")[-1] for p in ftp.nlst(FTP_BASE_PATH)]
+        products = [p for p in files if "." not in p]  # crude filter to exclude non-directories
+
+    # Compute each product tree in separate thread to speed up retrieval
+    # The FTP server only allows up to 5 connections from the same client
+    out = {}
+    with futures.ThreadPoolExecutor(max_workers=min(len(products), 5)) as tpe:
+        result = tpe.map(_fetch_product_tree, products)
+        for r in result:
+            out.update(r)
+
+    return out
+
+
+class GRUAN:
+    """Access `GRUAN <https://www.gruan.org/>`_ data over anonymous FTP.
+
+    GRUAN is the Global Climate Observing System Reference Upper-Air Network. It provides
+    high-quality measurements of atmospheric variables from ground to stratosphere
+    through a global network of radiosonde stations.
+
+    .. versionadded:: 0.59.0
+
+    Parameters
+    ----------
+    product : str
+        GRUAN data product. See :attr:`AVAILABLE` for available products. These currently
+        include:
+        - ``RS92-GDP.2``
+        - ``RS92-GDP.1``
+        - ``RS92-PROFILE-BETA.2``
+        - ``RS92-PROFILE-BETA.3``
+        - ``RS41-EDT.1``
+        - ``RS-11G-GDP.1``
+    site : str
+        GRUAN station identifier. See :attr:`AVAILABLE` for available sites for each product.
+    cachestore : cache.CacheStore | None, optional
+        Cache store to use for downloaded files. If not provided, a disk cache store
+        will be created in the user cache directory under ``gruan/``. Set to ``None``
+        to disable caching.
+
+    Notes
+    -----
+    The FTP files have the following hierarchy::
+
+        /pub/data/gruan/processing/level2/
+            {product-root}/
+                version-{NNN}/
+                    {SITE}/
+                        {YYYY}/
+                            <filename>.nc
+
+    - {product-root} is the product name without the trailing version integer (e.g. ``RS92-GDP``)
+    - version-{NNN} zero-pads to three digits (suffix ``.2`` -> ``version-002``)
+    - {SITE} is the station code (e.g. ``LIN``)
+    - {YYYY} is launch year
+    - Filenames encode launch time and revision (parsed by :func:`extract_gruan_time`)
+
+    Discovery helpers methods:
+
+        - :attr:`AVAILABLE` or :func:`available_sites` -> products and sites
+        - :meth:`years` -> list available years for (product, site)
+        - :meth:`list_files` -> list available NetCDF files for the given year
+        - :meth:`get` -> download and open a single NetCDF file as an :class:`xarray.Dataset`
+
+    Typical workflow:
+
+        1. Inspect :attr:`AVAILABLE` (fast) or call :func:`available_sites` (live)
+        2. Instantiate ``GRUAN(product, site)``
+        3. Call ``years()``
+        4. Call ``list_files(year)``
+        5. Call ``get(filename)`` for an ``xarray.Dataset``
+
+    """
+
+    # Convenience access to available sites
+    available_sites = staticmethod(available_sites)
+    AVAILABLE = AVAILABLE_PRODUCTS_TO_SITES
+
+    __slots__ = ("_ftp", "cachestore", "product", "site")
+
+    __marker = object()
+
+    def __init__(
+        self,
+        product: str,
+        site: str,
+        cachestore: cache.CacheStore | None = __marker,  # type: ignore[assignment]
+    ) -> None:
+        known = AVAILABLE_PRODUCTS_TO_SITES
+
+        if product not in known:
+            known = available_sites()  # perhaps AVAILABLE_PRODUCTS_TO_SITES is outdated
+            if product not in known:
+                raise ValueError(f"Unknown GRUAN product: {product}. Known products: {list(known)}")
+        self.product = product
+
+        if site not in known[product]:
+            known = available_sites()  # perhaps AVAILABLE_PRODUCTS_TO_SITES is outdated
+            if site not in known[product]:
+                raise ValueError(
+                    f"Unknown GRUAN site '{site}' for product '{product}'. "
+                    f"Known sites: {known[product]}"
+                )
+        self.site = site
+
+        if cachestore is self.__marker:
+            cache_root = cache._get_user_cache_dir()
+            cache_dir = f"{cache_root}/gruan"
+            cachestore = cache.DiskCacheStore(cache_dir=cache_dir)
+        self.cachestore = cachestore
+
+        self._ftp: ftplib.FTP | None = None
+
+    def __repr__(self) -> str:
+        return f"GRUAN(product='{self.product}', site='{self.site}')"
+
+    def _connect(self) -> ftplib.FTP:
+        """Connect to the GRUAN FTP server."""
+        if self._ftp is None or self._ftp.sock is None:
+            self._ftp = ftplib.FTP(FTP_SERVER)
+            self._ftp.login()
+            return self._ftp
+
+        try:
+            self._ftp.pwd()  # check if connection is still alive
+        except (*ftplib.all_errors, ConnectionError):  # type: ignore[misc]
+            # If we encounter any error, reset the connection and retry
+            self._ftp = None
+            return self._connect()
+        return self._ftp
+
+    @property
+    def base_path_product(self) -> str:
+        """Get the base path for GRUAN data product on the FTP server."""
+        product, version = self.product.rsplit(".")
+        return f"/pub/data/gruan/processing/level2/{product}/version-{version.zfill(3)}"
+
+    @property
+    def base_path_site(self) -> str:
+        """Get the base path for GRUAN data site on the FTP server."""
+        return f"{self.base_path_product}/{self.site}"
+
+    def years(self) -> list[int]:
+        """Get a list of available years for the selected product and site."""
+        ftp = self._connect()
+        ftp.cwd(self.base_path_site)
+        years = ftp.nlst()
+        return sorted(int(year) for year in years)
+
+    def list_files(self, year: int | None = None) -> list[str]:
+        """List available files for a given year.
+
+        Parameters
+        ----------
+        year : int | None, optional
+            Year to list files for. If ``None``, list files for all available years. The later
+            may be time-consuming.
+
+        Returns
+        -------
+        list[str]
+            List of available GRUAN filenames for the specified year.
+        """
+        if year is None:
+            years = self.years()
+            return sorted(file for y in years for file in self.list_files(y))
+
+        path = f"{self.base_path_site}/{year}"
+
+        ftp = self._connect()
+        try:
+            ftp.cwd(path)
+        except ftplib.error_perm as e:
+            available = self.years()
+            if year not in available:
+                msg = f"No data available for year {year}. Available years are: {available}"
+                raise ValueError(msg) from e
+            raise
+        return sorted(ftp.nlst())
+
+    def get(self, filename: str) -> xr.Dataset:
+        """Download a GRUAN dataset by filename.
+
+        Parameters
+        ----------
+        filename : str
+            GRUAN filename to download, e.g. "LIN-RS-01_2_RS92-GDP_002_20210125T132400_1-000-001.nc"
+
+        Returns
+        -------
+        xr.Dataset
+            The GRUAN dataset retrieved from the FTP server. If caching is enabled,
+            the file is downloaded to the cache store and loaded from there on subsequent calls.
+        """
+        if self.cachestore is None:
+            return self._get_no_cache(filename)
+        return self._get_with_cache(filename)
+
+    def _get_no_cache(self, filename: str) -> xr.Dataset:
+        t, _ = extract_gruan_time(filename)
+        path = f"{self.base_path_site}/{t.year}/{filename}"
+
+        ftp = self._connect()
+
+        try:
+            # On windows, NamedTemporaryFile cannot be reopened while still open.
+            # After python 3.11 support is dropped, we can use delete_on_close=False
+            # in NamedTemporaryFile to streamline this.
+            with tempfile.NamedTemporaryFile(delete=False) as tmp:
+                ftp.retrbinary(f"RETR {path}", tmp.write)
+            return xr.load_dataset(tmp.name)
+        finally:
+            os.remove(tmp.name)
+
+    def _get_with_cache(self, filename: str) -> xr.Dataset:
+        if self.cachestore is None:
+            raise ValueError("Cachestore is not configured.")
+
+        lpath = self.cachestore.path(filename)
+        if self.cachestore.exists(lpath):
+            return xr.open_dataset(lpath)
+
+        t, _ = extract_gruan_time(filename)
+        path = f"{self.base_path_site}/{t.year}/{filename}"
+
+        ftp = self._connect()
+        with open(lpath, "wb") as f:
+            ftp.retrbinary(f"RETR {path}", f.write)
+
+        return xr.open_dataset(lpath)

pycontrails/datalib/himawari/header_struct.py

@@ -205,7 +205,7 @@ HEADER_STRUCT_SCHEMA: dict[int, _HeaderBlock] = {
 }
 
 
-def parse_himawari_header(content: bytes) -> dict:
+def parse_himawari_header(content: bytes) -> dict[str, dict[str, Any]]:
     """Parse the Himawari header data.
 
     Skips variable-length fields and spares.

pycontrails/datalib/himawari/himawari.py

@@ -160,7 +160,10 @@ def _extract_band_from_rpath(rpath: str) -> str:
     return f"B{suffix[:2]}"  # B??
 
 
-def _mask_invalid(data: npt.NDArray[np.uint16], calib_info: dict) -> npt.NDArray[np.float32]:
+def _mask_invalid(
+    data: npt.NDArray[np.uint16],
+    calib_info: dict[str, Any],
+) -> npt.NDArray[np.float32]:
     """Mask invalid data."""
     error_pixel = calib_info["count_error_pixels"]
     outside_pixel = calib_info["count_outside_scan_area"]
@@ -218,7 +221,9 @@ def _counts_to_radiance(
     return counts * gain + const
 
 
-def _load_image_data(content: bytes, metadata: dict) -> npt.NDArray[np.float32]:
+def _load_image_data(
+    content: bytes, metadata: dict[str, dict[str, Any]]
+) -> npt.NDArray[np.float32]:
     counts = _load_raw_counts(content, metadata)
 
     calib_info = metadata["calibration_information"]
@@ -230,7 +235,10 @@ def _load_image_data(content: bytes, metadata: dict) -> npt.NDArray[np.float32]:
     return _radiance_to_brightness_temperature(radiance, calib_info)
 
 
-def _ahi_fixed_grid(proj_info: dict, arr: np.ndarray) -> tuple[xr.DataArray, xr.DataArray]:
+def _ahi_fixed_grid(
+    proj_info: dict[str, Any],
+    arr: np.ndarray,
+) -> tuple[xr.DataArray, xr.DataArray]:
     n_lines, n_columns = arr.shape
 
     i = np.arange(n_columns, dtype=np.float32)
@@ -277,7 +285,11 @@ def _himawari_proj4_string(proj_info: dict[str, Any]) -> str:
     return f"+proj=geos +h={h} +a={a} +b={b} +lon_0={lon} +sweep=x +units=m +no_defs"
 
 
-def _earth_disk_mask(proj_info: dict, x: xr.DataArray, y: xr.DataArray) -> npt.NDArray[np.bool_]:
+def _earth_disk_mask(
+    proj_info: dict[str, Any],
+    x: xr.DataArray,
+    y: xr.DataArray,
+) -> npt.NDArray[np.bool_]:
     """Return a boolean mask where True indicates pixels over the Earth disk."""
     a = proj_info["equatorial_radius"] * 1000.0  # km -> m
     b = proj_info["polar_radius"] * 1000.0  # km -> m
@@ -301,7 +313,7 @@ def _earth_disk_mask(proj_info: dict, x: xr.DataArray, y: xr.DataArray) -> npt.N
     return discriminant >= 0.0
 
 
-def _parse_start_time(metadata: dict) -> datetime.datetime:
+def _parse_start_time(metadata: dict[str, dict[str, Any]]) -> datetime.datetime:
     """Parse the start time from the metadata."""
     mjd_value = metadata["basic_information"]["obs_start_time"]
     mjd_epoch = datetime.datetime(1858, 11, 17)
@@ -355,9 +367,12 @@ def _parse_s3_raw_data(raw_data: list[bytes]) -> xr.DataArray:
 
 
 class Himawari:
-    """Support for Himawari-8/9 satellite data accessed via AWS S3.
+    """Support for Himawari-8/9 satellite data access via AWS S3.
 
-    This interface requires the ``s3fs`` package.
+    This interface requires the ``s3fs`` package to download data from the
+    `AWS Public Dataset <https://registry.opendata.aws/himawari/>`_.
+
+    .. versionadded:: 0.57.0
 
     Parameters
     ----------
@@ -382,6 +397,8 @@ class Himawari:
     HimawariRegion
     """
 
+    __slots__ = ("bands", "bucket", "cachestore", "fs", "region")
+
     __marker = object()
 
     def __init__(

pycontrails/datalib/leo_utils/sentinel_metadata.py

@@ -1,10 +1,10 @@
 """Download and parse Sentinel metadata."""
 
+import datetime
 import os
 import re
 import xml.etree.ElementTree as ET
 from collections.abc import Collection
-from datetime import datetime, timedelta, timezone
 
 import numpy as np
 import numpy.typing as npt
@@ -464,10 +464,10 @@ def parse_ephemeris_sentinel(datatsrip_metadata_path: str) -> pd.DataFrame:
                 if position_elem is None or position_elem.text is None:
                     continue  # skip if missing
 
-                gps_time = datetime.strptime(gps_time_elem.text, "%Y-%m-%dT%H:%M:%S")
+                gps_time = datetime.datetime.strptime(gps_time_elem.text, "%Y-%m-%dT%H:%M:%S")
 
                 # Convert GPS to UTC time as there is a few seconds between them
-                utc_time = gps_to_utc(gps_time).replace(tzinfo=timezone.utc)
+                utc_time = gps_to_utc(gps_time).replace(tzinfo=datetime.UTC)
 
                 # Parse positions in ECEF coordinate system
                 x, y, z = map(float, position_elem.text.split())
@@ -643,30 +643,30 @@ def get_time_delay_detectors(
 # Time helper functions
 
 
-def gps_to_utc(gps_time: datetime) -> datetime:
+def gps_to_utc(gps_time: datetime.datetime) -> datetime.datetime:
     """Convert GPS time (datetime object) to UTC time.
 
     https://gssc.esa.int/navipedia/index.php/Transformations_between_Time_Systems
     """
 
-    gps_tai_offset = timedelta(seconds=19)
-    utc_tai_offset = timedelta(seconds=37)
+    gps_tai_offset = datetime.timedelta(seconds=19)
+    utc_tai_offset = datetime.timedelta(seconds=37)
 
     # Convert GPS time to UTC
     return gps_time + gps_tai_offset - utc_tai_offset
 
 
-def _calculate_average_time(times: Collection[datetime]) -> datetime:
+def _calculate_average_time(times: Collection[datetime.datetime]) -> datetime.datetime:
     """Return the average time from a list of times."""
     # Compute the average time
     avg_timestamp = sum(t.timestamp() for t in times) / len(times)
-    return datetime.fromtimestamp(avg_timestamp)
+    return datetime.datetime.fromtimestamp(avg_timestamp)
 
 
 def _calculate_timedeltas(detector_times: dict[int, str]) -> dict[int, pd.Timedelta]:
     """Calculate the time difference between a detector and the average time."""
     detector_times_dt = {
-        detector_id: datetime.strptime(time_str, "%Y-%m-%dT%H:%M:%S.%f")
+        detector_id: datetime.datetime.strptime(time_str, "%Y-%m-%dT%H:%M:%S.%f")
         for detector_id, time_str in detector_times.items()
     }
 

pycontrails/ext/synthetic_flight.py

@@ -305,8 +305,8 @@ class SyntheticFlight:
             *src,
             az,
             npts,
-            m_per_timestep,  # type: ignore
-            return_back_azimuth=False,  # type: ignore
+            m_per_timestep,
+            return_back_azimuth=False,
         )
         longitude = np.asarray(result.lons)
         latitude = np.asarray(result.lats)

pycontrails/models/cocip/cocip_uncertainty.py

@@ -30,7 +30,7 @@ class habit_dirichlet(rv_frozen):
     - Table 2 in :cite:`schumannEffectiveRadiusIce2011`
     """
 
-    def __init__(self, C: float = 96.0):
+    def __init__(self, C: float = 96.0) -> None:
         self.C = C
 
     def rvs(self, *args: Any, **kwds: Any) -> npt.NDArray[np.float32]:

pycontrails/models/cocip/contrail_properties.py

@@ -236,7 +236,7 @@ def initial_ice_particle_number(
         phase, [:math:`# m^{-1}`]
     """
     if min_aei is not None:
-        aei = np.clip(aei, min=min_aei)  # type: ignore[arg-type,call-overload]
+        aei = np.clip(aei, min_aei, None)
     return fuel_dist * aei
 
 

pycontrails/models/cocip/output_formats.py

@@ -2228,7 +2228,7 @@ def compare_cocip_with_goes(
     fig = plt.figure(figsize=(1.2 * x_dim, y_dim))
     pc = ccrs.PlateCarree()
     ax = fig.add_subplot(projection=pc, extent=bbox)
-    ax.coastlines()  # type: ignore[attr-defined]
+    ax.coastlines()
     ax.imshow(rgb, extent=extent, transform=transform)
 
     ax.set_xticks([spatial_bbox[0], spatial_bbox[2]], crs=ccrs.PlateCarree())

pycontrails/models/cocipgrid/cocip_grid.py

@@ -114,7 +114,7 @@ class CocipGrid(models.Model):
         rad: MetDataset,
         params: dict[str, Any] | None = None,
         **params_kwargs: Any,
-    ):
+    ) -> None:
         super().__init__(met, params=params, **params_kwargs)
 
         compute_tau_cirrus = self.params["compute_tau_cirrus_in_model_init"]
@@ -386,7 +386,7 @@ class CocipGrid(models.Model):
             "dt_integration": dt_integration_str,
             "aircraft_type": self.get_source_param("aircraft_type"),
             "pycontrails_version": pycontrails.__version__,
-            **self.source.attrs,  # type: ignore[dict-item]
+            **self.source.attrs,
         }
         if ap_model := self.params["aircraft_performance"]:
             attrs["ap_model"] = type(ap_model).__name__
@@ -2210,7 +2210,7 @@ def result_to_metdataset(
     # Update source
     for k, v in data_vars.items():  # type: ignore[assignment]
         source[k] = v
-    source.attrs.update(attrs)  # type: ignore[arg-type]
+    source.attrs.update(attrs)
 
     # Return reference to source
     return source

pycontrails/models/dry_advection.py

@@ -590,7 +590,7 @@ def _evolve_one_step(
         vector,
         dz_m=dz_m,
         dt=dt,  # type: ignore[arg-type]
-        max_depth=max_depth,  # type: ignore[arg-type]
+        max_depth=max_depth,
         verbose_outputs=verbose_outputs,
     )
     out["azimuth"] = azimuth_2

pycontrails/models/extended_k15.py

@@ -24,12 +24,12 @@ DEFAULT_EXHAUST_T = 600.0  # Exhaust temperature, [K]
 EXPERIMENTAL_WARNING = True
 
 
-class ParticleType(enum.Enum):
+class ParticleType(enum.StrEnum):
     """Enumeration of particle types."""
 
-    NVPM = "nvPM"
-    VPM = "vPM"
-    AMBIENT = "ambient"
+    NVPM = enum.auto()
+    VPM = enum.auto()
+    AMBIENT = enum.auto()
 
 
 @dataclasses.dataclass(frozen=True)