shr-parser 0.1.5__tar.gz → 0.1.6__tar.gz

{shr_parser-0.1.5 → shr_parser-0.1.6}/Cargo.lock

@@ -292,7 +292,7 @@ dependencies = [
 
 [[package]]
 name = "shr_parser_py"
-version = "0.1.5"
+version = "0.1.6"
 dependencies = [
  "pyo3",
  "shr_parser",

{shr_parser-0.1.5 → shr_parser-0.1.6}/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "shr_parser_py"
 description = "Python bindings for the shr_parser Rust crate"
-version = "0.1.5"
+version = "0.1.6"
 edition = "2021"
 license = "GPL-3.0-only"
 authors = ["Lasse Nielsen <lasse@xerrion.dk>"]

{shr_parser-0.1.5 → shr_parser-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: shr_parser
-Version: 0.1.5
+Version: 0.1.6
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
@@ -9,7 +9,7 @@ Summary: Parses sweeps from a Signal Hound Spike file.
 Author: Lasse Nielsen
 Author-email: Lasse Nielsen <lasse@xerrion.dk>
 License: GPL-3.0-only
-Requires-Python: >=3.8, <=3.12
+Requires-Python: >=3.8, <=3.13
 Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
 Project-URL: Source Code, https://github.com/Xerrion/shr_parser_py
 

{shr_parser-0.1.5 → shr_parser-0.1.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "shr_parser"
-requires-python = ">=3.8,<=3.12"
+requires-python = ">=3.8,<=3.13"
 classifiers = [
     "Programming Language :: Rust",
     "Programming Language :: Python :: Implementation :: CPython",

shr_parser-0.1.6/src/lib.rs

@@ -0,0 +1,154 @@
+use fmt::Display;
+use std::fmt;
+use pyo3::prelude::*;
+use pyo3::wrap_pyfunction;
+use std::path::PathBuf;
+use ::shr_parser::{SHRParser, SHRParsingType};
+
+/// A wrapper around the SHRParser for Python
+#[pyclass(name="SHRParser", subclass)]
+struct PySHRParser {
+    parser: SHRParser,
+    parsing_type: PySHRParsingType,
+}
+
+#[pyclass(name="SHRSweep")]
+struct PySHRSweep {
+    sweep_number: i32,
+    timestamp: u64,
+    frequency: f64,
+    amplitude: f64,
+}
+
+#[pyclass(name="SHRParsingType", eq, eq_int)]
+#[derive(Clone, Copy, Debug, PartialEq)]
+enum PySHRParsingType {
+    PEAK = 0,
+    MEAN = 1,
+    LOW = 2,
+}
+
+impl TryFrom<i32> for PySHRParsingType {
+    type Error = &'static str;
+
+    fn try_from(value: i32) -> Result<Self, Self::Error> {
+        match value {
+            0 => Ok(PySHRParsingType::PEAK),
+            1 => Ok(PySHRParsingType::MEAN),
+            2 => Ok(PySHRParsingType::LOW),
+            _ => Err("Invalid value for SHRParsingType"),
+        }
+    }
+}
+
+impl TryFrom<PySHRParsingType> for SHRParsingType {
+    type Error = &'static str;
+
+    fn try_from(value: PySHRParsingType) -> Result<Self, Self::Error> {
+        match value {
+            PySHRParsingType::PEAK => Ok(SHRParsingType::Peak),
+            PySHRParsingType::MEAN => Ok(SHRParsingType::Mean),
+            PySHRParsingType::LOW => Ok(SHRParsingType::Low),
+        }
+    }
+}
+
+impl Display for PySHRParsingType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            PySHRParsingType::PEAK => write!(f, "SHRParsingType.PEAK"),
+            PySHRParsingType::MEAN => write!(f, "SHRParsingType.MEAN"),
+            PySHRParsingType::LOW => write!(f, "SHRParsingType.LOW"),
+        }
+    }
+}
+
+#[pymethods]
+impl PySHRSweep {
+    fn __repr__(&self) -> String {
+        format!(
+            "SHRSweep(sweep_number={}, timestamp={}, frequency={}, amplitude={})",
+            self.sweep_number, self.timestamp, self.frequency, self.amplitude
+        )
+    }
+
+    #[getter]
+    fn sweep_number(&self) -> i32 {
+        self.sweep_number
+    }
+
+    #[getter]
+    fn timestamp(&self) -> u64 {
+        self.timestamp
+    }
+
+    #[getter]
+    fn frequency(&self) -> f64 {
+        self.frequency
+    }
+
+    #[getter]
+    fn amplitude(&self) -> f64 {
+        self.amplitude
+    }
+}
+
+#[pymethods]
+impl PySHRParser {
+    #[new]
+    fn new(file_path: &str, parsing_type: PySHRParsingType) -> PyResult<Self> {
+        let parser = SHRParser::new(PathBuf::from(file_path), SHRParsingType::try_from(parsing_type).unwrap()).map_err(|e| {
+            pyo3::exceptions::PyIOError::new_err(format!("Failed to parse SHR file: {:?}", e))
+        })?;
+        Ok(PySHRParser { parser, parsing_type })
+    }
+
+    fn __repr__(&self) -> String {
+        format!("SHRParser(file_path='{}', parsing_type={})", self.parser.get_file_path().to_string_lossy(), self.parsing_type)
+    }
+
+    fn to_csv(&self, path: String) -> PyResult<()> {
+        self.parser.to_csv(PathBuf::from(path)).map_err(|e| {
+            pyo3::exceptions::PyIOError::new_err(format!("Failed to write to CSV: {:?}", e))
+        })
+    }
+
+    fn get_sweeps(&self) -> PyResult<Vec<PySHRSweep>> {
+        let sweeps = self.parser.get_sweeps();
+        Ok(sweeps
+            .into_iter()
+            .map(|sweep| PySHRSweep {
+                sweep_number: sweep.sweep_number,
+                timestamp: sweep.timestamp,
+                frequency: sweep.frequency,
+                amplitude: sweep.amplitude,
+            })
+            .collect())
+    }
+
+    fn get_file_header(&self) -> PyResult<String> {
+        let header = self.parser.get_file_header();
+        Ok(format!("{:?}", header))
+    }
+
+    fn get_file_path(&self) -> PyResult<String> {
+        Ok(self.parser.get_file_path().to_string_lossy().to_string())
+    }
+}
+
+
+/// Create a new SHRParser instance.
+#[pyfunction]
+fn create_parser(file_path: &str, parsing_type: i32) -> PyResult<PySHRParser> {
+    PySHRParser::new(file_path, parsing_type.try_into().unwrap())
+}
+
+/// A Python module implemented in Rust.
+#[pymodule]
+ fn shr_parser(module: &Bound<'_, PyModule>) -> PyResult<()> {
+    module.add_class::<PySHRParser>()?;
+    module.add_class::<PySHRSweep>()?;
+    module.add_class::<PySHRParsingType>()?;
+    module.add_function(wrap_pyfunction!(create_parser, module)?)?;
+    Ok(())
+}

shr_parser-0.1.5/src/lib.rs

@@ -1,61 +0,0 @@
-use pyo3::prelude::*;
-use pyo3::wrap_pyfunction;
-use std::path::PathBuf;
-use ::shr_parser::{SHRParser, SHRParsingType};
-
-/// A wrapper around the SHRParser for Python
-#[pyclass]
-struct PySHRParser {
-    parser: SHRParser,
-}
-
-#[pymethods]
-impl PySHRParser {
-    #[new]
-    fn new(file_path: String, parsing_type: i32) -> PyResult<Self> {
-        let parsing_type = SHRParsingType::try_from(parsing_type).map_err(|e| {
-            pyo3::exceptions::PyValueError::new_err(format!("Invalid parsing type: {}", e))
-        })?;
-        let parser = SHRParser::new(PathBuf::from(file_path), parsing_type).map_err(|e| {
-            pyo3::exceptions::PyIOError::new_err(format!("Failed to parse SHR file: {:?}", e))
-        })?;
-        Ok(PySHRParser { parser })
-    }
-
-    fn to_csv(&self, path: String) -> PyResult<()> {
-        self.parser.to_csv(PathBuf::from(path)).map_err(|e| {
-            pyo3::exceptions::PyIOError::new_err(format!("Failed to write to CSV: {:?}", e))
-        })
-    }
-
-    fn get_sweeps(&self) -> PyResult<Vec<(i32, u64, f64, f64)>> {
-        let sweeps = self.parser.get_sweeps();
-        Ok(sweeps
-            .into_iter()
-            .map(|sweep| (sweep.sweep_number, sweep.timestamp, sweep.frequency, sweep.amplitude))
-            .collect())
-    }
-
-    fn get_file_header(&self) -> PyResult<String> {
-        let header = self.parser.get_file_header();
-        Ok(format!("{:?}", header))
-    }
-
-    fn get_file_path(&self) -> PyResult<String> {
-        Ok(self.parser.get_file_path().to_string_lossy().to_string())
-    }
-}
-
-/// Create a new SHRParser instance.
-#[pyfunction]
-fn create_parser(file_path: String, parsing_type: i32) -> PyResult<PySHRParser> {
-    PySHRParser::new(file_path, parsing_type)
-}
-
-/// A Python module implemented in Rust.
-#[pymodule]
- fn shr_parser(module: &Bound<'_, PyModule>) -> PyResult<()> {
-    module.add_class::<PySHRParser>()?;
-    module.add_function(wrap_pyfunction!(create_parser, module)?)?;
-    Ok(())
-}