doppy 0.5.2__tar.gz → 0.5.4__tar.gz

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

@@ -34,9 +34,9 @@ checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
 
 [[package]]
 name = "bitflags"
-version = "2.8.0"
+version = "2.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f68f53c83ab957f72c32642f3868eec03eb974d1fb82e453128456482613d36"
+checksum = "5c8214115b7bf84099f1309324e63141d4c5d7cc26862f97a0a857dbefe165bd"
 
 [[package]]
 name = "bumpalo"
@@ -46,9 +46,9 @@ checksum = "1628fb46dfa0b37568d12e5edd512553eccf6a22a78e8bde00bb4aed84d5bdbf"
 
 [[package]]
 name = "cc"
-version = "1.2.15"
+version = "1.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c736e259eea577f443d5c86c304f9f4ae0295c43f3ba05c21f1d66b5f06001af"
+checksum = "be714c154be609ec7f5dad223a33bf1482fff90472de28f7362806e6d4832b8c"
 dependencies = [
  "shlex",
 ]
@@ -106,27 +106,29 @@ checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
 [[package]]
 name = "doppy_rs"
-version = "0.5.2"
+version = "0.5.4"
 dependencies = [
  "doprs",
+ "ndarray 0.16.1",
  "numpy",
  "pyo3",
 ]
 
 [[package]]
 name = "doprs"
-version = "0.5.2"
+version = "0.5.4"
 dependencies = [
  "chrono",
+ "ndarray 0.16.1",
  "rayon",
  "regex",
 ]
 
 [[package]]
 name = "either"
-version = "1.14.0"
+version = "1.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b7914353092ddf589ad78f25c5c1c21b7f80b0ff8621e7c814c3485b5306da9d"
+checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
 
 [[package]]
 name = "heck"
