jpk-reader-rs 0.0.1__tar.gz → 0.0.2__tar.gz

{jpk_reader_rs-0.0.1 → jpk_reader_rs-0.0.2}/Cargo.lock

@@ -636,7 +636,7 @@ dependencies = [
 
 [[package]]
 name = "jpk-reader-rs"
-version = "0.0.1"
+version = "0.0.2"
 dependencies = [
  "arrow",
  "jpk_reader",
@@ -1164,6 +1164,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f9e442fc33d7fdb45aa9bfeb312c095964abdf596f7567261062b2a7107aaabd"
 dependencies = [
  "deranged",
+ "js-sys",
  "num-conv",
  "powerfmt",
  "serde_core",
@@ -1267,6 +1268,12 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "typed-path"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7922f2cdc51280d47b491af9eafc41eb0cdab85eabcb390c854412fcbf26dbe8"
+
 [[package]]
 name = "typenum"
 version = "1.19.0"
@@ -1473,9 +1480,9 @@ dependencies = [
 
 [[package]]
 name = "zip"
-version = "7.1.0"
+version = "7.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9013f1222db8a6d680f13a7ccdc60a781199cd09c2fa4eff58e728bb181757fc"
+checksum = "c42e33efc22a0650c311c2ef19115ce232583abbe80850bc8b66509ebef02de0"
 dependencies = [
  "aes",
  "bzip2",
@@ -1493,6 +1500,7 @@ dependencies = [
  "ppmd-rust",
  "sha1",
  "time",
+ "typed-path",
  "zeroize",
  "zopfli",
  "zstd",

{jpk_reader_rs-0.0.1 → jpk_reader_rs-0.0.2}/PKG-INFO

@@ -1,8 +1,11 @@
 Metadata-Version: 2.4
 Name: jpk-reader-rs
-Version: 0.0.1
+Version: 0.0.2
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Dist: pyarrow
 Requires-Python: >=3.8
+Project-URL: Homepage, https://github.com/bicarlsen/jpk_reader
+Project-URL: Issues, https://github.com/bicarlsen/jpk_reader/issues
+Project-URL: Source, https://github.com/bicarlsen/jpk_reader

{jpk_reader_rs-0.0.1 → jpk_reader_rs-0.0.2}/py/Cargo.toml

@@ -1,15 +1,16 @@
 [package]
 name = "jpk-reader-rs"
-version = "0.0.1"
+version = "0.0.2"
 edition = "2024"
 
 authors = ["Brian Carlsen <carlsen.bri@gmail.com>"]
 description = "Python bindings for JPK data reader."
-license = "GNU GPLv3"
+license = "MIT OR Apache-2.0"
 
 repository = "https://github.com/bicarlsen/jpk_reader"
 keywords = ["afm", "atomic force microscopy", "jpk", "bruker"]
 categories = ["science"]
+readme = "README.md"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [lib]

jpk_reader_rs-0.0.2/py/examples/qi_data.py

@@ -0,0 +1,12 @@
+# %%
+import jpk_reader_rs as jpk
+
+# DATA_PATH = "../../data/qi_data/qi_data-2_0-lg.jpk-qi-data"
+DATA_PATH = "s:\\_öffentlich_TAUSCHordner\\Mitarbeitende\\carlsen_brian\\degradation\\00-preliminary\\01/carlsen-asfaw-postdegradation-data-2026.01.08-16.35.28.552.jpk-qi-data"
+# %%
+reader = jpk.QIMapReader(DATA_PATH)
+# %%
+metadata = reader.all_metadata()
+# %%
+data = reader.all_data()
+# %%

jpk_reader_rs-0.0.2/py/jpk_reader_rs.pyi

@@ -0,0 +1,46 @@
+from typing import Optional
+import pyarrow
+
+class QIMapReader:
+    """A JPK QI Map data (`.jpk-qi-data`) reader."""
+
+    def __init__(self, path: str) -> None: ...
+    def len(self) -> int:
+        """
+        Returns:
+            int: Number of files in the archive.
+        """
+
+    def files(self) -> list[str]:
+        """Get all files names in the archive.
+
+        Returns:
+            list[str]: Sorted list of file names.
+        """
+
+    def all_data(self) -> pyarrow.RecordBatch:
+        """Gets all data from the file.
+
+        Returns:
+            pyarrow.RecordBatch: All file data.
+
+        Raises:
+            RuntimeError: If the file can not be read.
+        """
+
+    def all_metadata(
+        self,
+    ) -> dict[tuple[str, Optional[int], Optional[int]], dict[str, str]]:
+        """Get all metadata from the file.
+
+        Returns:
+            dict[tuple[str, Optional[int], Optional[int]], dict[str, str]]: Dictionary keyed by the property type.
+            Keys are of the form `(type, index, segment)`:
+            + ("dataset", None, None)
+            + ("shared_data", None, None)
+            + ("index", int, None)
+            + ("segment", int, int)
+
+        Raises:
+            RuntimeError: If the file can not be read.
+        """

jpk_reader_rs-0.0.2/py/src/lib.rs

@@ -0,0 +1,145 @@
+use arrow::{
+    array::{
+        ArrayRef, Float64Builder, ListBuilder, RecordBatch, StringBuilder, UInt8Builder,
+        UInt32Builder,
+    },
+    datatypes::{DataType, Field, Schema},
+    pyarrow::PyArrowType,
+};
+use jpk_reader::{self as jpk, ArchiveReader, qi_map::QIMapReader as _};
+use pyo3::{exceptions::PyRuntimeError, prelude::*, types::PyDict};
+use std::{borrow::Cow, path::PathBuf, sync::Arc};
+
+const CHANNEL_NAME_LEN_HINT: usize = 10;
+
+/// Python exports
+#[pymodule]
+mod jpk_reader_rs {
+    #[pymodule_export]
+    use super::QIMapReader;
+}
+
+#[pyclass]
+pub struct QIMapReader {
+    inner: jpk::qi_map::VersionedFileReader,
+}
+
+#[pymethods]
+impl QIMapReader {
+    #[new]
+    fn new(path: PathBuf) -> PyResult<Self> {
+        let reader = jpk::qi_map::FileReader::new_versioned(path)
+            .map_err(|err| PyRuntimeError::new_err(err.to_string()))?;
+        Ok(Self { inner: reader })
+    }
+
+    fn len(&self) -> PyResult<usize> {
+        Ok(self.inner.len())
+    }
+
+    fn files(&self) -> PyResult<Vec<&str>> {
+        const SEPARATOR: char = '/';
+        let mut files = self.inner.files();
+        let max_digits = files.len().ilog10() as usize + 1;
+        files.sort_by_key(|file| {
+            file.split(SEPARATOR)
+                .map(|component| {
+                    if let Ok(value) = component.parse::<usize>() {
+                        Cow::Owned(format!("{:0>width$}", value, width = max_digits))
+                    } else {
+                        Cow::Borrowed(component)
+                    }
+                })
+                .collect::<String>()
+        });
+
+        return Ok(files);
+    }
+
+    fn all_data(&mut self) -> PyResult<PyArrowType<RecordBatch>> {
+        let data = self
+            .inner
+            .query_data(&jpk::qi_map::DataQuery::select_all())
+            .map_err(|err| PyRuntimeError::new_err(err.to_string()))?;
+
+        let schema = Schema::new(vec![
+            Field::new("index", DataType::UInt32, false),
+            Field::new("segment", DataType::UInt8, false),
+            Field::new("channel", DataType::Utf8, false),
+            Field::new("data", DataType::new_list(DataType::Float64, true), false), // TODO: Can List be non-nullable?
+        ]);
+
+        let (index, values) = data.into_parts();
+        let mut idx_index = UInt32Builder::with_capacity(index.len());
+        let mut idx_segment = UInt8Builder::with_capacity(index.len());
+        let mut idx_channel =
+            StringBuilder::with_capacity(index.len(), index.len() * CHANNEL_NAME_LEN_HINT);
+        for idx in index {
+            let jpk::qi_map::DataIndex {
+                index,
+                segment,
+                channel,
+            } = idx;
+            idx_index.append_value(index);
+            idx_segment.append_value(segment);
+            idx_channel.append_value(channel);
+        }
+        let idx_i = idx_index.finish();
+        let idx_segment = idx_segment.finish();
+        let idx_channel = idx_channel.finish();
+
+        let mut value_builder = ListBuilder::with_capacity(Float64Builder::new(), values.len());
+        for data in values {
+            let data = data.into_iter().map(|value| Some(value));
+            value_builder.append_value(data);
+        }
+        let values = value_builder.finish();
+
+        let schema = Arc::new(schema);
+        let data = vec![
+            Arc::new(idx_i) as ArrayRef,
+            Arc::new(idx_segment) as ArrayRef,
+            Arc::new(idx_channel) as ArrayRef,
+            Arc::new(values) as ArrayRef,
+        ];
+        let records = RecordBatch::try_new(schema, data).unwrap();
+        Ok(records.into())
+    }
+
+    fn all_metadata(&mut self, py: Python) -> PyResult<Py<PyAny>> {
+        let data = self
+            .inner
+            .query_metadata(&jpk_reader::qi_map::MetadataQuery::All)
+            .map_err(|err| PyRuntimeError::new_err(err.to_string()))?;
+
+        let dict = PyDict::new(py);
+        for (index, properties) in data.into_iter() {
+            let props = PyDict::new(py);
+            for (key, value) in properties.into_iter() {
+                props.set_item(key, value)?;
+            }
+
+            let mut idx = ("", None, None);
+            match index {
+                jpk_reader::qi_map::MetadataIndex::Dataset => {
+                    idx.0 = "dataset";
+                }
+                jpk_reader::qi_map::MetadataIndex::SharedData => {
+                    idx.0 = "shared_data";
+                }
+                jpk_reader::qi_map::MetadataIndex::Index(index) => {
+                    idx.0 = "index";
+                    idx.1 = Some(index);
+                }
+                jpk_reader::qi_map::MetadataIndex::Segment { index, segment } => {
+                    idx.0 = "segment";
+                    idx.1 = Some(index);
+                    idx.2 = Some(segment);
+                }
+            };
+            dict.set_item(idx, props)?;
+        }
+
+        Ok(dict.into())
+    }
+}

{jpk_reader_rs-0.0.1 → jpk_reader_rs-0.0.2}/pyproject.toml

@@ -14,6 +14,11 @@ dynamic = ["version"]
 
 dependencies = ["pyarrow"]
 
+[project.urls]
+Issues = "https://github.com/bicarlsen/jpk_reader/issues"
+Source = "https://github.com/bicarlsen/jpk_reader"
+Homepage = "https://github.com/bicarlsen/jpk_reader"
+
 [tool]
 
 [tool.maturin]

{jpk_reader_rs-0.0.1 → jpk_reader_rs-0.0.2}/rs/Cargo.toml

@@ -12,13 +12,13 @@ keywords = ["afm", "atomic force microscopy", "jpk", "bruker"]
 categories = ["science"]
 
 [dependencies]
-derive_more = { workspace = true, features = ["from", "deref"] }
+derive_more = { workspace = true, features = ["from", "deref", "deref_mut"] }
 rayon = "1.11.0"
 tracing = { workspace = true, optional = true }
 tracing-subscriber = { workspace = true, features = [
     "env-filter",
 ], optional = true }
-zip = "7.1"
+zip = "7.2"
 
 [dev-dependencies]
 tracing-test = { workspace = true }

jpk_reader_rs-0.0.2/rs/src/lib.rs

@@ -0,0 +1,13 @@
+use std::path::Path;
+use zip;
+
+pub mod properties;
+pub mod qi_map;
+
+pub trait ArchiveReader {
+    /// List of files in the archive.
+    fn files(&self) -> Vec<&str>;
+
+    /// Number of files in the archive.
+    fn len(&self) -> usize;
+}

{jpk_reader_rs-0.0.1 → jpk_reader_rs-0.0.2}/rs/src/properties.rs

@@ -62,7 +62,17 @@ impl Properties {
     }
 }
 
+impl IntoIterator for Properties {
+    type Item = (String, String);
+    type IntoIter = std::vec::IntoIter<Self::Item>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.properties.into_iter()
+    }
+}
+
 /// The format of the file was invalid.
+#[derive(Debug)]
 pub struct InvalidFormat;
 
 pub enum PropertyError {