doppy 0.5.3__tar.gz → 0.5.4__tar.gz

{doppy-0.5.3 → doppy-0.5.4}/Cargo.lock

@@ -106,18 +106,20 @@ checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
 [[package]]
 name = "doppy_rs"
-version = "0.5.3"
+version = "0.5.4"
 dependencies = [
  "doprs",
+ "ndarray 0.16.1",
  "numpy",
  "pyo3",
 ]
 
 [[package]]
 name = "doprs"
-version = "0.5.3"
+version = "0.5.4"
 dependencies = [
  "chrono",
+ "ndarray 0.16.1",
  "rayon",
  "regex",
 ]
@@ -233,6 +235,21 @@ dependencies = [
  "rawpointer",
 ]
 
+[[package]]
+name = "ndarray"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "882ed72dce9365842bf196bdeedf5055305f11fc8c03dee7bb0194a6cad34841"
+dependencies = [
+ "matrixmultiply",
+ "num-complex",
+ "num-integer",
+ "num-traits",
+ "portable-atomic",
+ "portable-atomic-util",
+ "rawpointer",
+]
+
 [[package]]
 name = "num-complex"
 version = "0.4.6"
@@ -267,7 +284,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bef41cbb417ea83b30525259e30ccef6af39b31c240bda578889494c5392d331"
 dependencies = [
  "libc",
- "ndarray",
+ "ndarray 0.15.6",
  "num-complex",
  "num-integer",
  "num-traits",
@@ -310,6 +327,15 @@ version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "350e9b48cbc6b0e028b0473b114454c6316e57336ee184ceab6e53f72c178b3e"
 
+[[package]]
+name = "portable-atomic-util"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8a2f0d8d040d7848a709caf78912debcc3f33ee4b3cac47d73d1e1069e83507"
+dependencies = [
+ "portable-atomic",
+]
+
 [[package]]
 name = "proc-macro2"
 version = "1.0.94"

{doppy-0.5.3 → doppy-0.5.4}/Cargo.toml

@@ -4,6 +4,11 @@ resolver = "2"
 
 [workspace.package]
 edition = "2021"
-version = "0.5.3"
+version = "0.5.4"
 authors = ["Niko Leskinen <niko.leskinen@fmi.fi>"]
 license-file = "LICENSE"
+
+
+[workspace.dependencies]
+ndarray = "0.16"
+numpy = {version = "0.20", fatures = ["ndarray"]}

{doppy-0.5.3 → doppy-0.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: doppy
-Version: 0.5.3
+Version: 0.5.4
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
@@ -28,6 +28,7 @@ Requires-Dist: maturin==1.8 ; extra == 'dev'
 Requires-Dist: release-version ; extra == 'dev'
 Requires-Dist: pre-commit ; extra == 'dev'
 Requires-Dist: xarray[io] ; extra == 'dev'
+Requires-Dist: seaborn ; extra == 'dev'
 Provides-Extra: dev
 License-File: LICENSE
 License-File: LICENSE

{doppy-0.5.3 → doppy-0.5.4}/crates/doppy_rs/Cargo.toml

@@ -1,6 +1,7 @@
 [dependencies]
-numpy = "0.20"
 doprs = {path = "../doprs"}
+ndarray = {workspace=true}
+numpy = {workspace=true}
 
 [dependencies.pyo3]
 version = "0.20.0"

doppy-0.5.4/crates/doppy_rs/src/raw/wls77.rs

@@ -0,0 +1,90 @@
+use numpy::PyArray1;
+use pyo3::exceptions::PyRuntimeError;
+use pyo3::prelude::*;
+use pyo3::types::PyDict;
+
+#[pymodule]
+pub fn wls77(_py: Python, m: &PyModule) -> PyResult<()> {
+    m.add_function(wrap_pyfunction!(from_bytes_src, m)?)?;
+    Ok(())
+}
+
+#[pyfunction]
+pub fn from_bytes_srcs<'a>(py: Python<'a>, contents: Vec<&'a [u8]>) -> PyResult<Vec<&'a PyDict>> {
+    let raws = doprs::raw::wls77::from_bytes_srcs(contents);
+    let mut result = Vec::new();
+    for raw in raws {
+        result.push(convert_to_python(py, raw)?);
+    }
+    Ok(result)
+}
+
+#[pyfunction]
+pub fn from_bytes_src<'a>(py: Python<'a>, content: &'a [u8]) -> PyResult<&'a PyDict> {
+    let raw = match doprs::raw::wls77::from_bytes_src(content) {
+        Ok(raw) => raw,
+        Err(e) => {
+            return Err(PyRuntimeError::new_err(format!(
+                "Failed to read files: {}",
+                e
+            )))
+        }
+    };
+    convert_to_python(py, raw)
+}
+
+#[pyfunction]
+pub fn from_filename_srcs(py: Python, filenames: Vec<String>) -> PyResult<Vec<&PyDict>> {
+    let raws = doprs::raw::wls77::from_filename_srcs(filenames);
+    let mut result = Vec::new();
+    for raw in raws {
+        result.push(convert_to_python(py, raw)?);
+    }
+    Ok(result)
+}
+
+#[pyfunction]
+pub fn from_filename_src(py: Python, filename: String) -> PyResult<&PyDict> {
+    let raw = match doprs::raw::wls77::from_filename_src(filename) {
+        Ok(raw) => raw,
+        Err(e) => {
+            return Err(PyRuntimeError::new_err(format!(
+                "Failed to read files: {}",
+                e
+            )))
+        }
+    };
+    convert_to_python(py, raw)
+}
+
+fn convert_to_python(py: Python, raw: doprs::raw::wls77::Wls77) -> PyResult<&PyDict> {
+    let d = PyDict::new(py);
+
+    let fields = [
+        ("time", raw.time.as_slice()),
+        ("altitude", raw.altitude.as_slice()),
+        ("position", raw.position.as_slice()),
+        ("temperature", raw.temperature.as_slice()),
+        ("wiper_count", raw.wiper_count.as_slice()),
+        ("cnr", raw.cnr.as_slice()),
+        ("radial_velocity", raw.radial_velocity.as_slice()),
+        (
+            "radial_velocity_deviation",
+            raw.radial_velocity_deviation.as_slice(),
+        ),
+        ("wind_speed", raw.wind_speed.as_slice()),
+        ("wind_direction", raw.wind_direction.as_slice()),
+        ("zonal_wind", raw.zonal_wind.as_slice()),
+        ("meridional_wind", raw.meridional_wind.as_slice()),
+        ("vertical_wind", raw.vertical_wind.as_slice()),
+    ];
+
+    for (key, value) in fields {
+        d.set_item(key, PyArray1::from_slice(py, value.unwrap()))?;
+    }
+
+    d.set_item("cnr_threshold", raw.cnr_threshold)?;
+    d.set_item("system_id", raw.system_id)?;
+
+    Ok(d)
+}

{doppy-0.5.3 → doppy-0.5.4}/crates/doppy_rs/src/raw.rs

@@ -3,10 +3,12 @@ use pyo3::wrap_pymodule;
 
 pub mod halo_hpl;
 pub mod wls70;
+pub mod wls77;
 
 #[pymodule]
 pub fn raw(_py: Python, m: &PyModule) -> PyResult<()> {
     m.add_wrapped(wrap_pymodule!(halo_hpl::halo_hpl))?;
     m.add_wrapped(wrap_pymodule!(wls70::wls70))?;
+    m.add_wrapped(wrap_pymodule!(wls77::wls77))?;
     Ok(())
 }

{doppy-0.5.3 → doppy-0.5.4}/crates/doprs/Cargo.toml

@@ -2,6 +2,7 @@
 chrono = "0.4"
 regex = "1.10"
 rayon = "1.8"
+ndarray = {workspace=true}
 
 [package]
 name = "doprs"

doppy-0.5.4/crates/doprs/src/bin/parse_wls70.rs

@@ -0,0 +1,8 @@
+use doprs::raw::wls70;
+
+fn main() {
+    let path = std::env::args().nth(1).unwrap();
+    let file = std::fs::File::open(path).unwrap();
+    let a = wls70::from_file_src(&file).unwrap();
+    dbg!(a);
+}

doppy-0.5.4/crates/doprs/src/bin/parse_wls77.rs

@@ -0,0 +1,7 @@
+use doprs::raw::wls77;
+
+fn main() {
+    let path = std::env::args().nth(1).unwrap();
+    let file = std::fs::File::open(path).unwrap();
+    let _a = wls77::from_file_src(&file).unwrap();
+}

doppy-0.5.4/crates/doprs/src/raw/wls77.rs

@@ -0,0 +1,290 @@
+use crate::raw::error::RawParseError;
+use chrono::{DateTime, NaiveDateTime, ParseError, Utc};
+use ndarray::{s, Array, Array1, Array2};
+use rayon::prelude::*;
+use std::fs::File;
+use std::io::{BufRead, Cursor, Read};
+
+#[derive(Debug, Default, Clone)]
+pub struct Wls77Old {
+    pub info: Info,
+    pub data_columns: Vec<String>,
+    pub data: Vec<f64>,
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct Wls77 {
+    pub time: Array1<f64>,
+    pub altitude: Array1<f64>,
+    pub position: Array1<f64>,
+    pub temperature: Array1<f64>,
+    pub wiper_count: Array1<f64>,
+    pub cnr: Array2<f64>,
+    pub radial_velocity: Array2<f64>,
+    pub radial_velocity_deviation: Array2<f64>,
+    pub wind_speed: Array2<f64>,
+    pub wind_direction: Array2<f64>,
+    pub zonal_wind: Array2<f64>,
+    pub meridional_wind: Array2<f64>,
+    pub vertical_wind: Array2<f64>,
+    pub cnr_threshold: f64,
+    pub system_id: String,
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct Info {
+    pub altitude: Vec<f64>,
+    pub system_id: String,
+    pub cnr_threshold: f64,
+}
+
+pub fn from_file_src(mut file: &File) -> Result<Wls77, RawParseError> {
+    let mut content = vec![];
+    file.read_to_end(&mut content)?;
+    from_bytes_src(&content)
+}
+
+pub fn from_filename_src(filename: String) -> Result<Wls77, RawParseError> {
+    let file = File::open(filename)?;
+    from_file_src(&file)
+}
+
+pub fn from_filename_srcs(filenames: Vec<String>) -> Vec<Wls77> {
+    let results = filenames
+        .par_iter()
+        .filter_map(|filename| from_filename_src(filename.to_string()).ok())
+        .collect();
+    results
+}
+
+pub fn from_file_srcs(files: Vec<&File>) -> Vec<Wls77> {
+    let results = files
+        .par_iter()
+        .filter_map(|file| from_file_src(file).ok())
+        .collect();
+    results
+}
+
+pub fn from_bytes_srcs(contents: Vec<&[u8]>) -> Vec<Wls77> {
+    let results = contents
+        .par_iter()
+        .filter_map(|content| from_bytes_src(content).ok())
+        .collect();
+    results
+}
+
+enum Phase {
+    Info,
+    Data,
+}
+
+pub fn from_bytes_src(content: &[u8]) -> Result<Wls77, RawParseError> {
+    let cur = Cursor::new(content);
+    let mut info_str = Vec::new();
+    let mut header = Vec::new();
+    let mut data_str = Vec::new();
+
+    let mut phase = Phase::Info;
+
+    for line in cur.split(b'\n') {
+        let line = line.unwrap();
+        match phase {
+            Phase::Info => {
+                if line.starts_with(b"Timestamp\tPosition\tTemperature")
+                    || line.starts_with(b"Date\tPosition\tTemperature")
+                {
+                    header.extend_from_slice(&line);
+                    header.push(b'\n');
+                    phase = Phase::Data;
+                } else {
+                    info_str.extend_from_slice(&line);
+                    info_str.push(b'\n');
+                }
+            }
+            Phase::Data => {
+                data_str.extend_from_slice(&line);
+                data_str.push(b'\n');
+            }
+        }
+    }
+    let info = parse_info(&info_str)?;
+
+    match parse_data(&data_str) {
+        Ok((data, ncols)) => {
+            let header_str: String = header.iter().map(|&c| c as char).collect();
+            let cols: Vec<_> = header_str
+                .split('\t')
+                .map(|s| s.trim().to_string())
+                .filter(|s| !s.is_empty())
+                .collect();
+            if ncols != (cols.len() as i64) {
+                return Err(RawParseError {
+                    message: "Number of columns on header and number of columns in data mismatch"
+                        .to_string(),
+                });
+            }
+
+            let data: Array1<_> = Array::from_vec(data.clone());
+            let n = (data.len() as i64 / ncols)
+                .try_into()
+                .map_err(|e| RawParseError {
+                    message: format!("Failed to convert rows count: {}", e),
+                })?;
+            let m = ncols.try_into().map_err(|e| RawParseError {
+                message: format!("Failed to convert columns count: {}", e),
+            })?;
+            let shape: [usize; 2] = [n, m];
+
+            let data = data
+                .into_shape_with_order(shape)
+                .map_err(|e| RawParseError {
+                    message: format!("Cannot reshape data array: {}", e),
+                })?;
+            let altitude = Array::from_vec(info.altitude);
+
+            let time = data.slice(s![.., 0]).to_owned();
+            let position = data.slice(s![.., 1]).to_owned();
+            let temperature = data.slice(s![.., 2]).to_owned();
+            let wiper_count = data.slice(s![.., 2]).to_owned();
+            let cnr = data.slice(s![..,4..;8]).to_owned();
+            let radial_velocity = data.slice(s![..,5..;8]).to_owned();
+            let radial_velocity_deviation = data.slice(s![..,6..;8]).to_owned();
+            let wind_speed = data.slice(s![..,7..;8]).to_owned();
+            let wind_direction = data.slice(s![..,8..;8]).to_owned();
+            let zonal_wind = data.slice(s![..,9..;8]).to_owned();
+            let meridional_wind = data.slice(s![..,10..;8]).to_owned();
+            let vertical_wind = data.slice(s![..,11..;8]).to_owned();
+
+            Ok(Wls77 {
+                time,
+                altitude,
+                position,
+                temperature,
+                wiper_count,
+                cnr,
+                radial_velocity,
+                radial_velocity_deviation,
+                wind_speed,
+                wind_direction,
+                zonal_wind,
+                meridional_wind,
+                vertical_wind,
+                system_id: info.system_id,
+                cnr_threshold: info.cnr_threshold,
+            })
+        }
+        Err(e) => Err(e),
+    }
+}
+
+fn parse_info(info_str: &[u8]) -> Result<Info, RawParseError> {
+    let mut info = Info::default();
+    for line in info_str.split(|&b| b == b'\n') {
+        match line {
+            b if b.starts_with(b"Altitudes AGL (m)=") => {
+                info.altitude = line
+                    .split(|&b| b == b'\t')
+                    .skip(1)
+                    .map(|part| {
+                        String::from_utf8(part.to_vec())
+                            .map_err(|_| RawParseError {
+                                message: "UTF-8 conversion error".into(),
+                            })
+                            .and_then(|s| {
+                                s.trim().parse::<f64>().map_err(|_| RawParseError {
+                                    message: "Parse float error".into(),
+                                })
+                            })
+                    })
+                    .collect::<Result<Vec<f64>, _>>()?;
+            }
+            b if b.starts_with(b"ID System=") => {
+                info.system_id = std::str::from_utf8(&line[10..])
+                    .map(|s| s.trim())
+                    .map_err(|_| RawParseError {
+                        message: "UTF-8 conversion error".into(),
+                    })?
+                    .to_string();
+            }
+            b if b.starts_with(b"CNRThreshold=") => {
+                info.cnr_threshold = std::str::from_utf8(&line[13..])
+                    .map_err(|_| RawParseError {
+                        message: "UTF-8 conversion error".into(),
+                    })?
+                    .trim()
+                    .parse::<f64>()
+                    .map_err(|_| RawParseError {
+                        message: "Parse float error".into(),
+                    })?;
+            }
+            _ => (),
+        }
+    }
+
+    Ok(info)
+}
+
+pub fn parse_data(data: &[u8]) -> Result<(Vec<f64>, i64), RawParseError> {
+    let mut ncols: i64 = -1;
+    let mut data_flat = vec![];
+    for line in data.split(|&b| b == b'\n') {
+        let parts: Vec<_> = line
+            .split(|&b| b == b'\t')
+            .filter(|part| !(part.is_empty() || part == b"\r"))
+            .collect();
+        if parts.is_empty() {
+            continue;
+        }
+        if ncols < 0 {
+            ncols = parts.len() as i64;
+        }
+        if ncols != parts.len() as i64 {
+            return Err(RawParseError {
+                message: "Unexpected number of columns".to_string(),
+            });
+        }
+        for (i, part) in parts.iter().enumerate() {
+            match i {
+                0 => {
+                    let date = String::from_utf8_lossy(part).trim().to_string();
+                    match datetime_to_timestamp(&date) {
+                        Ok(d) => {
+                            data_flat.push(d);
+                        }
+                        Err(_) => println!("Error with datetime"),
+                    }
+                }
+                1 => {
+                    let s = String::from_utf8_lossy(part).trim().to_string();
+                    if let Ok(val) = s.parse::<f64>() {
+                        data_flat.push(val);
+                    } else {
+                        match s.as_ref() {
+                            "V" => data_flat.push(-1.0),
+                            _ => data_flat.push(-2.0),
+                        }
+                    }
+                }
+
+                _ => match String::from_utf8_lossy(part).trim().parse::<f64>() {
+                    Ok(x) => {
+                        data_flat.push(x);
+                    }
+                    Err(_) => println!("Cannot parse float"),
+                },
+            }
+        }
+    }
+    if ncols < 1 || (data_flat.len() as i64) % ncols != 0 {
+        return Err(RawParseError {
+            message: "Unexpected number of columns".to_string(),
+        });
+    }
+    Ok((data_flat, ncols))
+}
+fn datetime_to_timestamp(s: &str) -> Result<f64, ParseError> {
+    let format = "%Y/%m/%d %H:%M:%S%.f";
+    let ndt = NaiveDateTime::parse_from_str(s, format)?;
+    let dt = DateTime::<Utc>::from_naive_utc_and_offset(ndt, Utc);
+    Ok(dt.timestamp() as f64 + dt.timestamp_subsec_millis() as f64 / 1000.0)
+}

{doppy-0.5.3 → doppy-0.5.4}/crates/doprs/src/raw.rs

@@ -1,3 +1,4 @@
 pub mod error;
 pub mod halo_hpl;
 pub mod wls70;
+pub mod wls77;

{doppy-0.5.3 → doppy-0.5.4}/pyproject.toml

@@ -44,6 +44,7 @@ dev = [
   "release-version",
   "pre-commit",
   "xarray[io]",
+  "seaborn",
 ]
 
 [project.scripts]

{doppy-0.5.3 → doppy-0.5.4}/src/doppy/raw/__init__.py

@@ -3,5 +3,14 @@ from .halo_hpl import HaloHpl
 from .halo_sys_params import HaloSysParams
 from .windcube import WindCube, WindCubeFixed
 from .wls70 import Wls70
+from .wls77 import Wls77
 
-__all__ = ["HaloHpl", "HaloBg", "HaloSysParams", "WindCube", "WindCubeFixed", "Wls70"]
+__all__ = [
+    "HaloHpl",
+    "HaloBg",
+    "HaloSysParams",
+    "WindCube",
+    "WindCubeFixed",
+    "Wls70",
+    "Wls77",
+]

doppy-0.5.4/src/doppy/raw/wls77.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from io import BufferedIOBase
+from pathlib import Path
+from typing import Any, Sequence
+
+import numpy as np
+import numpy.typing as npt
+from numpy import datetime64
+
+import doppy
+from doppy import exceptions
+from doppy.raw.utils import bytes_from_src
+from doppy.utils import merge_all_equal
+
+
+@dataclass
+class Wls77:
+    time: npt.NDArray[datetime64]  # dim: (time, )
+    altitude: npt.NDArray[np.float64]  # dim: (altitude, )
+    position: npt.NDArray[np.float64]  # dim: (time, )
+    temperature: npt.NDArray[np.float64]  # dim: (time, )
+    wiper_count: npt.NDArray[np.float64]  # dim: (time, )
+    cnr: npt.NDArray[np.float64]  # dim: (time, altitude)
+    radial_velocity: npt.NDArray[np.float64]  # dim: (time, altitude)
+    radial_velocity_deviation: npt.NDArray[np.float64]  # dim: (time, altitude)
+    wind_speed: npt.NDArray[np.float64]  # dim: (time, altitude)
+    wind_direction: npt.NDArray[np.float64]  # dim: (time, altitude)
+    zonal_wind: npt.NDArray[np.float64]  # u := zonal wind?, dim: (time, altitude)
+    meridional_wind: npt.NDArray[
+        np.float64
+    ]  # v := meridional wind?, dim: (time, altitude)
+    vertical_wind: npt.NDArray[np.float64]  # w := vertical wind?, dim: (time, altitude)
+    cnr_threshold: float
+    system_id: str
+
+    @classmethod
+    def from_srcs(
+        cls, data: Sequence[str | bytes | Path | BufferedIOBase]
+    ) -> list[Wls77]:
+        data_bytes = [bytes_from_src(src) for src in data]
+        raws = doppy.rs.raw.wls77.from_bytes_srcs(data_bytes)
+        try:
+            return [_raw_rs_to_wls77(r) for r in raws]
+        except RuntimeError as err:
+            raise exceptions.RawParsingError(err) from err
+
+    @classmethod
+    def from_src(cls, data: str | Path | bytes | BufferedIOBase) -> Wls77:
+        data_bytes = bytes_from_src(data)
+        try:
+            return _raw_rs_to_wls77(doppy.rs.raw.wls77.from_bytes_src(data_bytes))
+        except RuntimeError as err:
+            raise exceptions.RawParsingError(err) from err
+
+    def __getitem__(
+        self,
+        index: int
+        | slice
+        | list[int]
+        | npt.NDArray[np.int64]
+        | npt.NDArray[np.bool_]
+        | tuple[slice, slice],
+    ) -> Wls77:
+        if isinstance(index, (int, slice, list, np.ndarray)):
+            return Wls77(
+                time=self.time[index],
+                altitude=self.altitude,
+                position=self.position[index],
+                temperature=self.temperature[index],
+                wiper_count=self.wiper_count[index],
+                cnr=self.cnr[index],
+                radial_velocity=self.radial_velocity[index],
+                radial_velocity_deviation=self.radial_velocity_deviation[index],
+                wind_speed=self.wind_speed[index],
+                wind_direction=self.wind_direction[index],
+                zonal_wind=self.zonal_wind[index],
+                meridional_wind=self.meridional_wind[index],
+                vertical_wind=self.vertical_wind[index],
+                system_id=self.system_id,
+                cnr_threshold=self.cnr_threshold,
+            )
+        raise TypeError
+
+    def sorted_by_time(self) -> Wls77:
+        sort_indices = np.argsort(self.time)
+        return self[sort_indices]
+
+    @classmethod
+    def merge(cls, raws: Sequence[Wls77]) -> Wls77:
+        return cls(
+            time=np.concatenate(tuple(r.time for r in raws)),
+            altitude=raws[0].altitude,
+            position=np.concatenate(tuple(r.position for r in raws)),
+            temperature=np.concatenate(tuple(r.temperature for r in raws)),
+            wiper_count=np.concatenate(tuple(r.wiper_count for r in raws)),
+            cnr=np.concatenate(tuple(r.cnr for r in raws)),
+            radial_velocity=np.concatenate(tuple(r.radial_velocity for r in raws)),
+            radial_velocity_deviation=np.concatenate(
+                tuple(r.radial_velocity_deviation for r in raws)
+            ),
+            wind_speed=np.concatenate(tuple(r.wind_speed for r in raws)),
+            wind_direction=np.concatenate(tuple(r.wind_direction for r in raws)),
+            zonal_wind=np.concatenate(tuple(r.zonal_wind for r in raws)),
+            meridional_wind=np.concatenate(tuple(r.meridional_wind for r in raws)),
+            vertical_wind=np.concatenate(tuple(r.vertical_wind for r in raws)),
+            system_id=merge_all_equal("system_id", [r.system_id for r in raws]),
+            cnr_threshold=merge_all_equal(
+                "cnr_threshold", [r.cnr_threshold for r in raws]
+            ),
+        )
+
+    def non_strictly_increasing_timesteps_removed(self) -> Wls77:
+        if len(self.time) == 0:
+            return self
+        mask = np.ones_like(self.time, dtype=np.bool_)
+        latest_time = self.time[0]
+        for i, t in enumerate(self.time[1:], start=1):
+            if t <= latest_time:
+                mask[i] = False
+            else:
+                latest_time = t
+        return self[mask]
+
+
+def _raw_rs_to_wls77(
+    raw: dict[str, Any],
+) -> Wls77:
+    time_ts = raw["time"]
+    time = np.array(
+        [
+            datetime64(datetime.fromtimestamp(ts, timezone.utc).replace(tzinfo=None))
+            for ts in time_ts
+        ]
+    )
+
+    n = time.size
+
+    return Wls77(
+        time=time,
+        altitude=np.array(raw["altitude"], dtype=np.float64),
+        position=np.array(raw["position"], dtype=np.float64),
+        temperature=np.array(raw["temperature"], dtype=np.float64),
+        wiper_count=np.array(raw["wiper_count"], dtype=np.float64),
+        cnr=np.array(raw["cnr"], dtype=np.float64).reshape(n, -1),
+        radial_velocity=np.array(raw["radial_velocity"], dtype=np.float64).reshape(
+            n, -1
+        ),
+        radial_velocity_deviation=np.array(
+            raw["radial_velocity_deviation"], dtype=np.float64
+        ).reshape(n, -1),
+        wind_speed=np.array(raw["wind_speed"], dtype=np.float64).reshape(n, -1),
+        wind_direction=np.array(raw["wind_direction"], dtype=np.float64).reshape(n, -1),
+        zonal_wind=np.array(raw["zonal_wind"], dtype=np.float64).reshape(n, -1),
+        meridional_wind=np.array(raw["meridional_wind"], dtype=np.float64).reshape(
+            n, -1
+        ),
+        vertical_wind=np.array(raw["vertical_wind"], dtype=np.float64).reshape(n, -1),
+        cnr_threshold=raw["cnr_threshold"],
+        system_id=raw["system_id"],
+    )