@@ -159,9 +161,9 @@ dependencies = [
 
 [[package]]
 name = "indoc"
-version = "2.0.5"
+version = "2.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b248f5224d1d606005e02c97f5aa4e88eeb230488bcc03bc9ca4d7991399f2b5"
+checksum = "f4c7245a08504955605670dbf141fceab975f15ca21570696aebe9d2e71576bd"
 
 [[package]]
 name = "js-sys"
@@ -175,9 +177,9 @@ dependencies = [
 
 [[package]]
 name = "libc"
-version = "0.2.170"
+version = "0.2.171"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "875b3680cb2f8f71bdcf9a30f38d48282f5d3c95cbf9b3fa57269bb5d5c06828"
+checksum = "c19937216e9d3aa9956d9bb8dfc0b0c8beb6058fc4f7a4dc4d850edf86a237d6"
 
 [[package]]
 name = "lock_api"
@@ -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",
@@ -277,9 +294,9 @@ dependencies = [
 
 [[package]]
 name = "once_cell"
-version = "1.20.3"
+version = "1.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "945462a4b81e43c4e3ba96bd7b49d834c6f61198356aa858733bc4acf3cbe62e"
+checksum = "cde51589ab56b20a6f686b2c68f7a0bd6add753d697abf720d63f8db3ab7b1ad"
 
 [[package]]
 name = "parking_lot"
@@ -310,11 +327,20 @@ 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.93"
+version = "1.0.94"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "60946a68e5f9d28b0dc1c21bb8a97ee7d018a8b322fa57838ba31cc878e22d99"
+checksum = "a31971752e70b8b2686d7e46ec17fb38dad4051d94024c88df49b667caea9c84"
 dependencies = [
  "unicode-ident",
 ]
@@ -384,9 +410,9 @@ dependencies = [
 
 [[package]]
 name = "quote"
-version = "1.0.38"
+version = "1.0.40"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e4dccaaaf89514f546c693ddc140f729f958c247918a13380cccc6078391acc"
+checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d"
 dependencies = [
  "proc-macro2",
 ]
@@ -419,9 +445,9 @@ dependencies = [
 
 [[package]]
 name = "redox_syscall"
-version = "0.5.9"
+version = "0.5.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82b568323e98e49e2a0899dcee453dd679fae22d69adf9b11dd508d1549b7e2f"
+checksum = "0b8c0c260b63a8219631167be35e6a988e9554dbd323f8bd08439c8ed1302bd1"
 dependencies = [
  "bitflags",
 ]
@@ -463,9 +489,9 @@ checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
 [[package]]
 name = "rustversion"
-version = "1.0.19"
+version = "1.0.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7c45b9784283f1b2e7fb61b42047c2fd678ef0960d4f6f1eba131594cc369d4"
+checksum = "eded382c5f5f786b989652c49544c4877d9f015cc22e145a5ea8ea66c2921cd2"
 
 [[package]]
 name = "scopeguard"
@@ -487,9 +513,9 @@ checksum = "7fcf8323ef1faaee30a44a340193b1ac6814fd9b7b4e88e9d4519a3e4abe1cfd"
 
 [[package]]
 name = "syn"
-version = "2.0.98"
+version = "2.0.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "36147f1a48ae0ec2b5b3bc5b537d267457555a10dc06f3dbc8cb11ba3006d3b1"
+checksum = "b09a44accad81e1ba1cd74a32461ba89dee89095ba17b32f5d03683b1b1fc2a0"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -504,15 +530,15 @@ checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.17"
+version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "00e2473a93778eb0bad35909dff6a10d28e63f792f16ed15e404fca9d5eeedbe"
+checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
 
 [[package]]
 name = "unindent"
-version = "0.2.3"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7de7d73e1754487cb58364ee906a499937a0dfabd86bcb980fa99ec8c8fa2ce"
+checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3"
 
 [[package]]
 name = "wasm-bindgen"

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

@@ -4,6 +4,11 @@ resolver = "2"
 
 [workspace.package]
 edition = "2021"
-version = "0.5.2"
+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.2 → doppy-0.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: doppy
-Version: 0.5.2
+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.2 → 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.2 → 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.2 → 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.2 → doppy-0.5.4}/crates/doprs/src/raw/halo_hpl.rs

@@ -29,6 +29,22 @@ pub struct Info {
     pub start_time: i64, // Unix-timestamp
     pub system_id: String,
     pub instrument_spectral_width: Option<f64>,
+    range_formula: Option<RangeFormula>,
+}
+
+#[derive(Debug, Clone)]
+enum RangeFormula {
+    Common,      //(range gate + 0.5) * Gate length
+    Overlapping, //Gate length / 2 + (range gate x 3)
+}
+
+impl RangeFormula {
+    fn compute_distance(&self, gate_index: f64, range_gate_length: f64) -> f64 {
+        match self {
+            RangeFormula::Common => (gate_index + 0.5) * range_gate_length,
+            RangeFormula::Overlapping => range_gate_length / 2.0 + gate_index * 3.0,
+        }
+    }
 }
 
 #[derive(Debug, Default, Clone)]
@@ -97,7 +113,11 @@ pub fn from_bytes_src(content: &[u8]) -> Result<HaloHpl, RawParseError> {
         }
     }
     let info = parse_header(&buf_header)?;
-    let data = parse_data(&mut cur, info.ngates, info.range_gate_length)?;
+    let range_formula = info
+        .range_formula
+        .as_ref()
+        .ok_or("Cannot find range formula")?;
+    let data = parse_data(&mut cur, info.ngates, info.range_gate_length, range_formula)?;
     Ok(HaloHpl { info, data })
 }
 
@@ -105,6 +125,7 @@ fn parse_data(
     cur: &mut Cursor<&[u8]>,
     ngates: u64,
     range_gate_length: f64,
+    range_formula: &RangeFormula,
 ) -> Result<Data, RawParseError> {
     let (n1d, n2d) = infer_data_shape(cur)?;
     if ngates < 1 || n1d < 3 || n2d < 4 {
@@ -161,7 +182,7 @@ fn parse_data(
         time: data_1d[0].clone(),
         radial_distance: gate
             .iter()
-            .map(|&x| (x + 0.5) * range_gate_length)
+            .map(|&x| range_formula.compute_distance(x, range_gate_length))
             .collect(),
         azimuth: data_1d[1].clone(),
         elevation: data_1d[2].clone(),
@@ -249,8 +270,13 @@ fn parse_header(header_bytes: &[u8]) -> Result<Info, RawParseError> {
                 info.instrument_spectral_width = Some(captures[1].parse()?);
             } else {
                 match line.as_str() {
-                    "Altitude of measurement (center of gate) = (range gate + 0.5) * Gate length" => (),
-                    "Range of measurement (center of gate) = (range gate + 0.5) * Gate length" => (),
+                    "Altitude of measurement (center of gate) = (range gate + 0.5) * Gate length" |
+                    "Range of measurement (center of gate) = (range gate + 0.5) * Gate length" => {
+                        info.range_formula = Some(RangeFormula::Common)
+                    },
+                    "Range of measurement (center of gate) = Gate length / 2 + (range gate x 3)" => {
+                        info.range_formula = Some(RangeFormula::Overlapping)
+                    },
                     "Data line 1: Decimal time (hours)  Azimuth (degrees)  Elevation (degrees) Pitch (degrees) Roll (degrees)" => (),
                     "Data line 1: Decimal time (hours)  Azimuth (degrees)  Elevation (degrees)" => (),
                     "f9.6,1x,f6.2,1x,f6.2" => (),

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.2 → 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.2 → doppy-0.5.4}/pyproject.toml

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

{doppy-0.5.2 → 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"],
+    )