cloudnetpy 1.61.7__py3-none-any.whl → 1.61.9__py3-none-any.whl

cloudnetpy/categorize/categorize.py

@@ -289,33 +289,38 @@ COMMENTS = {
 }
 
 DEFINITIONS = {
-    "category_bits": (
-        "\n"
-        "Bit 0: Small liquid droplets are present.\n"
-        "Bit 1: Falling hydrometeors are present; if Bit 2 is set then these are most\n"
-        "       likely ice particles, otherwise they are drizzle or rain drops.\n"
-        "Bit 2: Wet-bulb temperature is less than 0 degrees C, implying the phase of\n"
-        "       Bit-1 particles.\n"
-        "Bit 3: Melting ice particles are present.\n"
-        "Bit 4: Aerosol particles are present and visible to the lidar.\n"
-        "Bit 5: Insects are present and visible to the radar."
+    "category_bits": utils.bit_field_definition(
+        {
+            0: """Small liquid droplets are present.""",
+            1: """Falling hydrometeors are present; if Bit 2 is set then these
+                  are most likely ice particles, otherwise they are drizzle or
+                  rain drops.""",
+            2: """Wet-bulb temperature is less than 0 degrees C, implying the
+                  phase of Bit-1 particles.""",
+            3: """Melting ice particles are present.""",
+            4: """Aerosol particles are present and visible to the lidar.""",
+            5: """Insects are present and visible to the radar.""",
+        }
     ),
-    "quality_bits": (
-        "\n"
-        "Bit 0: An echo is detected by the radar.\n"
-        "Bit 1: An echo is detected by the lidar.\n"
-        "Bit 2: The apparent echo detected by the radar is ground clutter or some\n"
-        "       other non-atmospheric artifact.\n"
-        "Bit 3: The lidar echo is due to clear-air molecular scattering.\n"
-        "Bit 4: Liquid water cloud, rainfall or melting ice below this pixel\n"
-        "       will have caused radar and lidar attenuation; if bit 5 is set then\n"
-        "       a correction for the radar attenuation has been performed;\n"
-        "       otherwise do not trust the absolute values of reflectivity factor.\n"
-        "       No correction is performed for lidar attenuation.\n"
-        "Bit 5: Radar reflectivity has been corrected for liquid-water attenuation\n"
-        "       using the microwave radiometer measurements of liquid water path\n"
-        "       and the lidar estimation of the location of liquid water cloud;\n"
-        "       be aware that errors in reflectivity may result.\n"
+    "quality_bits": utils.bit_field_definition(
+        {
+            0: """An echo is detected by the radar.""",
+            1: """An echo is detected by the lidar.""",
+            2: """The apparent echo detected by the radar is ground clutter or
+                  some other non-atmospheric artifact.""",
+            3: """The lidar echo is due to clear-air molecular scattering.""",
+            4: """Liquid water cloud, rainfall or melting ice below this pixel
+                  will have caused radar and lidar attenuation; if bit 5 is set
+                  then a correction for the radar attenuation has been
+                  performed; otherwise do not trust the absolute values of
+                  reflectivity factor. No correction is performed for lidar
+                  attenuation.""",
+            5: """Radar reflectivity has been corrected for liquid-water
+                  attenuation using the microwave radiometer measurements of
+                  liquid water path and the lidar estimation of the location of
+                  liquid water cloud; be aware that errors in reflectivity may
+                  result.""",
+        }
     ),
 }
 

cloudnetpy/instruments/ceilo.py

@@ -4,7 +4,7 @@ from itertools import islice
 import netCDF4
 from numpy import ma
 
-from cloudnetpy import output
+from cloudnetpy import output, utils
 from cloudnetpy.instruments.campbell_scientific import Cs135
 from cloudnetpy.instruments.cl61d import Cl61d
 from cloudnetpy.instruments.lufft import LufftCeilo
@@ -225,11 +225,12 @@ ATTRIBUTES = {
     "warning": MetaData(
         long_name="Warning and Alarm flag",
         units="1",
-        definition=(
-            "\n"
-            "Value 0: Self-check OK\n"
-            "Value W: At least one warning on\n"
-            "Value A: At least one error active."
+        definition=utils.status_field_definition(
+            {
+                "0": "Self-check OK",
+                "W": "At least one warning on",
+                "A": "At least one error active.",
+            }
         ),
     ),
     "warning_flags": MetaData(

cloudnetpy/instruments/rpg.py

@@ -346,30 +346,37 @@ def _filter_zenith_angle(zenith: ma.MaskedArray) -> np.ndarray:
 
 
 DEFINITIONS = {
-    "model_number": "\n"
-    "0: Single polarisation radar.\n"
-    "1: Dual polarisation radar.",
-    "dual_polarization": (
-        "\n"
-        "Value 0: Single polarisation radar.\n"
-        "Value 1: Dual polarisation radar in linear depolarisation ratio (LDR) mode.\n"
-        "Value 2: Dual polarisation radar in simultaneous transmission simultaneous\n"
-        "reception (STSR) mode."
-    ),
-    "FFT_window": (
-        "\n"
-        "Value 0: Square\n"
-        "Value 1: Parzen\n"
-        "Value 2: Blackman\n"
-        "Value 3: Welch\n"
-        "Value 4: Slepian2\n"
-        "Value 5: Slepian3"
-    ),
-    "quality_flag": (
-        "\n"
-        "Bit 0: ADC saturation.\n"
-        "Bit 1: Spectral width too high.\n"
-        "Bit 2: No transmission power levelling."
+    "model_number": utils.status_field_definition(
+        {
+            0: "Single polarisation radar.",
+            1: "Dual polarisation radar.",
+        }
+    ),
+    "dual_polarization": utils.status_field_definition(
+        {
+            0: """Single polarisation radar.""",
+            1: """Dual polarisation radar in linear depolarisation ratio (LDR)
+                  mode.""",
+            2: """Dual polarisation radar in simultaneous transmission
+                  simultaneous reception (STSR) mode.""",
+        }
+    ),
+    "FFT_window": utils.status_field_definition(
+        {
+            0: "Square",
+            1: "Parzen",
+            2: "Blackman",
+            3: "Welch",
+            4: "Slepian2",
+            5: "Slepian3",
+        }
+    ),
+    "quality_flag": utils.bit_field_definition(
+        {
+            0: "ADC saturation.",
+            1: "Spectral width too high.",
+            2: "No transmission power levelling.",
+        }
     ),
 }
 

cloudnetpy/instruments/vaisala.py

@@ -54,10 +54,13 @@ class VaisalaCeilo(Ceilometer):
     def _read_backscatter(self, lines: list) -> np.ndarray:
         """Converts backscatter profile from 2-complement hex to floats."""
         n_chars = self._hex_conversion_params[0]
-        n_gates = int(len(lines[0]) / n_chars)
+        n_gates = len(self.data["range"])
         profiles = np.zeros((len(lines), n_gates), dtype=int)
         ran = range(0, n_gates * n_chars, n_chars)
         for ind, line in enumerate(lines):
+            if int(len(line) / n_chars) != n_gates:
+                logging.warning("Invalid line in raw ceilometer data")
+                continue
             try:
                 profiles[ind, :] = [int(line[i : i + n_chars], 16) for i in ran]
             except ValueError:

cloudnetpy/instruments/weather_station.py

@@ -1,4 +1,6 @@
+import csv
 import datetime
+import math
 
 import numpy as np
 from numpy import ma
@@ -15,7 +17,7 @@ from cloudnetpy.utils import datetime2decimal_hours
 
 
 def ws2nc(
-    weather_station_file: str,
+    weather_station_file: str | list[str],
     output_file: str,
     site_meta: dict,
     uuid: str | None = None,
@@ -38,12 +40,16 @@ def ws2nc(
         WeatherStationDataError : Unable to read the file.
         ValidTimeStampError: No valid timestamps found.
     """
+    if not isinstance(weather_station_file, list):
+        weather_station_file = [weather_station_file]
     try:
         ws: WS
         if site_meta["name"] == "Palaiseau":
             ws = PalaiseauWS(weather_station_file, site_meta)
         elif site_meta["name"] == "Granada":
             ws = GranadaWS(weather_station_file, site_meta)
+        elif site_meta["name"] == "Kenttärova":
+            ws = KenttarovaWS(weather_station_file, site_meta)
         else:
             msg = "Unsupported site"
             raise ValueError(msg)  # noqa: TRY301
@@ -81,9 +87,11 @@ class WS(CloudnetInstrument):
 
 
 class PalaiseauWS(WS):
-    def __init__(self, filename: str, site_meta: dict):
+    def __init__(self, filenames: list[str], site_meta: dict):
         super().__init__()
-        self.filename = filename
+        if len(filenames) != 1:
+            raise ValueError
+        self.filename = filenames[0]
         self.site_meta = site_meta
         self.instrument = instruments.GENERIC_WEATHER_STATION
         self._data = self._read_data()
@@ -176,9 +184,11 @@ class PalaiseauWS(WS):
 
 
 class GranadaWS(WS):
-    def __init__(self, filename: str, site_meta: dict):
+    def __init__(self, filenames: list[str], site_meta: dict):
+        if len(filenames) != 1:
+            raise ValueError
         super().__init__()
-        self.filename = filename
+        self.filename = filenames[0]
         self.site_meta = site_meta
         self.instrument = instruments.GENERIC_WEATHER_STATION
         self._data = self._read_data()
@@ -262,6 +272,94 @@ class GranadaWS(WS):
         )  # mm -> m
 
 
+class KenttarovaWS(WS):
+    def __init__(self, filenames: list[str], site_meta: dict):
+        super().__init__()
+        self.filenames = filenames
+        self.site_meta = site_meta
+        self.instrument = instruments.GENERIC_WEATHER_STATION
+        self._data = self._read_data()
+
+    def _read_data(self) -> dict:
+        merged: dict = {}
+        for filename in self.filenames:
+            with open(filename, newline="") as f:
+                reader = csv.DictReader(f)
+                raw_data: dict = {key: [] for key in reader.fieldnames}  # type: ignore[union-attr]
+                for row in reader:
+                    for key, value in row.items():
+                        parsed_value: float | datetime.datetime
+                        if key == "Read time (UTC+2)":
+                            parsed_value = datetime.datetime.strptime(
+                                value, "%Y-%m-%d %H:%M:%S"
+                            ) - datetime.timedelta(hours=2)
+                        else:
+                            try:
+                                parsed_value = float(value)
+                            except ValueError:
+                                parsed_value = math.nan
+                        raw_data[key].append(parsed_value)
+            data = {
+                "time": raw_data["Read time (UTC+2)"],
+                "air_temperature": raw_data["Temp 2m (C)"],
+                "relative_humidity": raw_data["Humidity 2m (%)"],
+                "air_pressure": raw_data["Pressure (hPa)"],
+                "wind_speed": raw_data["Wind speed (m/s)"],
+                "wind_direction": raw_data["Wind dir (deg)"],
+                "rainfall_rate": raw_data["Precipitation (?)"],
+            }
+            if merged:
+                merged = {key: [*merged[key], *data[key]] for key in merged}
+            else:
+                merged = data
+        for key, value in merged.items():
+            new_value = np.array(value)
+            if key != "time":
+                new_value = ma.masked_where(np.isnan(new_value), new_value)
+            merged[key] = new_value
+        return merged
+
+    def convert_time(self) -> None:
+        pass
+
+    def screen_timestamps(self, date: str) -> None:
+        dates = [str(d.date()) for d in self._data["time"]]
+        valid_ind = [ind for ind, d in enumerate(dates) if d == date]
+        if not valid_ind:
+            raise ValidTimeStampError
+        for key in self._data:
+            self._data[key] = [
+                x for ind, x in enumerate(self._data[key]) if ind in valid_ind
+            ]
+
+    def add_date(self) -> None:
+        first_date = self._data["time"][0].date()
+        self.date = [
+            str(first_date.year),
+            str(first_date.month).zfill(2),
+            str(first_date.day).zfill(2),
+        ]
+
+    def add_data(self) -> None:
+        for key, value in self._data.items():
+            parsed = datetime2decimal_hours(value) if key == "time" else ma.array(value)
+            self.data[key] = CloudnetArray(parsed, key)
+        self.data["rainfall_amount"] = CloudnetArray(
+            ma.cumsum(self._data["rainfall_rate"]), "rainfall_amount"
+        )
+
+    def convert_units(self) -> None:
+        temperature_kelvins = atmos_utils.c2k(self.data["air_temperature"][:])
+        self.data["air_temperature"].data = temperature_kelvins
+        self.data["relative_humidity"].data = self.data["relative_humidity"][:] / 100
+        self.data["air_pressure"].data = self.data["air_pressure"][:] * 100  # hPa -> Pa
+        rainfall_rate = self.data["rainfall_rate"][:]
+        self.data["rainfall_rate"].data = rainfall_rate / 60 / 1000  # mm/min -> m/s
+        self.data["rainfall_amount"].data = (
+            self.data["rainfall_amount"][:] / 1000
+        )  # mm -> m
+
+
 ATTRIBUTES = {
     "rainfall_amount": MetaData(
         long_name="Rainfall amount",

cloudnetpy/products/classification.py

@@ -2,7 +2,7 @@
 import numpy as np
 from numpy import ma
 
-from cloudnetpy import output
+from cloudnetpy import output, utils
 from cloudnetpy.categorize import atmos
 from cloudnetpy.datasource import DataSource
 from cloudnetpy.metadata import MetaData
@@ -140,35 +140,38 @@ COMMENTS = {
 }
 
 DEFINITIONS = {
-    "target_classification": (
-        "\n"
-        "Value 0: Clear sky.\n"
-        "Value 1: Cloud liquid droplets only.\n"
-        "Value 2: Drizzle or rain.\n"
-        "Value 3: Drizzle or rain coexisting with cloud liquid droplets.\n"
-        "Value 4: Ice particles.\n"
-        "Value 5: Ice coexisting with supercooled liquid droplets.\n"
-        "Value 6: Melting ice particles.\n"
-        "Value 7: Melting ice particles coexisting with cloud liquid droplets.\n"
-        "Value 8: Aerosol particles, no cloud or precipitation.\n"
-        "Value 9: Insects, no cloud or precipitation.\n"
-        "Value 10: Aerosol coexisting with insects, no cloud or precipitation."
+    "target_classification": utils.status_field_definition(
+        {
+            0: "Clear sky.",
+            1: "Cloud liquid droplets only.",
+            2: "Drizzle or rain.",
+            3: "Drizzle or rain coexisting with cloud liquid droplets.",
+            4: "Ice particles.",
+            5: "Ice coexisting with supercooled liquid droplets.",
+            6: "Melting ice particles.",
+            7: "Melting ice particles coexisting with cloud liquid droplets.",
+            8: "Aerosol particles, no cloud or precipitation.",
+            9: "Insects, no cloud or precipitation.",
+            10: "Aerosol coexisting with insects, no cloud or precipitation.",
+        }
     ),
-    "detection_status": (
-        "\n"
-        "Value 0: Clear sky.\n"
-        "Value 1: Lidar echo only.\n"
-        "Value 2: Radar echo but reflectivity may be unreliable as attenuation\n"
-        "         by rain, melting ice or liquid cloud has not been corrected.\n"
-        "Value 3: Good radar and lidar echos.\n"
-        "Value 4: No radar echo but rain or liquid cloud beneath mean that\n"
-        "         attenuation that would be experienced is unknown.\n"
-        "Value 5: Good radar echo only.\n"
-        "Value 6: No radar echo but known attenuation.\n"
-        "Value 7: Radar echo corrected for liquid attenuation using microwave\n"
-        "         radiometer data.\n"
-        "Value 8: Radar ground clutter.\n"
-        "Value 9: Lidar clear-air molecular scattering."
+    "detection_status": utils.status_field_definition(
+        {
+            0: """Clear sky.""",
+            1: """Lidar echo only.""",
+            2: """Radar echo but reflectivity may be unreliable as attenuation
+                  by rain, melting ice or liquid cloud has not been
+                  corrected.""",
+            3: """Good radar and lidar echos.""",
+            4: """No radar echo but rain or liquid cloud beneath mean that
+                  attenuation that would be experienced is unknown.""",
+            5: """Good radar echo only.""",
+            6: """No radar echo but known attenuation.""",
+            7: """Radar echo corrected for liquid attenuation using microwave
+                  radiometer data.""",
+            8: """Radar ground clutter.""",
+            9: """Lidar clear-air molecular scattering.""",
+        }
     ),
 }
 

cloudnetpy/products/der.py

@@ -225,16 +225,17 @@ class DerSource(DataSource):
 
 
 DEFINITIONS = {
-    "der_retrieval_status": (
-        "\n"
-        "Value 0: No data: No cloud observed.\n"
-        "Value 1: Reliable retrieval.\n"
-        "Value 2: Mix of drops and ice: Droplets and ice crystals coexist within\n"
-        "pixel. Z may be biased by large crystals.\n"
-        "Value 3: Precipitation in profile: Drizzle and rain affects LWP retrieval\n"
-        "         of MWR but also the target reflectivity.\n"
-        "Value 4: Surrounding ice: Less crucial! Ice crystals in the vicinity of a\n"
-        "         droplet pixel may also bias its reflectivity.\n"
+    "der_retrieval_status": utils.status_field_definition(
+        {
+            0: """No data: No cloud observed.""",
+            1: """Reliable retrieval.""",
+            2: """Mix of drops and ice: Droplets and ice crystals coexist within
+                  pixel. Z may be biased by large crystals.""",
+            3: """Precipitation in profile: Drizzle and rain affects LWP
+                  retrieval of MWR but also the target reflectivity.""",
+            4: """Surrounding ice: Less crucial! Ice crystals in the vicinity of
+                  a droplet pixel may also bias its reflectivity.""",
+        }
     ),
 }
 

cloudnetpy/products/ier.py

@@ -130,23 +130,26 @@ COMMENTS = {
 }
 
 DEFINITIONS = {
-    "ier_retrieval_status": (
-        "\n"
-        "Value 0: No ice present.\n"
-        "Value 1: Reliable retrieval.\n"
-        "Value 2: Unreliable retrieval due to uncorrected attenuation from liquid\n"
-        "         water below the ice (no liquid water path measurement available).\n"
-        "Value 3: Retrieval performed but radar corrected for liquid attenuation\n"
-        "         using radiometer liquid water path which is not always accurate.\n"
-        "Value 4: Ice detected only by the lidar.\n"
-        "Value 5: Ice detected by radar but rain below so no retrieval performed\n"
-        "         due to very uncertain attenuation.\n"
-        "Value 6: Clear sky above rain wet-bulb temperature less than 0degC: if\n"
-        "         rain attenuation were strong then ice could be present but\n"
-        "         undetected."
-        "Value 7: Drizzle or rain that would have been classified as ice if\n"
-        "          the wet-bulb temperature were less than 0degC: may be ice\n"
-        "          if temperature is in error."
+    "ier_retrieval_status": utils.status_field_definition(
+        {
+            0: """No ice present.""",
+            1: """Reliable retrieval.""",
+            2: """Unreliable retrieval due to uncorrected attenuation from
+                  liquid water below the ice (no liquid water path measurement
+                  available).""",
+            3: """Retrieval performed but radar corrected for liquid attenuation
+                  using radiometer liquid water path which is not always
+                  accurate.""",
+            4: """Ice detected only by the lidar.""",
+            5: """Ice detected by radar but rain below so no retrieval performed
+                  due to very uncertain attenuation.""",
+            6: """Clear sky above rain wet-bulb temperature less than 0degC: if
+                  rain attenuation were strong then ice could be present but
+                  undetected.""",
+            7: """Drizzle or rain that would have been classified as ice if the
+                  wet-bulb temperature were less than 0degC: may be ice if
+                  temperature is in error.""",
+        }
     ),
 }
 

cloudnetpy/products/iwc.py

@@ -170,22 +170,26 @@ COMMENTS = {
 }
 
 DEFINITIONS = {
-    "iwc_retrieval_status": (
-        "\n"
-        "Value 0: No ice present.\n"
-        "Value 1: Reliable retrieval.\n"
-        "Value 2: Unreliable retrieval due to uncorrected attenuation from liquid\n"
-        "         water below the ice (no liquid water path measurement available).\n"
-        "Value 3: Retrieval performed but radar corrected for liquid attenuation\n"
-        "         using radiometer liquid water path which is not always accurate.\n"
-        "Value 4: Ice detected only by the lidar.\n"
-        "Value 5: Ice detected by radar but rain below so no retrieval performed\n"
-        "         due to very uncertain attenuation.\n"
-        "Value 6: Clear sky above rain and wet-bulb temperature less than 0degC:\n"
-        "         if rain attenuation is strong, ice could be present but undetected.\n"
-        "Value 7: Drizzle or rain that would have been classified as ice if the\n"
-        "         wet-bulb temperature were less than 0degC: may be ice if\n"
-        "         temperature is in error."
+    "iwc_retrieval_status": utils.status_field_definition(
+        {
+            0: """No ice present.""",
+            1: """Reliable retrieval.""",
+            2: """Unreliable retrieval due to uncorrected attenuation from
+                  liquid water below the ice (no liquid water path measurement
+                  available).""",
+            3: """Retrieval performed but radar corrected for liquid attenuation
+                  using radiometer liquid water path which is not always
+                  accurate.""",
+            4: """Ice detected only by the lidar.""",
+            5: """Ice detected by radar but rain below so no retrieval performed
+                  due to very uncertain attenuation.""",
+            6: """Clear sky above rain and wet-bulb temperature less than 0degC:
+                  if rain attenuation is strong, ice could be present but
+                  undetected.""",
+            7: """Drizzle or rain that would have been classified as ice if the
+                  wet-bulb temperature were less than 0degC: may be ice if
+                  temperature is in error.""",
+        }
     ),
 }
 

cloudnetpy/products/lwc.py

@@ -414,24 +414,25 @@ COMMENTS = {
 }
 
 DEFINITIONS = {
-    "lwc_retrieval_status": (
-        "\n"
-        "Value 0: No liquid water detected.\n"
-        "Value 1: Reliable retrieval.\n"
-        "Value 2: Adiabatic retrieval where cloud top has been adjusted to match\n"
-        "         liquid water path from microwave radiometer because layer is not\n"
-        "         detected by radar."
-        "Value 3: Adiabatic retrieval: new cloud pixels where cloud top has been\n"
-        "         adjusted to match liquid water path from microwave radiometer\n"
-        "         because layer is not detected by radar.\n"
-        "Value 4: No retrieval: either no liquid water path is available or liquid\n"
-        "          water path is uncertain.\n"
-        "Value 5: No retrieval: liquid water layer detected only by the lidar and\n"
-        "         liquid water path is unavailable or uncertain: cloud top may be\n"
-        "         higher than diagnosed cloud top since lidar signal has been\n"
-        "         attenuated."
-        "Value 6: Rain present: cloud extent is difficult to ascertain and liquid\n"
-        "         water path also uncertain."
+    "lwc_retrieval_status": utils.status_field_definition(
+        {
+            0: """No liquid water detected.""",
+            1: """Reliable retrieval.""",
+            2: """Adiabatic retrieval where cloud top has been adjusted to match
+                  liquid water path from microwave radiometer because layer is
+                  not detected by radar.""",
+            3: """Adiabatic retrieval: new cloud pixels where cloud top has been
+                  adjusted to match liquid water path from microwave radiometer
+                  because layer is not detected by radar.""",
+            4: """No retrieval: either no liquid water path is available or
+                  liquid water path is uncertain.""",
+            5: """No retrieval: liquid water layer detected only by the lidar
+                  and liquid water path is unavailable or uncertain: cloud top
+                  may be higher than diagnosed cloud top since lidar signal has
+                  been attenuated.""",
+            6: """Rain present: cloud extent is difficult to ascertain and
+                  liquid water path also uncertain.""",
+        }
     ),
 }
 

cloudnetpy/utils.py

@@ -3,11 +3,12 @@ import datetime
 import logging
 import os
 import re
+import textwrap
 import uuid
 import warnings
 from collections.abc import Iterator
 from datetime import timezone
-from typing import Literal
+from typing import Literal, TypeVar
 
 import netCDF4
 import numpy as np
@@ -995,3 +996,25 @@ def find_masked_profiles_indices(array: ma.MaskedArray) -> list:
     non_masked_counts = np.ma.count(array, axis=1)
     masked_profiles_indices = np.where(non_masked_counts == 0)[0]
     return list(masked_profiles_indices)
+
+
+T = TypeVar("T", int, str)
+
+
+def _format_definition(kind: str, definitions: dict[T, str]) -> str:
+    lines = [""]
+    for key, value in definitions.items():
+        prefix = f"{kind} {key}: "
+        indent = " " * len(prefix)
+        text = " ".join(value.split())
+        wrapped = textwrap.wrap(prefix + text, subsequent_indent=indent)
+        lines.extend(wrapped)
+    return "\n".join(lines)
+
+
+def status_field_definition(definitions: dict[T, str]) -> str:
+    return _format_definition("Value", definitions)
+
+
+def bit_field_definition(definitions: dict[T, str]) -> str:
+    return _format_definition("Bit", definitions)

cloudnetpy/version.py

@@ -1,4 +1,4 @@
 MAJOR = 1
 MINOR = 61
-PATCH = 7
+PATCH = 9
 __version__ = f"{MAJOR}.{MINOR}.{PATCH}"

{cloudnetpy-1.61.7.dist-info → cloudnetpy-1.61.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cloudnetpy
-Version: 1.61.7
+Version: 1.61.9
 Summary: Python package for Cloudnet processing
 Author: Simo Tukiainen
 License: MIT License

{cloudnetpy-1.61.7.dist-info → cloudnetpy-1.61.9.dist-info}/RECORD

@@ -7,12 +7,12 @@ cloudnetpy/exceptions.py,sha256=wrI0bZTwmS5C_cqOmvlJ8XJSEFyzuD1eD4voGJc_Gjg,1584
 cloudnetpy/metadata.py,sha256=v_VDo2vbdTxB0zIsfP69IcrwSKiRlLpsGdq6JPI4CoA,5306
 cloudnetpy/output.py,sha256=WoVTNuxni0DUr163vZ-_mDr1brXhY15XSlGMrq9Aoqw,14700
 cloudnetpy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cloudnetpy/utils.py,sha256=DuUbtGJJTwEwrDxx6aLkos4qL-Lrdchnzjx4gv5dZiU,27814
-cloudnetpy/version.py,sha256=kTFWe1O0uMTPg6LtGazqdKp2KOo0w7j9KaWIUOArJx4,72
+cloudnetpy/utils.py,sha256=-8x7LQ6WDHxf2lDZfhG50WYe2iSVLQObnVXZG46JzKI,28468
+cloudnetpy/version.py,sha256=jCiBK4tcMrQYXPVaBsEM_6y-SUJGsVWPfbgo81jYpFg,72
 cloudnetpy/categorize/__init__.py,sha256=gP5q3Vis1y9u9OWgA_idlbjfWXYN_S0IBSWdwBhL_uU,69
 cloudnetpy/categorize/atmos.py,sha256=fWW8ye_8HZASRAiYwURFKWzcGOYIA2RKeVxCq0lVOuM,12389
 cloudnetpy/categorize/atmos_utils.py,sha256=wndpwJxc2-QnNTkV8tc8I11Vs_WkNz9sVMX1fuGgUC4,3777
-cloudnetpy/categorize/categorize.py,sha256=p3LLBXSu5AOMrJWwAZeS6J-Xzh4PkXuPmOCZiEHzt2w,17678
+cloudnetpy/categorize/categorize.py,sha256=cIuspjg76h99Czf0XICpjflZGzmfyUH8LYGGgnbaBM8,17826
 cloudnetpy/categorize/classify.py,sha256=x7aqPfhw4xuER22sqOb9ES9nijwk1E8b7HF7uaFJD7k,9218
 cloudnetpy/categorize/containers.py,sha256=j6oSKPeZcq9vFthYaocAw1m6yReRNNPYUQF5UTDq4YM,4232
 cloudnetpy/categorize/disdrometer.py,sha256=daPB1JgERRqa0Ekxx_LYCP8mDe3XnUYj2VlsIKAB7sE,2003
@@ -28,7 +28,7 @@ cloudnetpy/categorize/radar.py,sha256=oaptBCymSPTa1HNYOWURnE0h5oklDOVxQvqAEAbqSQ
 cloudnetpy/instruments/__init__.py,sha256=_jejVwi_viSZehmAOkEqTNI-0-exGgAJ_bHW1IRRwTI,398
 cloudnetpy/instruments/basta.py,sha256=0zUztUJBXT2nrBTAl3-NLowxu_CYwTU5TgdBq4etj7E,3757
 cloudnetpy/instruments/campbell_scientific.py,sha256=2WHfBKQjtRSl0AqvtPeX7G8Hdi3Dn0WbvoAppFOMbA8,5270
-cloudnetpy/instruments/ceilo.py,sha256=56zhNSx5cyqV9ToeDUhXzwOUQK32oa9Vng2VsPXLsmM,8876
+cloudnetpy/instruments/ceilo.py,sha256=ZDMrHHGYrboJMC2YMU9E1XsBAPI2eYoovrEsF1fUaRE,8922
 cloudnetpy/instruments/ceilometer.py,sha256=-aPEZs_r0Gxeu53PHeWAkZMB2BUdauS47tkL7RFxo6k,12078
 cloudnetpy/instruments/cl61d.py,sha256=ycJGvUqNU2KHhECbrSehtWRnvg1vKFHhvMeQpjpdCI4,1989
 cloudnetpy/instruments/cloudnet_instrument.py,sha256=RG5HJxGM6p0F-IGyr85fvOizcMmgx48OeD_XeIsrgSU,3367
@@ -43,11 +43,11 @@ cloudnetpy/instruments/nc_lidar.py,sha256=Q4sJJwiEPthDz0Zb-laISX32jNYzlUBMafxLJi
 cloudnetpy/instruments/nc_radar.py,sha256=cDd20Yz-UeDQp1Gmkk-jGNZ45DangFsCaioeo_kktHQ,6935
 cloudnetpy/instruments/pollyxt.py,sha256=SccV9htZ5MWrK7JEleOr4hbmeTr-lKktUzAt7H9Xkf8,8932
 cloudnetpy/instruments/radiometrics.py,sha256=2ofeZ6KJ_JOWTd3UA-wSzJpM5cjN7R4jZeBLJCQKEYc,7624
-cloudnetpy/instruments/rpg.py,sha256=U8nEOlOI74f2lk2w4C4xKZCrW6AkDZpQZYE3yv7SNHE,17130
+cloudnetpy/instruments/rpg.py,sha256=yQpcKcgzRvVvkl6NhKvo4PUkv9nZ69_hzzPpS2Ei-Is,17315
 cloudnetpy/instruments/rpg_reader.py,sha256=LAdXL3TmD5QzQbqtPOcemZji_qkXwmw6a6F8NmF6Zg8,11355
 cloudnetpy/instruments/toa5.py,sha256=1JnuYViD8c_tHJZ9lf4OU44iepEkXHsXOzDfVf_b0qc,1759
-cloudnetpy/instruments/vaisala.py,sha256=GzESZvboOoXzWmmr9dC-y6oM6ogc-M-zT3KmBTaD0LI,14512
-cloudnetpy/instruments/weather_station.py,sha256=0ajUvZ4BQIr_HXwBgEek2rf3Oorqp4L-t95gIUVK9vM,9650
+cloudnetpy/instruments/vaisala.py,sha256=ektdXoID2X_V9H5Zp1fgHTUBapFMSyPVEWW_aoR6DEY,14655
+cloudnetpy/instruments/weather_station.py,sha256=76O3z1932Bidi_1tXHeVJmtoISOJFKB9vFVJnWJj4M0,13822
 cloudnetpy/instruments/disdrometer/__init__.py,sha256=lyjwttWvFvuwYxEkusoAvgRcbBmglmOp5HJOpXUqLWo,93
 cloudnetpy/instruments/disdrometer/common.py,sha256=g52iK2aNp3Z88kovUmGVpC54NZomPa9D871gzO0AmQ4,9267
 cloudnetpy/instruments/disdrometer/parsivel.py,sha256=WiL-vCjw9Gmb5irvW3AXddsyprp8MGOfqcVAlfy0zpc,25521
@@ -96,20 +96,20 @@ cloudnetpy/plotting/__init__.py,sha256=lg9Smn4BI0dVBgnDLC3JVJ4GmwoSnO-qoSd4ApvwV
 cloudnetpy/plotting/plot_meta.py,sha256=cLdCZrhbP-gaobS_zjcf8d2xVALzl7zh2qpttxCHyrg,15983
 cloudnetpy/plotting/plotting.py,sha256=bve91iM9RcWmKaZOFWxVh2y3DPmupI1944MMYDdv17I,32459
 cloudnetpy/products/__init__.py,sha256=2hRb5HG9hNrxH1if5laJkLeFeaZCd5W1q3hh4ewsX0E,273
-cloudnetpy/products/classification.py,sha256=0E9OUGR3uLCsS1nORwQu0SqW0_8uX7n6LlRcVhtzKw4,7845
-cloudnetpy/products/der.py,sha256=mam6jWV7A2h8V5WC3DIeFp6ou7UD1JOw9r7h2B0su-s,12403
+cloudnetpy/products/classification.py,sha256=pzFQtgOKS7g_3LqiAY84EFUUste-VES7CJNgoq2Bs34,7914
+cloudnetpy/products/der.py,sha256=XZMbqDQUq0E9iBU3Axr-NfUJfRAhjsaGlyxJ4tKyGcw,12444
 cloudnetpy/products/drizzle.py,sha256=BY2HvJeWt_ps6KKCGXwUUNRTy78q0cQM8bOCCoj8TWA,10803
 cloudnetpy/products/drizzle_error.py,sha256=4GwlHRtNbk9ks7bGtXCco-wXbcDOKeAQwKmbhzut6Qk,6132
 cloudnetpy/products/drizzle_tools.py,sha256=UhcJbPa4tXHbuVlegIRfOl5nZ_E6ddKv20aghfP0hdg,10847
-cloudnetpy/products/ier.py,sha256=IcGPlQahbwJjp3vOOrxWSYW2FPzbSV0KQL5eYECc4kU,7777
-cloudnetpy/products/iwc.py,sha256=MUPuVKWgqOuuLRCGk3QY74uBZB_7P1qlinlP8nEvz9o,10124
-cloudnetpy/products/lwc.py,sha256=TbIR6kMwjbm63ed5orB1pkqx9ZBm8C5TF2JmT8WKdKI,18794
+cloudnetpy/products/ier.py,sha256=ZwjyRwh7dJPjz9K5x1HiLFyD0BDNsFx-B7zBAds_ACs,7838
+cloudnetpy/products/iwc.py,sha256=kdYvOy2-xwY1Qnx8qdyGAhAjMJowh23Iv1JNuNxXNLA,10206
+cloudnetpy/products/lwc.py,sha256=FOc-dYKM_OTLN1PK9yfApKiKCJYSv82BLPwXJqO2Bqo,18815
 cloudnetpy/products/mie_lu_tables.nc,sha256=It4fYpqJXlqOgL8jeZ-PxGzP08PMrELIDVe55y9ob58,16637951
 cloudnetpy/products/mwr_tools.py,sha256=RuzokxxqXlTGk7XAOrif_FDPUJdf0j_wJgNq-7a_nK8,4684
 cloudnetpy/products/product_tools.py,sha256=rhx_Ru9FLlQqCNM-awoiHx18-Aq1eBwL9LiUaQoJs6k,10412
 docs/source/conf.py,sha256=IKiFWw6xhUd8NrCg0q7l596Ck1d61XWeVjIFHVSG9Og,1490
-cloudnetpy-1.61.7.dist-info/LICENSE,sha256=wcZF72bdaoG9XugpyE95Juo7lBQOwLuTKBOhhtANZMM,1094
-cloudnetpy-1.61.7.dist-info/METADATA,sha256=FcyxQIL3n-BVcQGqXwfpT51ahxWRkCEfcuADunGOQ6U,5784
-cloudnetpy-1.61.7.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-cloudnetpy-1.61.7.dist-info/top_level.txt,sha256=ibSPWRr6ojS1i11rtBFz2_gkIe68mggj7aeswYfaOo0,16
-cloudnetpy-1.61.7.dist-info/RECORD,,
+cloudnetpy-1.61.9.dist-info/LICENSE,sha256=wcZF72bdaoG9XugpyE95Juo7lBQOwLuTKBOhhtANZMM,1094
+cloudnetpy-1.61.9.dist-info/METADATA,sha256=-rbU3tJCXKfgY_2BcIqFh0Ryw9R7rHXhURpuPabJXLQ,5784
+cloudnetpy-1.61.9.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+cloudnetpy-1.61.9.dist-info/top_level.txt,sha256=ibSPWRr6ojS1i11rtBFz2_gkIe68mggj7aeswYfaOo0,16
+cloudnetpy-1.61.9.dist-info/RECORD,,