cloudnetpy 1.71.3__py3-none-any.whl → 1.71.5__py3-none-any.whl

cloudnetpy/instruments/ceilo.py

@@ -6,10 +6,9 @@ import netCDF4
 from numpy import ma
 
 from cloudnetpy import output, utils
-from cloudnetpy.instruments.campbell_scientific import Cs135
 from cloudnetpy.instruments.cl61d import Cl61d
 from cloudnetpy.instruments.lufft import LufftCeilo
-from cloudnetpy.instruments.vaisala import ClCeilo, Ct25k
+from cloudnetpy.instruments.vaisala import ClCeilo, Cs135, Ct25k
 from cloudnetpy.metadata import MetaData
 
 

cloudnetpy/instruments/hatpro.py

@@ -103,6 +103,8 @@ def hatpro2l1c(
 
     if "ir_wavelength" in hatpro.data:
         hatpro.data["ir_wavelength"].dimensions = ("ir_channel",)
+    if "irt" in hatpro.data:
+        hatpro.data["irt"].dimensions = ("time", "ir_channel")
 
     for key in ("latitude", "longitude", "altitude"):
         if key in site_meta:

cloudnetpy/instruments/vaisala.py

@@ -1,405 +1,130 @@
 """Module with classes for Vaisala ceilometers."""
 
-import itertools
-import logging
+import datetime
+from collections.abc import Callable
 
+import ceilopyter.version
 import numpy as np
+import numpy.typing as npt
+from ceilopyter import read_cl_file, read_cs_file, read_ct_file
 
-from cloudnetpy import utils
-from cloudnetpy.constants import SEC_IN_HOUR, SEC_IN_MINUTE
 from cloudnetpy.exceptions import ValidTimeStampError
 from cloudnetpy.instruments import instruments
 from cloudnetpy.instruments.ceilometer import Ceilometer, NoiseParam
 
-M2KM = 0.001
-
 
 class VaisalaCeilo(Ceilometer):
     """Base class for Vaisala ceilometers."""
 
     def __init__(
         self,
+        reader: Callable,
         full_path: str,
         site_meta: dict,
         expected_date: str | None = None,
     ):
         super().__init__(self.noise_param)
+        self.reader = reader
         self.full_path = full_path
         self.site_meta = site_meta
         self.expected_date = expected_date
-        self._backscatter_scale_factor = 1.0
-        self._hex_conversion_params: tuple[int, int, int] = (1, 1, 1)
-        self._message_number: int
-
-    def _is_ct25k(self) -> bool:
-        if self.instrument is not None and self.instrument.model is not None:
-            return "CT25k" in self.instrument.model
-        return False
-
-    def _fetch_data_lines(self) -> list:
-        """Finds data lines (header + backscatter) from ceilometer file."""
-        with open(self.full_path, "rb") as file:
-            all_lines = file.readlines()
-        return self._screen_invalid_lines(all_lines)
-
-    def _calc_range(self) -> np.ndarray:
-        """Calculates range vector from the resolution and number of gates."""
-        if self._is_ct25k():
-            range_resolution = 30
-            n_gates = 256
-        else:
-            n_gates = int(self.metadata["number_of_gates"])
-            range_resolution = int(self.metadata["range_resolution"])
-        return np.arange(n_gates) * range_resolution + range_resolution / 2
-
-    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 = 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:
-                logging.warning("Bad value in raw ceilometer data")
-        ind = profiles & self._hex_conversion_params[1] != 0
-        profiles[ind] -= self._hex_conversion_params[2]
-        return profiles.astype(float) / self._backscatter_scale_factor
-
-    def _screen_invalid_lines(self, data_in: list) -> list:
-        """Removes empty (and other weird) lines from the list of data."""
-
-        def _filter_lines(data: list) -> list:
-            output = []
-            for line in data:
-                try:
-                    output.append(line.decode("utf8"))
-                except UnicodeDecodeError:
-                    continue
-            return output
-
-        def _find_timestamp_line_numbers(data: list) -> list:
-            return [n for n, value in enumerate(data) if utils.is_timestamp(value)]
-
-        def _find_correct_dates(data: list, line_numbers: list) -> list:
-            return [
-                n for n in line_numbers if data[n].strip("-")[:10] == self.expected_date
-            ]
-
-        def _find_number_of_data_lines(data: list, timestamp_line_number: int) -> int:
-            for i, line in enumerate(data[timestamp_line_number:]):
-                if utils.is_empty_line(line):
-                    return i
-            msg = "Can not parse number of data lines"
-            raise RuntimeError(msg)
-
-        def _parse_data_lines(data: list, starting_indices: list) -> list:
-            iterator = range(number_of_data_lines)
-            n_lines = max(iterator)
-            return [
-                [
-                    data[n + line_number]
-                    for n in starting_indices
-                    if (n + n_lines) < len(data)
-                ]
-                for line_number in iterator
-            ]
-
-        valid_lines = _filter_lines(data_in)
-        timestamp_line_numbers = _find_timestamp_line_numbers(valid_lines)
-        if self.expected_date is not None:
-            timestamp_line_numbers = _find_correct_dates(
-                valid_lines,
-                timestamp_line_numbers,
-            )
-            if not timestamp_line_numbers:
-                raise ValidTimeStampError
-        number_of_data_lines = _find_number_of_data_lines(
-            valid_lines,
-            timestamp_line_numbers[0],
+        self.sane_date = (
+            datetime.date.fromisoformat(self.expected_date)
+            if self.expected_date
+            else None
         )
-        return _parse_data_lines(valid_lines, timestamp_line_numbers)
-
-    @staticmethod
-    def _get_message_number(header_line_1: dict) -> int:
-        msg_no = header_line_1["message_number"]
-        if len(np.unique(msg_no)) != 1:
-            msg = "Error: inconsistent message numbers."
-            raise RuntimeError(msg)
-        return int(msg_no[0])
-
-    @staticmethod
-    def _calc_time(time_lines: list) -> np.ndarray:
-        """Returns the time vector as fraction hour."""
-        time = [time_to_fraction_hour(line.split()[1]) for line in time_lines]
-        return np.array(time)
-
-    @staticmethod
-    def _calc_date(time_lines) -> list:
-        """Returns the date [yyyy, mm, dd]."""
-        return time_lines[0].split()[0].strip("-").split("-")
-
-    @classmethod
-    def _handle_metadata(cls, header: list) -> dict:
-        meta = cls._concatenate_meta(header)
-        meta = cls._remove_meta_duplicates(meta)
-        return cls._convert_meta_strings(meta)
-
-    @staticmethod
-    def _concatenate_meta(header: list) -> dict:
-        meta = {}
-        for head in header:
-            meta.update(head)
-        return meta
-
-    @staticmethod
-    def _remove_meta_duplicates(meta: dict) -> dict:
-        for field in meta:
-            if len(np.unique(meta[field])) == 1:
-                meta[field] = meta[field][0]
-        return meta
+        self.software = {"ceilopyter": ceilopyter.version.__version__}
 
-    @staticmethod
-    def _convert_meta_strings(meta: dict) -> dict:
-        strings = (
-            "cloud_base_data",
-            "measurement_parameters",
-            "cloud_amount_data",
-        )
-        for field in meta:
-            if field in strings:
-                continue
-            values = meta[field]
-            if isinstance(values, str):  # only one unique value
-                try:
-                    meta[field] = int(values)
-                except (ValueError, TypeError):
-                    continue
-            else:
-                meta[field] = [None] * len(values)
-                for ind, value in enumerate(values):
-                    try:
-                        meta[field][ind] = int(value)
-                    except (ValueError, TypeError):
-                        continue
-                meta[field] = np.array(meta[field])
-        return meta
-
-    def _read_common_header_part(self) -> tuple[list, list]:
-        header = []
-        data_lines = self._fetch_data_lines()
-        self.data["time"] = self._calc_time(data_lines[0])
-        self.date = self._calc_date(data_lines[0])
-        header.append(self._read_header_line_1(data_lines[1]))
-        self._message_number = self._get_message_number(header[0])
-        header.append(self._read_header_line_2(data_lines[2]))
-        return header, data_lines
-
-    def _read_header_line_1(self, lines: list) -> dict:
-        """Reads all first header lines from CT25k and CL ceilometers."""
-        fields = (
-            "model_id",
-            "unit_id",
-            "software_level",
-            "message_number",
-            "message_subclass",
-        )
-        indices = [1, 3, 4, 6, 7, 8] if self._is_ct25k() else [1, 3, 4, 7, 8, 9]
-        values = [split_string(line, indices) for line in lines]
-        return values_to_dict(fields, values)
-
-    @staticmethod
-    def _read_header_line_2(lines: list) -> dict:
-        """Reads the second header line."""
-        fields = (
-            "detection_status",
-            "warning",
-            "cloud_base_data",
-            "warning_flags",
-        )
-        values = [[line[0], line[1], line[3:20], line[21:].strip()] for line in lines]
-        return values_to_dict(fields, values)
+    def read_ceilometer_file(self, calibration_factor: float | None = None) -> None:
+        """Read all lines of data from the file."""
+        time, data = self.reader(self.full_path)
+        range_res = data[0].range_resolution
+        n_gates = len(data[0].beta)
+        self.data["time"] = np.array(time)
+        self.data["range"] = np.arange(n_gates) * range_res + range_res / 2
+        self.data["beta_raw"] = np.stack([d.beta for d in data])
+        self.data["calibration_factor"] = calibration_factor or 1.0
+        self.data["beta_raw"] *= self.data["calibration_factor"]
+        self.data["zenith_angle"] = np.median([d.tilt_angle for d in data])
+        self._sort_time()
+        self._screen_date()
+        self._convert_to_fraction_hour()
+        self._store_ceilometer_info()
 
-    def _sort_time(self) -> None:
+    def _sort_time(self):
         """Sorts timestamps and removes duplicates."""
-        time = np.copy(self.data["time"][:])
-        ind_sorted = np.argsort(time)
-        ind_valid: list[int] = []
-        for ind in ind_sorted:
-            if time[ind] not in time[ind_valid]:
-                ind_valid.append(ind)
+        time = self.data["time"]
+        _time, ind = np.unique(time, return_index=True)
+        self._screen_time_indices(ind)
+
+    def _screen_date(self):
+        time = self.data["time"]
+        if self.sane_date is None:
+            self.sane_date = time[0].date()
+            self.expected_date = self.sane_date.isoformat()
+        is_valid = np.array([t.date() == self.sane_date for t in time])
+        self._screen_time_indices(is_valid)
+
+    def _screen_time_indices(
+        self, valid_indices: npt.NDArray[np.intp] | npt.NDArray[np.bool]
+    ):
+        time = self.data["time"]
         n_time = len(time)
+        if len(valid_indices) == 0 or (
+            valid_indices.dtype == np.bool and not np.any(valid_indices)
+        ):
+            msg = "All timestamps screened"
+            raise ValidTimeStampError(msg)
         for key, array in self.data.items():
-            if not hasattr(array, "shape"):
-                continue
-            if array.ndim == 1 and array.shape[0] == n_time:
-                self.data[key] = self.data[key][ind_valid]
-            if array.ndim == 2 and array.shape[0] == n_time:
-                self.data[key] = self.data[key][ind_valid, :]
+            if hasattr(array, "shape") and array.shape[:1] == (n_time,):
+                self.data[key] = self.data[key][valid_indices]
+
+    def _convert_to_fraction_hour(self):
+        time = self.data["time"]
+        midnight = time[0].replace(hour=0, minute=0, second=0, microsecond=0)
+        hour = datetime.timedelta(hours=1)
+        self.data["time"] = (time - midnight) / hour
+        self.date = self.expected_date.split("-")  # type: ignore[union-attr]
+
+    def _store_ceilometer_info(self):
+        raise NotImplementedError
 
 
 class ClCeilo(VaisalaCeilo):
-    """Base class for Vaisala CL31/CL51 ceilometers."""
+    """Class for Vaisala CL31/CL51 ceilometers."""
 
     noise_param = NoiseParam(noise_min=3.1e-8, noise_smooth_min=1.1e-8)
 
-    def __init__(
-        self,
-        full_path: str,
-        site_meta: dict,
-        expected_date: str | None = None,
-    ):
-        super().__init__(full_path, site_meta, expected_date)
-        self._hex_conversion_params = (5, 524288, 1048576)
-        self._backscatter_scale_factor = 1e8
-
-    def read_ceilometer_file(self, calibration_factor: float | None = None) -> None:
-        """Read all lines of data from the file."""
-        header, data_lines = self._read_common_header_part()
-        header.append(self._read_header_line_4(data_lines[-3]))
-        self.metadata = self._handle_metadata(header)
-        self.data["range"] = self._calc_range()
-        self.data["beta_raw"] = self._read_backscatter(data_lines[-2])
-        self.data["calibration_factor"] = calibration_factor or 1.0
-        self.data["beta_raw"] *= self.data["calibration_factor"]
-        self.data["zenith_angle"] = np.median(self.metadata["zenith_angle"])
-        self._store_ceilometer_info()
-        self._sort_time()
+    def __init__(self, full_path, site_meta, expected_date=None):
+        super().__init__(read_cl_file, full_path, site_meta, expected_date)
 
-    def _store_ceilometer_info(self) -> None:
+    def _store_ceilometer_info(self):
         n_gates = self.data["beta_raw"].shape[1]
         if n_gates < 1540:
             self.instrument = instruments.CL31
         else:
             self.instrument = instruments.CL51
 
-    def _read_header_line_3(self, lines: list) -> dict:
-        if self._message_number != 2:
-            msg = f"Unsupported message number: {self._message_number}"
-            raise RuntimeError(msg)
-        keys = ("cloud_detection_status", "cloud_amount_data")
-        values = [[line[0:3], line[3:].strip()] for line in lines]
-        return values_to_dict(keys, values)
-
-    @staticmethod
-    def _read_header_line_4(lines: list) -> dict:
-        keys = (
-            "scale",
-            "range_resolution",
-            "number_of_gates",
-            "laser_energy",
-            "laser_temperature",
-            "window_transmission",
-            "zenith_angle",
-            "background_light",
-            "measurement_parameters",
-            "backscatter_sum",
-        )
-        values = [line.split() for line in lines]
-        return values_to_dict(keys, values)
-
 
 class Ct25k(VaisalaCeilo):
-    """Class for Vaisala CT25k ceilometer.
-
-    References:
-        https://www.manualslib.com/manual/1414094/Vaisala-Ct25k.html
-
-    """
+    """Class for Vaisala CT25k ceilometer."""
 
     noise_param = NoiseParam(noise_min=0.7e-7, noise_smooth_min=1.2e-8)
 
-    def __init__(
-        self,
-        input_file: str,
-        site_meta: dict,
-        expected_date: str | None = None,
-    ):
-        super().__init__(input_file, site_meta, expected_date)
-        self._hex_conversion_params = (4, 32768, 65536)
-        self._backscatter_scale_factor = 1e7
-        self.instrument = instruments.CT25K
-
-    def read_ceilometer_file(self, calibration_factor: float | None = None) -> None:
-        """Read all lines of data from the file."""
-        header, data_lines = self._read_common_header_part()
-        header.append(self._read_header_line_3(data_lines[3]))
-        self.metadata = self._handle_metadata(header)
-        self.data["range"] = self._calc_range()
-        hex_profiles = self._parse_hex_profiles(data_lines[4:20])
-        self.data["beta_raw"] = self._read_backscatter(hex_profiles)
-        self.data["calibration_factor"] = calibration_factor or 1.0
-        self.data["beta_raw"] *= self.data["calibration_factor"]
-        self.data["zenith_angle"] = np.median(self.metadata["zenith_angle"])
-        self._sort_time()
-
-    @staticmethod
-    def _parse_hex_profiles(lines: list) -> list:
-        """Collects ct25k profiles into list (one profile / element)."""
-        n_profiles = len(lines[0])
-        return [
-            "".join([lines[m][n][3:].strip() for m in range(16)])
-            for n in range(n_profiles)
-        ]
-
-    def _read_header_line_3(self, lines: list) -> dict:
-        if self._message_number in (1, 3, 6):
-            msg = f"Unsupported message number: {self._message_number}"
-            raise RuntimeError(msg)
-        keys = (
-            "measurement_mode",
-            "laser_energy",
-            "laser_temperature",
-            "receiver_sensitivity",
-            "window_contamination",
-            "zenith_angle",
-            "background_light",
-            "measurement_parameters",
-            "backscatter_sum",
-        )
-        values = [line.split() for line in lines]
-        keys_out = ("scale", *keys) if len(values[0]) == 10 else keys
-        return values_to_dict(keys_out, values)
-
-
-def split_string(string: str, indices: list) -> list:
-    """Splits string between indices.
-
-    Notes:
-        It is possible to skip characters from the beginning and end of the
-        string but not from the middle.
-
-    Examples:
-        >>> s = 'abcde'
-        >>> indices = [1, 2, 4]
-        >>> split_string(s, indices)
-        ['b', 'cd']
-
-    """
-    return [string[n:m] for n, m in itertools.pairwise(indices)]
+    def __init__(self, full_path, site_meta, expected_date=None):
+        super().__init__(read_ct_file, full_path, site_meta, expected_date)
 
+    def _store_ceilometer_info(self):
+        self.instrument = instruments.CT25K
 
-def values_to_dict(keys: tuple, values: list) -> dict:
-    """Converts list elements to dictionary.
 
-    Examples:
-        >>> keys = ('a', 'b')
-        >>> values = [[1, 2], [1, 2], [1, 2], [1, 2]]
-        >>> values_to_dict(keys, values)
-        {'a': array([1, 1, 1, 1]), 'b': array([2, 2, 2, 2])}
+class Cs135(VaisalaCeilo):
+    """Class for Campbell Scientific CS135 ceilometer."""
 
-    """
-    out = {}
-    for i, key in enumerate(keys):
-        out[key] = np.array([x[i] for x in values if len(x) == len(keys)])
-    return out
+    noise_param = NoiseParam()
 
+    def __init__(self, full_path, site_meta, expected_date=None):
+        super().__init__(read_cs_file, full_path, site_meta, expected_date)
 
-def time_to_fraction_hour(time: str) -> float:
-    """Returns time (hh:mm:ss) as fraction hour."""
-    hour, minute, sec = time.split(":")
-    return int(hour) + (int(minute) * SEC_IN_MINUTE + int(sec)) / SEC_IN_HOUR
+    def _store_ceilometer_info(self):
+        self.instrument = instruments.CS135

cloudnetpy/output.py

@@ -44,6 +44,9 @@ def save_level1b(
         nc.source = get_l1b_source(obj.instrument)
         if hasattr(obj, "serial_number") and obj.serial_number is not None:
             nc.serial_number = obj.serial_number
+        if hasattr(obj, "software"):
+            for software, version in obj.software.items():
+                nc.setncattr(f"{software}_version", version)
         nc.references = get_references()
     return file_uuid
 

cloudnetpy/plotting/plotting.py

@@ -199,7 +199,7 @@ class FigureData:
                 if "altitude" not in self.file.variables:
                     msg = "No altitude information in the file."
                     raise ValueError(msg)
-                height -= self.file.variables["altitude"][:]
+                height -= np.median(self.file.variables["altitude"][:])
             return height * con.M_TO_KM
         if "range" in self.file.variables:
             return self.file.variables["range"][:] * con.M_TO_KM

cloudnetpy/version.py

@@ -1,4 +1,4 @@
 MAJOR = 1
 MINOR = 71
-PATCH = 3
+PATCH = 5
 __version__ = f"{MAJOR}.{MINOR}.{PATCH}"

{cloudnetpy-1.71.3.dist-info → cloudnetpy-1.71.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: cloudnetpy
-Version: 1.71.3
+Version: 1.71.5
 Summary: Python package for Cloudnet processing
 Author: Simo Tukiainen
 License: MIT License
@@ -33,14 +33,12 @@ Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Topic :: Scientific/Engineering
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Atmospheric Science
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: ceilopyter
 Requires-Dist: cloudnetpy_qc>=1.15.0
 Requires-Dist: doppy>=0.5.0
 Requires-Dist: matplotlib
@@ -61,6 +59,7 @@ Requires-Dist: pre-commit; extra == "dev"
 Requires-Dist: release-version; extra == "dev"
 Provides-Extra: extras
 Requires-Dist: voodoonet>=0.1.7; extra == "extras"
+Dynamic: license-file
 
 # CloudnetPy
 

{cloudnetpy-1.71.3.dist-info → cloudnetpy-1.71.5.dist-info}/RECORD

@@ -6,10 +6,10 @@ cloudnetpy/constants.py,sha256=YnoSzZm35NDooJfhlulSJBc7g0eSchT3yGytRaTaJEI,845
 cloudnetpy/datasource.py,sha256=FcWS77jz56gIzwnbafDLdj-HjAyu0P_VtY7gkeVZThU,7952
 cloudnetpy/exceptions.py,sha256=hYbUtBwjCIfxnPe_5mELDEw87AWITBrwuo7WYIEKmJ8,1579
 cloudnetpy/metadata.py,sha256=BDEpgwZ58PHznc1gi11gtNNV4kFiMAmlHnF4huTy7nw,5982
-cloudnetpy/output.py,sha256=lq4YSeMT_d-j4rlQkKm9KIZ8boupTBBBKV1eUawpmCI,15672
+cloudnetpy/output.py,sha256=l0LoOhcGCBrg2EJ4NT1xZ7-UKWdV7X7yQ0fJmhkwJVc,15829
 cloudnetpy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cloudnetpy/utils.py,sha256=U0iMIKPiKLrLVAfs_u9pPuoWYW1RJHcM8dbLF9a4yIA,29796
-cloudnetpy/version.py,sha256=tsjo_vDV3Q5KrCVFxMEpgs-KBRK1bdqml45ItHKQVio,72
+cloudnetpy/version.py,sha256=WGC_6FoGDMaIdA18EiKCMGcEd1CCikWt_zPUoQ2yXjs,72
 cloudnetpy/categorize/__init__.py,sha256=s-SJaysvVpVVo5kidiruWQO6p3gv2TXwY1wEHYO5D6I,44
 cloudnetpy/categorize/atmos_utils.py,sha256=RcmbKxm2COkE7WEya0mK3yX5rzUbrewRVh3ekm01RtM,10598
 cloudnetpy/categorize/attenuation.py,sha256=Y_-fzmQTltWTqIZTulJhovC7a6ifpMcaAazDJcnMIOc,990
@@ -34,14 +34,13 @@ cloudnetpy/categorize/attenuations/melting_attenuation.py,sha256=9c9xoZHtGUbjFYJ
 cloudnetpy/categorize/attenuations/rain_attenuation.py,sha256=qazJzRyXf9vbjJhh4yiFmABI4L57j5W_6YZ-6qjRiBI,2839
 cloudnetpy/instruments/__init__.py,sha256=2vAdceXCNxZhTujhArLf4NjYOfUdkhLpGM-NQa_LXdg,470
 cloudnetpy/instruments/basta.py,sha256=Lb_EhQTI93S5Bd9osDbCE_tC8gZreRsHz7D2_dFOjmE,3793
-cloudnetpy/instruments/campbell_scientific.py,sha256=c3f2W9aA52ghJ35_J994y7FShA3W-Bxk52BCbEm_gt0,6975
-cloudnetpy/instruments/ceilo.py,sha256=xrI7iYNftKvGZf-3C_ESUNsu-QhXV43iWkDuKp3biZU,9552
+cloudnetpy/instruments/ceilo.py,sha256=rkP6Vo90eS5ZhnKxZpnkuiG5ZEP86lDK8zRqoMY1aqg,9498
 cloudnetpy/instruments/ceilometer.py,sha256=pdmLVljsuciyKpaGxWxJ_f1IrJK-UrkBC0lSeuirLlU,12095
 cloudnetpy/instruments/cl61d.py,sha256=g6DNBFju3wYhLFl32DKmC8pUup7y-EupXoUU0fuoGGA,1990
 cloudnetpy/instruments/cloudnet_instrument.py,sha256=086GJ6Nfp7sK9ZK8UygJOn-aiVPreez674_gbrOZj4I,5183
 cloudnetpy/instruments/copernicus.py,sha256=99idcn6-iKOSvSslNjwFRng3gwlTLFjKPiT1tnVytpQ,6613
 cloudnetpy/instruments/galileo.py,sha256=BjWE15_S3tTCOmAM5k--oicI3wghKaO0hv9EUBxtbl8,4830
-cloudnetpy/instruments/hatpro.py,sha256=5jeONT2gBlAFr_M6mPablAiWloBYta_9nvXv6kt75LU,8969
+cloudnetpy/instruments/hatpro.py,sha256=z3mOc23LDz2Si9hasRaJvJFDEPR5rxYUFWfoKWK0LyE,9061
 cloudnetpy/instruments/instruments.py,sha256=97hHMjp8fp2IKihr0XJYY3BrOlBArU7gYwYmt3OxqvU,4124
 cloudnetpy/instruments/lufft.py,sha256=nIoEKuuFGKq2dLqkX7zW-HpAifefG472tZhKfXE1yoA,4212
 cloudnetpy/instruments/mira.py,sha256=Wofp8HbiAwJce_IbOLjpEFV07H_Kh4170C9Wygiz-ew,11401
@@ -54,7 +53,7 @@ cloudnetpy/instruments/rain_e_h3.py,sha256=9TdpP4UzMBNIt2iE2GL6K9dFldzTHPLOrU8Q3
 cloudnetpy/instruments/rpg.py,sha256=vfs_eGahPOxFjOIBczNywRwtdutOsJpSNeXZm99SIOo,17438
 cloudnetpy/instruments/rpg_reader.py,sha256=ThztFuVrWxhmWVAfZTfQDeUiKK1XMTbtv08IBe8GK98,11364
 cloudnetpy/instruments/toa5.py,sha256=CfmmBMv5iMGaWHIGBK01Rw24cuXC1R1RMNTXkmsm340,1760
-cloudnetpy/instruments/vaisala.py,sha256=MA6hAlanFrxJlF4suDxLt5FyjcSSzJg-SWRnkLQpu3E,14688
+cloudnetpy/instruments/vaisala.py,sha256=RKAw_fVry4YOUF0i2_-2jLIc6_H85oL8USA4ji9rh0o,4583
 cloudnetpy/instruments/weather_station.py,sha256=pg5Rf6A0qkbAYV1NvC1-oQLkwe9-gmLxHJ8CYW7xgYI,20365
 cloudnetpy/instruments/disdrometer/__init__.py,sha256=lyjwttWvFvuwYxEkusoAvgRcbBmglmOp5HJOpXUqLWo,93
 cloudnetpy/instruments/disdrometer/common.py,sha256=g52iK2aNp3Z88kovUmGVpC54NZomPa9D871gzO0AmQ4,9267
@@ -102,7 +101,7 @@ cloudnetpy/model_evaluation/tests/unit/test_statistical_methods.py,sha256=Ra3r4V
 cloudnetpy/model_evaluation/tests/unit/test_tools.py,sha256=Ia_VrLdV2NstX5gbx_3AZTOAlrgLAy_xFZ8fHYVX0xI,3817
 cloudnetpy/plotting/__init__.py,sha256=lg9Smn4BI0dVBgnDLC3JVJ4GmwoSnO-qoSd4ApvwV6Y,107
 cloudnetpy/plotting/plot_meta.py,sha256=qfyZJNis937uM-NJseer8i4FO7I_v5jhQPyFl5Uszi8,17390
-cloudnetpy/plotting/plotting.py,sha256=Hi_n3TjzqR2KjZgalFHGxsb7jTsqub9nWzZyscfk6xA,38385
+cloudnetpy/plotting/plotting.py,sha256=EEdTu9H3ly5dxILNyiWjmH5iDRyTFDlFIYGUp7Yvxxs,38396
 cloudnetpy/products/__init__.py,sha256=2hRb5HG9hNrxH1if5laJkLeFeaZCd5W1q3hh4ewsX0E,273
 cloudnetpy/products/classification.py,sha256=KwAiBSgFwDqhM114NIgYiUjj8HoYc7gAlc8E1QgcSig,8207
 cloudnetpy/products/der.py,sha256=soypE7uSEP4uHUCCQVEhyXsKY6e9mzV9B_2S5GUizqk,12729
@@ -116,10 +115,10 @@ cloudnetpy/products/lwc.py,sha256=sl6Al2tuH3KkCBrPbWTmuz3jlD5UQJ4D6qBsn1tt2CQ,18
 cloudnetpy/products/mie_lu_tables.nc,sha256=It4fYpqJXlqOgL8jeZ-PxGzP08PMrELIDVe55y9ob58,16637951
 cloudnetpy/products/mwr_tools.py,sha256=rd7UC67O4fsIE5SaHVZ4qWvUJTj41ZGwgQWPwZzOM14,5377
 cloudnetpy/products/product_tools.py,sha256=uu4l6reuGbPcW3TgttbaSrqIKbyYGhBVTdnC7opKvmg,11101
+cloudnetpy-1.71.5.dist-info/licenses/LICENSE,sha256=wcZF72bdaoG9XugpyE95Juo7lBQOwLuTKBOhhtANZMM,1094
 docs/source/conf.py,sha256=IKiFWw6xhUd8NrCg0q7l596Ck1d61XWeVjIFHVSG9Og,1490
-cloudnetpy-1.71.3.dist-info/LICENSE,sha256=wcZF72bdaoG9XugpyE95Juo7lBQOwLuTKBOhhtANZMM,1094
-cloudnetpy-1.71.3.dist-info/METADATA,sha256=kMugQZKRTpx-hY86nY2NMhW5Q6oYE5p4a0eeM6H8vPo,5872
-cloudnetpy-1.71.3.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-cloudnetpy-1.71.3.dist-info/entry_points.txt,sha256=HhY7LwCFk4qFgDlXx_Fy983ZTd831WlhtdPIzV-Y3dY,51
-cloudnetpy-1.71.3.dist-info/top_level.txt,sha256=ibSPWRr6ojS1i11rtBFz2_gkIe68mggj7aeswYfaOo0,16
-cloudnetpy-1.71.3.dist-info/RECORD,,
+cloudnetpy-1.71.5.dist-info/METADATA,sha256=PPVhCnIGq2fq-b981uBPydzl4mR5Dia7_1JGhD7_LHI,5787
+cloudnetpy-1.71.5.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+cloudnetpy-1.71.5.dist-info/entry_points.txt,sha256=HhY7LwCFk4qFgDlXx_Fy983ZTd831WlhtdPIzV-Y3dY,51
+cloudnetpy-1.71.5.dist-info/top_level.txt,sha256=ibSPWRr6ojS1i11rtBFz2_gkIe68mggj7aeswYfaOo0,16
+cloudnetpy-1.71.5.dist-info/RECORD,,

{cloudnetpy-1.71.3.dist-info → cloudnetpy-1.71.5.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (76.0.0)
+Generator: setuptools (78.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

cloudnetpy/instruments/campbell_scientific.py

@@ -1,203 +0,0 @@
-import binascii
-import datetime
-import re
-from typing import NamedTuple
-
-import numpy as np
-
-from cloudnetpy import utils
-from cloudnetpy.exceptions import InconsistentDataError, ValidTimeStampError
-from cloudnetpy.instruments import instruments
-from cloudnetpy.instruments.ceilometer import Ceilometer
-
-
-def _date_format_to_regex(fmt: bytes) -> bytes:
-    """Converts a date format string to a regex pattern."""
-    mapping = {
-        b"%Y": rb"\d{4}",
-        b"%m": rb"0[1-9]|1[0-2]",
-        b"%d": rb"0[1-9]|[12]\d|3[01]",
-        b"%H": rb"[01]\d|2[0-3]",
-        b"%M": rb"[0-5]\d",
-        b"%S": rb"[0-5]\d",
-        b"%f": rb"\d{6}",
-    }
-    pattern = re.escape(fmt)
-    for key, value in mapping.items():
-        pattern = pattern.replace(
-            re.escape(key), b"(?P<" + key[1:] + b">" + value + b")"
-        )
-    return pattern
-
-
-FORMATS = [
-    re.compile(_date_format_to_regex(fmt))
-    for fmt in [
-        b"%Y-%m-%dT%H:%M:%S.%f,",
-        b"%%% %Y/%m/%d %H:%M:%S %%%\n",
-    ]
-]
-
-
-class Cs135(Ceilometer):
-    def __init__(
-        self,
-        full_path: str,
-        site_meta: dict,
-        expected_date: str | None = None,
-    ):
-        super().__init__()
-        self.full_path = full_path
-        self.site_meta = site_meta
-        self.expected_date = expected_date
-        self.data = {}
-        self.metadata = {}
-        self.instrument = instruments.CS135
-
-    def read_ceilometer_file(self, calibration_factor: float | None = None) -> None:
-        with open(self.full_path, mode="rb") as f:
-            content = f.read()
-        timestamps = []
-        profiles = []
-        tilt_angles = []
-        range_resolutions = []
-
-        for fmt in FORMATS:
-            parts = re.split(fmt, content)
-            for i in range(1, len(parts), fmt.groups + 1):
-                timestamp = datetime.datetime(
-                    int(parts[i + fmt.groupindex["Y"] - 1]),
-                    int(parts[i + fmt.groupindex["m"] - 1]),
-                    int(parts[i + fmt.groupindex["d"] - 1]),
-                    int(parts[i + fmt.groupindex["H"] - 1]),
-                    int(parts[i + fmt.groupindex["M"] - 1]),
-                    int(parts[i + fmt.groupindex["S"] - 1]),
-                    int(parts[i + fmt.groupindex["f"] - 1])
-                    if "f" in fmt.groupindex
-                    else 0,
-                    tzinfo=datetime.timezone.utc,
-                )
-                try:
-                    self._check_timestamp(timestamp)
-                except ValidTimeStampError:
-                    continue
-                try:
-                    message = _read_message(parts[i + fmt.groups])
-                except InvalidMessageError:
-                    continue
-                profile = (message.data[:-2] * 1e-8) * (message.scale / 100)
-                timestamps.append(timestamp)
-                profiles.append(profile)
-                tilt_angles.append(message.tilt_angle)
-                range_resolutions.append(message.range_resolution)
-
-        if len(timestamps) == 0:
-            msg = "No valid timestamps found in the file"
-            raise ValidTimeStampError(msg)
-        range_resolution = range_resolutions[0]
-        n_gates = len(profiles[0])
-        if any(res != range_resolution for res in range_resolutions):
-            msg = "Inconsistent range resolution"
-            raise InconsistentDataError(msg)
-        if any(len(profile) != n_gates for profile in profiles):
-            msg = "Inconsistent number of gates"
-            raise InconsistentDataError(msg)
-
-        self.data["beta_raw"] = np.array(profiles)
-        if calibration_factor is None:
-            calibration_factor = 1.0
-        self.data["beta_raw"] *= calibration_factor
-        self.data["calibration_factor"] = calibration_factor
-        self.data["range"] = (
-            np.arange(n_gates) * range_resolution + range_resolution / 2
-        )
-        self.data["time"] = utils.datetime2decimal_hours(timestamps)
-        self.data["zenith_angle"] = np.median(tilt_angles)
-
-    def _check_timestamp(self, timestamp: datetime.datetime) -> None:
-        timestamp_components = str(timestamp.date()).split("-")
-        if (
-            self.expected_date is not None
-            and timestamp_components != self.expected_date.split("-")
-        ):
-            raise ValidTimeStampError
-        if not self.date:
-            self.date = timestamp_components
-        if timestamp_components != self.date:
-            msg = "Inconsistent dates in the file"
-            raise RuntimeError(msg)
-
-
-class Message(NamedTuple):
-    scale: int
-    range_resolution: int
-    laser_pulse_energy: int
-    laser_temperature: int
-    tilt_angle: int
-    background_light: int
-    pulse_quantity: int
-    sample_rate: int
-    data: np.ndarray
-
-
-class InvalidMessageError(Exception):
-    pass
-
-
-def _read_message(message: bytes) -> Message:
-    end_idx = message.index(3)
-    content = message[1 : end_idx + 1]
-    expected_checksum = int(message[end_idx + 1 : end_idx + 5], 16)
-    actual_checksum = _crc16(content)
-    if expected_checksum != actual_checksum:
-        msg = (
-            "Invalid checksum: "
-            f"expected {expected_checksum:04x}, "
-            f"got {actual_checksum:04x}"
-        )
-        raise InvalidMessageError(msg)
-    lines = message[1 : end_idx - 1].splitlines()
-    n_lines = len(lines) + 1
-    n_first = len(lines[0]) + 1
-    if n_first != 11:
-        msg = f"Expected 11 characters in first line, got {n_first}"
-        raise NotImplementedError(msg)
-    msg_no = lines[0][-4:-1]
-    if msg_no == b"002":
-        if n_lines != 5:
-            msg = f"Expected 5 lines, got {len(lines)}"
-            raise InvalidMessageError(msg)
-        scale, res, n, energy, lt, ti, bl, pulse, rate, _sum = map(
-            int, lines[2].split()
-        )
-        data = _read_backscatter(lines[3].strip(), n)
-        return Message(scale, res, energy, lt, ti, bl, pulse, rate, data)
-    if msg_no == b"004":
-        if n_lines != 6:
-            msg = f"Expected 6 lines, got {len(lines)}"
-            raise InvalidMessageError(msg)
-        scale, res, n, energy, lt, ti, bl, pulse, rate, _sum = map(
-            int, lines[3].split()
-        )
-        data = _read_backscatter(lines[4].strip(), n)
-        return Message(scale, res, energy, lt, ti, bl, pulse, rate, data)
-    msg = f"Message number {msg_no.decode()} not implemented"
-    raise NotImplementedError(msg)
-
-
-def _read_backscatter(data: bytes, n_gates: int) -> np.ndarray:
-    """Read backscatter values from hex-encoded two's complement values."""
-    n_chars = 5
-    n_bits = n_chars * 4
-    limit = (1 << (n_bits - 1)) - 1
-    offset = 1 << n_bits
-    out = np.array(
-        [int(data[i : i + n_chars], 16) for i in range(0, n_gates * n_chars, n_chars)],
-    )
-    out[out > limit] -= offset
-    return out
-
-
-def _crc16(data: bytes) -> int:
-    """Compute checksum similar to CRC-16-CCITT."""
-    return binascii.crc_hqx(data, 0xFFFF) ^ 0xFFFF