First attempt at a reader with few supported types

Cargo.toml

···
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [lib]
-name = "py_oxyroot"
+name = "oxyroot"
 crate-type = ["cdylib"]
 
 [dependencies]
-pyo3 = "0.25.0"
+numpy = "0.26.0"
+oxyroot = "0.1.25"
+pyo3 = { version = "0.26.0", features = ["abi3-py38"] }

pyproject.toml

···
 build-backend = "maturin"
 
 [project]
-name = "py-oxyroot"
+name = "oxyroot"
 requires-python = ">=3.8"
 classifiers = [
     "Programming Language :: Rust",
···
 [project.optional-dependencies]
 tests = [
     "pytest",
+    "numpy",
+    "uproot",
 ]
 [tool.maturin]
 python-source = "python"

python/oxyroot/__init__.py

···
+from .oxyroot import *
+
+__doc__: str = oxyroot.__doc__
+__version__: str = oxyroot.version()
+
+if hasattr(oxyroot, "__all__"):
+    __all__ = oxyroot.__all__

python/py_oxyroot/__init__.py

···
-from .py_oxyroot import *
-
-
-__doc__ = py_oxyroot.__doc__
-if hasattr(py_oxyroot, "__all__"):
-    __all__ = py_oxyroot.__all__

python/tests/read_ntuples.py

···
+import oxyroot
+
+if __name__ == '__main__':
+    import uproot
+    import numpy as np
+    import time
+
+    file_name = "ntuples.root"
+    tree_name = 'mu_mc'
+
+    up_start_time = time.time()
+    up_tree = uproot.open(file_name)[tree_name]
+    for branch in up_tree.keys():
+        # print(branch, up_tree[branch].typename)
+        if up_tree[branch].typename != "std::string":
+            up_values = up_tree[branch].array(library="np")
+            print(f"Uproot read {branch} into a {type(up_values)} and it has a mean of {np.nanmean(up_values):.2f}") 
+    up_end_time = time.time()
+    
+    print("\n")
+
+    oxy_start_time = time.time()
+    oxy_branches = oxyroot.read_root(file_name, tree_name=tree_name)
+    for branch in oxy_branches:
+        oxyroot.read_root(file_name, tree_name=tree_name, branch=branch)
+        oxy_values = oxyroot.read_root(file_name, tree_name=tree_name, branch=branch)
+        if type(oxy_values) is np.ndarray:
+            print(f"Oxyroot read {branch} into a {type(oxy_values)} and it has a mean of {np.nanmean(oxy_values):.2f}")
+        else:
+            print(f"Oxyroot read {branch} into a {type(oxy_values)} and it has a length of {len(oxy_values)}")
+    oxy_end_time = time.time()
+
+    print("\n Total time")
+    print(f"Uproot took: {up_end_time - up_start_time:.3}s")
+    print(f"Oxyroot took: {oxy_end_time - oxy_start_time:.3}s")

python/tests/test_all.py

···
-import pytest
-import py_oxyroot
-
-
-def test_sum_as_string():
-    assert py_oxyroot.sum_as_string(1, 1) == "2"

python/tests/test_read_from_uproot.py

···
+import pytest
+import oxyroot
+import uproot
+import numpy as np
+import os
+
+def test_read_from_uproot():
+    # Create a dummy ROOT file for testing
+
+    input = np.array([4.1, 5.2, 6.3])
+    file_name = "test.root"
+
+    with uproot.recreate(file_name) as f:
+        f.mktree("tree1", {"branch1": np.float64})
+        f["tree1"].extend({"branch1": input})
+        
+
+    output = oxyroot.read_root(file_name, tree_name="tree1", branch="branch1")
+    assert(type(output) is np.ndarray)
+    assert(np.array_equal(input, output))
+
+    os.remove(file_name)

src/lib.rs

···
-use pyo3::prelude::*;
+use ::oxyroot::{Named, RootFile};
+use numpy::ToPyArray;
+use pyo3::{exceptions::PyValueError, prelude::*, types::PyModule, IntoPyObjectExt};
+
+#[pyfunction]
+fn version() -> PyResult<String> {
+    Ok(env!("CARGO_PKG_VERSION").to_string())
+}
 
-/// Formats the sum of two numbers as string.
+/// Read a ROOT file and return the list of trees, the branches of a tree, or the values of a branch.
 #[pyfunction]
-fn sum_as_string(a: usize, b: usize) -> PyResult<String> {
-    Ok((a + b).to_string())
+#[pyo3(signature = (path, tree_name = None, branch = None))]
+fn read_root(
+    path: String,
+    tree_name: Option<String>,
+    branch: Option<String>,
+) -> PyResult<Py<PyAny>> {
+    let mut file = RootFile::open(&path).unwrap();
+    let keys: Vec<String> = file
+        .keys()
+        .into_iter()
+        .map(|k| k.name().to_string())
+        .collect();
+
+    Python::attach(|py| -> PyResult<Py<PyAny>> {
+        match tree_name {
+            Some(name) => {
+                if let Ok(tree) = file.get_tree(&name) {
+                    let branches_available: Vec<String> =
+                        tree.branches().map(|b| b.name().to_string()).collect();
+
+                    match branch {
+                        Some(bs) => {
+                            if let Some(branch) = tree.branch(&bs) {
+                                match branch.item_type_name().as_str() {
+                                    "f32" => {
+                                        let data =
+                                            branch.as_iter::<f32>().unwrap().collect::<Vec<_>>();
+                                        Ok(data.to_pyarray(py).into_py_any(py).unwrap())
+                                    }
+                                    "double" => {
+                                        let data =
+                                            branch.as_iter::<f64>().unwrap().collect::<Vec<_>>();
+                                        Ok(data.to_pyarray(py).into_py_any(py).unwrap())
+                                    }
+                                    "int32_t" => {
+                                        let data =
+                                            branch.as_iter::<i32>().unwrap().collect::<Vec<_>>();
+                                        Ok(data.to_pyarray(py).into_py_any(py).unwrap())
+                                    }
+                                    "int64_t" => {
+                                        let data =
+                                            branch.as_iter::<i64>().unwrap().collect::<Vec<_>>();
+                                        Ok(data.to_pyarray(py).into_py_any(py).unwrap())
+                                    }
+                                    "uint32_t" => {
+                                        let data =
+                                            branch.as_iter::<u32>().unwrap().collect::<Vec<_>>();
+                                        Ok(data.to_pyarray(py).into_py_any(py).unwrap())
+                                    }
+                                    "uint64_t" => {
+                                        let data =
+                                            branch.as_iter::<u64>().unwrap().collect::<Vec<_>>();
+                                        Ok(data.to_pyarray(py).into_py_any(py).unwrap())
+                                    }
+                                    "string" => {
+                                        let data =
+                                            branch.as_iter::<String>().unwrap().collect::<Vec<_>>();
+                                        Ok(data.into_py_any(py).unwrap())
+                                    }
+                                    other => Err(PyValueError::new_err(format!(
+                                        "Unsupported branch type: {}",
+                                        other
+                                    ))),
+                                }
+                            } else {
+                                Err(PyValueError::new_err(format!(
+                                    "Branch '{}' not found. Available branches are: {:?}",
+                                    bs, branches_available
+                                )))
+                            }
+                        }
+                        None => Ok(branches_available.into_py_any(py).unwrap()),
+                    }
+                } else {
+                    Err(PyValueError::new_err(format!(
+                        "Tree '{}' not found. Available trees are: {:?}",
+                        name, keys
+                    )))
+                }
+            }
+            None => Ok(keys.into_py_any(py).unwrap()),
+        }
+    })
 }
 
-/// A Python module implemented in Rust.
+/// A Python module to read root files implemented in Rust.
 #[pymodule]
-fn py_oxyroot(m: &Bound<'_, PyModule>) -> PyResult<()> {
-    m.add_function(wrap_pyfunction!(sum_as_string, m)?)?;
+fn oxyroot(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_function(wrap_pyfunction!(version, m)?)?;
+    m.add_function(wrap_pyfunction!(read_root, m)?)?;
     Ok(())
 }