evaluatio 0.1.0__tar.gz

evaluatio-0.1.0/Cargo.lock

@@ -0,0 +1,236 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "autocfg"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+
+[[package]]
+name = "cc"
+version = "1.2.50"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f50d563227a1c37cc0a263f64eca3334388c01c5e4c4861a9def205c614383c"
+dependencies = [
+ "find-msvc-tools",
+ "shlex",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "either"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+
+[[package]]
+name = "evaluatio-bindings"
+version = "0.1.0"
+dependencies = [
+ "evaluatio-core",
+ "pyo3",
+]
+
+[[package]]
+name = "evaluatio-core"
+version = "0.1.0"
+dependencies = [
+ "itertools",
+ "pyo3",
+]
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a3076410a55c90011c298b04d0cfa770b00fa04e1e3c97d3f6c9de105a03844"
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "indoc"
+version = "2.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "79cf5c93f93228cf8efb3ba362535fb11199ac548a09ce117c9b1adc3030d706"
+dependencies = [
+ "rustversion",
+]
+
+[[package]]
+name = "itertools"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.182"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6800badb6cb2082ffd7b6a67e6125bb39f18782f793520caee8cb8846be06112"
+
+[[package]]
+name = "memoffset"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+
+[[package]]
+name = "portable-atomic"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "pyo3"
+version = "0.23.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7778bffd85cf38175ac1f545509665d0b9b92a198ca7941f131f85f7a4f9a872"
+dependencies = [
+ "cfg-if",
+ "indoc",
+ "libc",
+ "memoffset",
+ "once_cell",
+ "portable-atomic",
+ "pyo3-build-config",
+ "pyo3-ffi",
+ "pyo3-macros",
+ "unindent",
+]
+
+[[package]]
+name = "pyo3-build-config"
+version = "0.23.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94f6cbe86ef3bf18998d9df6e0f3fc1050a8c5efa409bf712e661a4366e010fb"
+dependencies = [
+ "once_cell",
+ "python3-dll-a",
+ "target-lexicon",
+]
+
+[[package]]
+name = "pyo3-ffi"
+version = "0.23.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e9f1b4c431c0bb1c8fb0a338709859eed0d030ff6daa34368d3b152a63dfdd8d"
+dependencies = [
+ "libc",
+ "pyo3-build-config",
+]
+
+[[package]]
+name = "pyo3-macros"
+version = "0.23.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fbc2201328f63c4710f68abdf653c89d8dbc2858b88c5d88b0ff38a75288a9da"
+dependencies = [
+ "proc-macro2",
+ "pyo3-macros-backend",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pyo3-macros-backend"
+version = "0.23.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fca6726ad0f3da9c9de093d6f116a93c1a38e417ed73bf138472cf4064f72028"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "pyo3-build-config",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "python3-dll-a"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d381ef313ae70b4da5f95f8a4de773c6aa5cd28f73adec4b4a31df70b66780d8"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21b2ebcf727b7760c461f091f9f0f539b77b8e87f2fd88131e7f1b433b3cece4"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "syn"
+version = "2.0.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.12.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "unindent"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3"

evaluatio-0.1.0/Cargo.toml

@@ -0,0 +1,3 @@
+[workspace]
+resolver = "3"
+members = ["evaluatio-core", "evaluatio-bindings"]

evaluatio-0.1.0/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: evaluatio
+Version: 0.1.0
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+License-File: LICENSE
+Summary: A library that contains computationally efficient metrics for the valuation of different NLP systems
+Author-email: Preben Vangberg <prv21fgt@bangor.ac.uk>
+License-Expression: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: homepage, https://codeberg.org/prvinspace/evaluatio
+Project-URL: repository, https://codeberg.org/prvinspace/evaluatio
+
+# Evaluatio
+
+***Note: The library is under development, so things are likely to change, especially function signatures.***
+
+Evaluatio is a library that contains computationally efficient metrics for the valuation of different NLP systems.
+It is the continuation of the [`universal-edit-distance`](https://gitlab.com/prebens-phd-adventures/universal-edit-distance) project, but was renamed and restructured due to the project outgrowing its original purpose.
+
+## Etymology
+The name `evaluatio` is a Latin noun and means "evaluation". It also doubles as the English verb "to evaluate" with the Welsh verbal derivational suffix `-io`, so it could also be Welsh slang for "to evaluate".
+
+## Components
+
+### [evaluatio-core](./evaluatio-core/README.md)
+`evaluatio-core` is a standalone Rust library that implements certain metrics and functions to improve the performance of the main library. This can be used by other Rust projects without requiring PyO3.
+
+### [evaluatio-bindings](./evaluatio-bindings/README.md)
+`evaluatio-bindings` contains the Py03 bindings between `evaluatio-core` and the main Python library. It simply exposes the functions and classes in the `evaluatio-core` to the Python library while also containing some helper functions to ensure that Python types are handled properly. All classes and functions are exported to a single Python module.
+
+### python-src
+`python-src` contains the main Python library. It contains wrappers for `evaluatio-bindings` to ensure that functions are documented, type-annotated, and sorted into different organised modules.
+
+## Contribute to the project
+There is always room for improvements, new metrics, new functionality, etc. If you have any suggestions or requests please feel free to add an issue! The main repository for the project can be found at [https://codeberg.org/prvinspace/evaluatio](codeberg.org/prvinspace/evaluatio)
+
+## Maintainer
+
+The project is maintained by Preben Vangberg &lt;prv21fgt@bangor.ac.uk&gt;.

evaluatio-0.1.0/README.md

@@ -0,0 +1,27 @@
+# Evaluatio
+
+***Note: The library is under development, so things are likely to change, especially function signatures.***
+
+Evaluatio is a library that contains computationally efficient metrics for the valuation of different NLP systems.
+It is the continuation of the [`universal-edit-distance`](https://gitlab.com/prebens-phd-adventures/universal-edit-distance) project, but was renamed and restructured due to the project outgrowing its original purpose.
+
+## Etymology
+The name `evaluatio` is a Latin noun and means "evaluation". It also doubles as the English verb "to evaluate" with the Welsh verbal derivational suffix `-io`, so it could also be Welsh slang for "to evaluate".
+
+## Components
+
+### [evaluatio-core](./evaluatio-core/README.md)
+`evaluatio-core` is a standalone Rust library that implements certain metrics and functions to improve the performance of the main library. This can be used by other Rust projects without requiring PyO3.
+
+### [evaluatio-bindings](./evaluatio-bindings/README.md)
+`evaluatio-bindings` contains the Py03 bindings between `evaluatio-core` and the main Python library. It simply exposes the functions and classes in the `evaluatio-core` to the Python library while also containing some helper functions to ensure that Python types are handled properly. All classes and functions are exported to a single Python module.
+
+### python-src
+`python-src` contains the main Python library. It contains wrappers for `evaluatio-bindings` to ensure that functions are documented, type-annotated, and sorted into different organised modules.
+
+## Contribute to the project
+There is always room for improvements, new metrics, new functionality, etc. If you have any suggestions or requests please feel free to add an issue! The main repository for the project can be found at [https://codeberg.org/prvinspace/evaluatio](codeberg.org/prvinspace/evaluatio)
+
+## Maintainer
+
+The project is maintained by Preben Vangberg <prv21fgt@bangor.ac.uk>.

evaluatio-0.1.0/evaluatio-bindings/.gitignore

@@ -0,0 +1,72 @@
+/target
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+.pytest_cache/
+*.py[cod]
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+.venv/
+env/
+bin/
+build/
+develop-eggs/
+dist/
+eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+include/
+man/
+venv/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+pip-selfcheck.json
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.cache
+nosetests.xml
+coverage.xml
+
+# Translations
+*.mo
+
+# Mr Developer
+.mr.developer.cfg
+.project
+.pydevproject
+
+# Rope
+.ropeproject
+
+# Django stuff:
+*.log
+*.pot
+
+.DS_Store
+
+# Sphinx documentation
+docs/_build/
+
+# PyCharm
+.idea/
+
+# VSCode
+.vscode/
+
+# Pyenv
+.python-version

evaluatio-0.1.0/evaluatio-bindings/Cargo.toml

@@ -0,0 +1,27 @@
+# [package]
+# name = "evaluatio_bindings"
+# version = "0.1.0"
+# edition = "2021"
+
+# # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+# [lib]
+# name = "evaluatio_bindings"
+# crate-type = ["cdylib"]
+
+# [dependencies]
+# pyo3 = "0.23.3"
+# evaluatio-core = { path = "../evaluatio-core", features = ["python"] }
+
+[package]
+name = "evaluatio-bindings"
+version = "0.1.0"
+edition = "2021"
+readme = "README.md"
+
+[lib]
+name = "_bindings"
+crate-type = ["cdylib"]
+
+[dependencies]
+pyo3 = { version = "0.23.3", features = ["extension-module", "abi3", "abi3-py38", "generate-import-lib"] }
+evaluatio-core = { path = "../evaluatio-core", features = ["python"] }

evaluatio-0.1.0/evaluatio-bindings/README.md

@@ -0,0 +1,5 @@
+# evaluatio-bindings
+
+This component contains the PyO3 bindings for [evaluatio-core](../evaluatio-core/README.md).
+The bindings are exported to a single module located at `evaluatio._bindings`.
+These bindings are used/wrapped by functions in the main [Python package](../python-src/).

evaluatio-0.1.0/evaluatio-bindings/src/base.rs

@@ -0,0 +1,104 @@
+use pyo3::{
+    types::{PyAnyMethods, PyList},
+    Bound, FromPyObject, IntoPyObjectExt, Py, PyAny, PyResult, Python,
+};
+
+#[derive(Debug)]
+pub enum EditDistanceItem {
+    String(String),
+    Int(i64),
+    Float(f64),
+    Bool(bool),
+    Object(Py<PyAny>),
+}
+
+impl PartialEq for EditDistanceItem {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (EditDistanceItem::String(a), EditDistanceItem::String(b)) => a == b,
+            (EditDistanceItem::Int(a), EditDistanceItem::Int(b)) => a == b,
+            (EditDistanceItem::Float(a), EditDistanceItem::Float(b)) => a == b,
+            (EditDistanceItem::Bool(a), EditDistanceItem::Bool(b)) => a == b,
+            (EditDistanceItem::Object(a), EditDistanceItem::Object(b)) => {
+                // Use Python's __eq__ by acquiring the GIL
+                Python::with_gil(|py| {
+                    // Bind the Py<PyAny> to this thread-local context
+                    let a_bound = a.bind(py);
+                    let b_bound = b.bind(py);
+                    a_bound.eq(b_bound).unwrap_or(false)
+                })
+            }
+            // If types don't match, defer to Python's eq function
+            (a, b) => Python::with_gil(|py| {
+                let to_py = |item: &EditDistanceItem| -> Option<Py<PyAny>> {
+                    match item {
+                        EditDistanceItem::String(s) => s.into_py_any(py).ok(),
+                        EditDistanceItem::Int(i) => i.into_py_any(py).ok(),
+                        EditDistanceItem::Float(f) => f.into_py_any(py).ok(),
+                        EditDistanceItem::Bool(b) => b.into_py_any(py).ok(),
+                        EditDistanceItem::Object(obj) => Some(obj.clone_ref(py)),
+                    }
+                };
+
+                match (to_py(a), to_py(b)) {
+                    // if both are fine, defer to Python, otherwise assume False
+                    (Some(a), Some(b)) => a.bind(py).eq(b.bind(py)).unwrap_or(false),
+                    _ => false,
+                }
+            }),
+        }
+    }
+}
+
+impl<'source> FromPyObject<'source> for EditDistanceItem {
+    fn extract_bound(obj: &Bound<'source, PyAny>) -> PyResult<Self> {
+        // Try to extract each supported type in order
+        if let Ok(val) = obj.extract::<String>() {
+            Ok(EditDistanceItem::String(val))
+        } else if let Ok(val) = obj.extract::<i64>() {
+            Ok(EditDistanceItem::Int(val))
+        } else if let Ok(val) = obj.extract::<f64>() {
+            Ok(EditDistanceItem::Float(val))
+        } else if let Ok(val) = obj.extract::<bool>() {
+            Ok(EditDistanceItem::Bool(val))
+        } else {
+            // For any other type, store the Python object for later comparison
+            let py_obj = obj.clone().unbind();
+            Ok(EditDistanceItem::Object(py_obj))
+        }
+    }
+}
+
+pub(crate) fn convert_to_edit_distance_vec(
+    items: &Vec<Bound<PyAny>>,
+) -> PyResult<Vec<EditDistanceItem>> {
+    items
+        .iter()
+        .map(|item| item.extract::<EditDistanceItem>())
+        .collect()
+}
+
+pub fn convert_to_nested_edit_distance_item_vec(
+    pylist: &Bound<PyList>,
+) -> PyResult<Vec<Vec<EditDistanceItem>>> {
+    // Create vectors to store the converted data
+    let mut vecs: Vec<Vec<EditDistanceItem>> = Vec::with_capacity(pylist.len()?);
+
+    // Extract the data from Python
+    for i in 0..pylist.len()? {
+        let item = pylist.get_item(i)?;
+        let list = item.downcast::<PyList>()?;
+
+        let mut inner: Vec<EditDistanceItem> = Vec::with_capacity(list.len()?);
+
+        // Extract items from the inner lists, converting to EditDistanceItem
+        for j in 0..list.len()? {
+            inner.push(list.get_item(j)?.extract::<EditDistanceItem>()?);
+        }
+
+        vecs.push(inner);
+    }
+
+    // Create the vectors of references to vectors that the edit_distance function expects
+    Ok(vecs)
+}

evaluatio-0.1.0/evaluatio-bindings/src/lib.rs

@@ -0,0 +1,36 @@
+use pyo3::prelude::*;
+mod base;
+mod metrics;
+use metrics::*;
+
+/// A Python module implemented in Rust.
+#[pymodule]
+fn _bindings(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    // Character error rate
+    m.add_function(wrap_pyfunction!(cer::character_edit_distance_array_py, m)?)?;
+    m.add_function(wrap_pyfunction!(cer::character_error_rate_py, m)?)?;
+    m.add_function(wrap_pyfunction!(cer::character_error_rate_array_py, m)?)?;
+
+    // Match error rate
+    //m.add_function(wrap_pyfunction!(mer::match_error_rate_array_py, m)?)?;
+    //m.add_function(wrap_pyfunction!(mer::hits_array_py, m)?)?;
+
+    // Optimal alignment
+    m.add_function(wrap_pyfunction!(alignment::optimial_alignment_py, m)?)?;
+    m.add_class::<evaluatio_core::metrics::alignment::Alignment>()?;
+
+    // Points of interest error rate
+    m.add_function(wrap_pyfunction!(pier::poi_edit_distance_py, m)?)?;
+    m.add_function(wrap_pyfunction!(pier::poi_error_rate_py, m)?)?;
+
+    // Universal error rate
+    m.add_function(wrap_pyfunction!(uer::universal_edit_distance_array_py, m)?)?;
+    m.add_function(wrap_pyfunction!(uer::universal_error_rate_array_py, m)?)?;
+
+    // Word error rate
+    m.add_function(wrap_pyfunction!(wer::word_edit_distance_array_py, m)?)?;
+    m.add_function(wrap_pyfunction!(wer::word_error_rate_py, m)?)?;
+    m.add_function(wrap_pyfunction!(wer::word_error_rate_array_py, m)?)?;
+
+    Ok(())
+}

evaluatio-0.1.0/evaluatio-bindings/src/metrics/alignment.rs

@@ -0,0 +1,16 @@
+use evaluatio_core::metrics::alignment;
+use pyo3::{pyfunction, Bound, PyAny, PyResult};
+
+use crate::base::{convert_to_edit_distance_vec, EditDistanceItem};
+
+#[pyfunction(name = "optimal_alignment")]
+pub fn optimial_alignment_py(
+    predictions: Vec<Bound<PyAny>>,
+    references: Vec<Bound<PyAny>>,
+) -> PyResult<Vec<alignment::Alignment>> {
+    let pred: Vec<EditDistanceItem> = convert_to_edit_distance_vec(&predictions)?;
+    let ref_: Vec<EditDistanceItem> = convert_to_edit_distance_vec(&references)?;
+
+    let result = alignment::optimial_aligment(&pred, &ref_);
+    Ok(result)
+}

evaluatio-0.1.0/evaluatio-bindings/src/metrics/cer.rs

@@ -0,0 +1,32 @@
+use evaluatio_core::metrics::cer;
+use pyo3::{pyfunction, PyResult};
+
+#[pyfunction(name = "character_error_rate_array")]
+pub fn character_error_rate_array_py(
+    predictions: Vec<String>,
+    references: Vec<String>,
+) -> PyResult<Vec<f64>> {
+    let left_vec: Vec<&str> = predictions.iter().map(|x| x.as_str()).collect();
+    let right_vec: Vec<&str> = references.iter().map(|x| x.as_str()).collect();
+    let result = cer::character_error_rate_array(&left_vec, &right_vec);
+    Ok(result)
+}
+
+#[pyfunction(name = "character_edit_distance_array")]
+pub fn character_edit_distance_array_py(
+    predictions: Vec<String>,
+    references: Vec<String>,
+) -> PyResult<Vec<usize>> {
+    let left_vec: Vec<&str> = predictions.iter().map(|x| x.as_str()).collect();
+    let right_vec: Vec<&str> = references.iter().map(|x| x.as_str()).collect();
+    let result = cer::character_edit_distance_array(&left_vec, &right_vec);
+    Ok(result)
+}
+
+#[pyfunction(name = "character_error_rate")]
+pub fn character_error_rate_py(predictions: Vec<String>, references: Vec<String>) -> PyResult<f64> {
+    let left_vec: Vec<&str> = predictions.iter().map(|x| x.as_str()).collect();
+    let right_vec: Vec<&str> = references.iter().map(|x| x.as_str()).collect();
+    let result = cer::character_error_rate(&left_vec, &right_vec);
+    Ok(result)
+}

evaluatio-0.1.0/evaluatio-bindings/src/metrics/mod.rs

@@ -0,0 +1,5 @@
+pub mod alignment;
+pub mod cer;
+pub mod pier;
+pub mod uer;
+pub mod wer;

evaluatio-0.1.0/evaluatio-bindings/src/metrics/pier.rs

@@ -0,0 +1,42 @@
+use crate::base::{
+    convert_to_edit_distance_vec, convert_to_nested_edit_distance_item_vec, EditDistanceItem,
+};
+use evaluatio_core::metrics::pier;
+use pyo3::types::PyList;
+use pyo3::{pyfunction, Bound, PyAny, PyResult};
+
+#[pyfunction(name = "poi_edit_distance")]
+pub fn poi_edit_distance_py(
+    predictions: Vec<Bound<PyAny>>,
+    references: Vec<Bound<PyAny>>,
+    points_of_interest: Vec<bool>,
+) -> PyResult<usize> {
+    let pred: Vec<EditDistanceItem> = convert_to_edit_distance_vec(&predictions)?;
+    let ref_: Vec<EditDistanceItem> = convert_to_edit_distance_vec(&references)?;
+
+    let result = pier::poi_edit_distance(&pred, &ref_, &points_of_interest);
+    Ok(result)
+}
+
+#[pyfunction(name = "poi_error_rate")]
+pub fn poi_error_rate_py(
+    predictions: &Bound<PyList>,
+    references: &Bound<PyList>,
+    points_of_interest: Vec<Vec<bool>>,
+) -> PyResult<f64> {
+    // Create vectors to store the converted data
+    let pred_vecs: Vec<Vec<EditDistanceItem>> =
+        convert_to_nested_edit_distance_item_vec(predictions)?;
+    let ref_vecs: Vec<Vec<EditDistanceItem>> =
+        convert_to_nested_edit_distance_item_vec(references)?;
+
+    // Create the vectors of references to vectors that the edit_distance function expects
+    let pred_vec_refs: Vec<&[EditDistanceItem]> = pred_vecs.iter().map(|v| v.as_slice()).collect();
+    let ref_vec_refs: Vec<&[EditDistanceItem]> = ref_vecs.iter().map(|v| v.as_slice()).collect();
+    let poi_vec_refs: Vec<&[bool]> = points_of_interest.iter().map(|v| v.as_slice()).collect();
+
+    // Call a modified edit_distance implementation that works with EditDistanceItem
+    let result = pier::poi_error_rate(&pred_vec_refs, &ref_vec_refs, &poi_vec_refs);
+
+    Ok(result)
+}