ocr-stringdist 0.0.1__tar.gz → 0.0.3__tar.gz

{ocr_stringdist-0.0.1 → ocr_stringdist-0.0.3}/.gitignore

@@ -17,6 +17,7 @@ site/
 target/
 Cargo.lock
 .venv
+.vscode
 
 # Byte-compiled / optimized / DLL files
 __pycache__/

{ocr_stringdist-0.0.1 → ocr_stringdist-0.0.3}/Cargo.lock

@@ -67,10 +67,9 @@ dependencies = [
 
 [[package]]
 name = "ocr_stringdist"
-version = "0.0.1"
+version = "0.0.3"
 dependencies = [
  "ahash",
- "once_cell",
  "pyo3",
  "smallvec",
 ]

{ocr_stringdist-0.0.1 → ocr_stringdist-0.0.3}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ocr_stringdist"
-version = "0.0.1"
+version = "0.0.3"
 edition = "2021"
 description = "String distances considering OCR errors."
 authors = ["Niklas von Moers <niklasvmoers@protonmail.com>"]
@@ -16,7 +16,6 @@ crate-type = ["cdylib"]
 [dependencies]
 pyo3 = { version = "0.24.0", features = [] }
 ahash = "^0.8"
-once_cell = "1.21.3"
 smallvec = "1.15.0"
 
 [features]

ocr_stringdist-0.0.3/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Niklas von Moers
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ocr_stringdist-0.0.3/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: ocr_stringdist
+Version: 0.0.3
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Operating System :: OS Independent
+License-File: LICENSE
+Summary: String distances considering OCR errors.
+Author: Niklas von Moers <niklasvmoers@protonmail.com>
+Author-email: Niklas von Moers <niklasvmoers@protonmail.com>
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: repository, https://github.com/NiklasvonM/ocr-stringdist
+
+# OCR-StringDist
+
+A Python library for string distance calculations that account for common OCR (optical character recognition) errors.
+
+[![PyPI](https://img.shields.io/badge/PyPI-Package-blue)](https://pypi.org/project/ocr-stringdist/)
+[![License](https://img.shields.io/badge/License-MIT-green)](LICENSE)
+
+## Overview
+
+OCR-StringDist provides specialized string distance algorithms that accommodate for optical character recognition (OCR) errors. Unlike traditional string comparison algorithms, OCR-StringDist considers common OCR confusions (like "0" vs "O", "6" vs "G", etc.) when calculating distances between strings.
+
+> **Note:** This project is in early development. APIs may change in future releases.
+
+## Installation
+
+```bash
+pip install ocr-stringdist
+```
+
+## Features
+
+- **Weighted Levenshtein Distance**: An adaptation of the classic Levenshtein algorithm with custom substitution costs for character pairs that are commonly confused in OCR models.
+- **Pre-defined OCR Distance Map**: A built-in distance map for common OCR confusions (e.g., "0" vs "O", "1" vs "l", "5" vs "S").
+- **Customizable Cost Maps**: Create your own substitution cost maps for specific OCR systems or domains.
+
+## Usage
+
+```python
+import ocr_stringdist as osd
+
+# Using default OCR distance map
+distance = osd.weighted_levenshtein_distance("OCR5", "OCRS")
+print(f"Distance between 'OCR5' and 'OCRS': {distance}")  # Will be less than 1.0
+
+# Custom cost map
+custom_map = {("f", "t"): 0.2, ("m", "n"): 0.1}
+distance = osd.weighted_levenshtein_distance(
+    "first", "tirst",
+    cost_map=custom_map,
+    symmetric=True,
+    default_cost=1.0
+)
+print(f"Distance with custom map: {distance}")
+```
+
+## Acknowledgements
+
+This project is inspired by [jellyfish](https://github.com/jamesturk/jellyfish), providing the base implementations of the algorithms used here.
+

ocr_stringdist-0.0.3/README.md

@@ -0,0 +1,48 @@
+# OCR-StringDist
+
+A Python library for string distance calculations that account for common OCR (optical character recognition) errors.
+
+[![PyPI](https://img.shields.io/badge/PyPI-Package-blue)](https://pypi.org/project/ocr-stringdist/)
+[![License](https://img.shields.io/badge/License-MIT-green)](LICENSE)
+
+## Overview
+
+OCR-StringDist provides specialized string distance algorithms that accommodate for optical character recognition (OCR) errors. Unlike traditional string comparison algorithms, OCR-StringDist considers common OCR confusions (like "0" vs "O", "6" vs "G", etc.) when calculating distances between strings.
+
+> **Note:** This project is in early development. APIs may change in future releases.
+
+## Installation
+
+```bash
+pip install ocr-stringdist
+```
+
+## Features
+
+- **Weighted Levenshtein Distance**: An adaptation of the classic Levenshtein algorithm with custom substitution costs for character pairs that are commonly confused in OCR models.
+- **Pre-defined OCR Distance Map**: A built-in distance map for common OCR confusions (e.g., "0" vs "O", "1" vs "l", "5" vs "S").
+- **Customizable Cost Maps**: Create your own substitution cost maps for specific OCR systems or domains.
+
+## Usage
+
+```python
+import ocr_stringdist as osd
+
+# Using default OCR distance map
+distance = osd.weighted_levenshtein_distance("OCR5", "OCRS")
+print(f"Distance between 'OCR5' and 'OCRS': {distance}")  # Will be less than 1.0
+
+# Custom cost map
+custom_map = {("f", "t"): 0.2, ("m", "n"): 0.1}
+distance = osd.weighted_levenshtein_distance(
+    "first", "tirst",
+    cost_map=custom_map,
+    symmetric=True,
+    default_cost=1.0
+)
+print(f"Distance with custom map: {distance}")
+```
+
+## Acknowledgements
+
+This project is inspired by [jellyfish](https://github.com/jamesturk/jellyfish), providing the base implementations of the algorithms used here.

ocr_stringdist-0.0.3/example.py

@@ -0,0 +1,41 @@
+from ocr_stringdist import weighted_levenshtein_distance
+from icecream import ic
+
+ic(
+    weighted_levenshtein_distance(
+        "12345G",
+        "123456",
+        # Default costs
+    ),
+)
+
+ic(
+    weighted_levenshtein_distance(
+        "12345G",
+        "123456",
+        {("G", "6"): 0.1},  # Custom cost_map
+    )
+)
+
+ic(
+    weighted_levenshtein_distance(
+        "ABCDE",
+        "XBCDE",
+        cost_map={},
+        default_cost=0.8,  # Lower default substitution cost (default is 1.0)
+    )
+)
+
+ic(
+    weighted_levenshtein_distance(
+        "RO8ERT",
+        "R0BERT",
+        {("O", "0"): 0.1, ("B", "8"): 0.2},
+    )
+)
+
+
+ic(weighted_levenshtein_distance("A", "B", {("A", "B"): 0.0}, symmetric=False))
+ic(weighted_levenshtein_distance("A", "B", {("B", "A"): 0.0}, symmetric=False))
+ic(weighted_levenshtein_distance("B", "A", {("B", "A"): 0.0}, symmetric=False))
+ic(weighted_levenshtein_distance("B", "A", {("A", "B"): 0.0}, symmetric=False))

ocr_stringdist-0.0.3/python/ocr_stringdist/__init__.py

@@ -0,0 +1,41 @@
+from typing import Optional
+
+from ._rust_stringdist import *  # noqa: F403
+
+from .default_ocr_distances import ocr_distance_map
+
+
+__all__ = [
+    "ocr_distance_map",
+    "weighted_levenshtein_distance",  # noqa: F405
+]
+
+
+def weighted_levenshtein_distance(
+    s1: str,
+    s2: str,
+    /,
+    cost_map: Optional[dict[tuple[str, str], float]] = None,
+    *,
+    symmetric: bool = True,
+    default_cost: float = 1.0,
+) -> float:
+    """
+    Levenshtein distance with custom substitution costs.
+    Insertion/deletion costs are 1.
+
+    The default `cost_map` considers common OCR errors, see `ocr_stringdist.ocr_distance_map`.
+
+    :param s1: First string
+    :param s2: Second string
+    :param cost_map: Dictionary mapping tuples of characters to their substitution cost.
+                     Only one direction needs to be configured unless `symmetric` is False.
+                     Defaults to `ocr_stringdist.ocr_distance_map`.
+    :param symmetric: Should the keys of `cost_map` be considered to be symmetric? Defaults to True.
+    :param default_cost: The default substitution cost for character pairs not found in `cost_map`.
+    """
+    if cost_map is None:
+        cost_map = ocr_distance_map
+    return _weighted_levenshtein_distance(  # noqa: F405
+        s1, s2, cost_map=cost_map, symmetric=symmetric, default_cost=default_cost
+    )

ocr_stringdist-0.0.3/python/ocr_stringdist/default_ocr_distances.py

@@ -0,0 +1,38 @@
+ocr_distance_map: dict[tuple[str, str], float] = {
+    ("O", "0"): 0.1,
+    ("l", "1"): 0.1,
+    ("I", "1"): 0.15,
+    ("o", "0"): 0.2,
+    ("B", "8"): 0.25,
+    ("S", "5"): 0.3,
+    ("G", "6"): 0.3,
+    ("Z", "2"): 0.3,
+    ("C", "c"): 0.3,
+    ("é", "e"): 0.3,
+    ("Ä", "A"): 0.4,
+    ("Ö", "O"): 0.4,
+    ("Ü", "U"): 0.4,
+    ("c", "e"): 0.4,
+    ("a", "o"): 0.4,
+    ("u", "v"): 0.4,
+    ("i", "l"): 0.4,
+    ("s", "5"): 0.4,
+    ("m", "n"): 0.5,
+    ("f", "s"): 0.5,
+    (".", ","): 0.5,
+    ("2", "Z"): 0.5,
+    ("t", "f"): 0.6,
+    ("r", "n"): 0.6,
+    ("-", "_"): 0.6,
+    ("ß", "B"): 0.6,
+    ("h", "b"): 0.7,
+    ("v", "y"): 0.7,
+    ("i", "j"): 0.7,
+    ("é", "á"): 0.7,
+    ("E", "F"): 0.8,
+}
+"""
+Pre-defined distance map between characters, considering common OCR errors.
+The distances are between 0 and 1.
+This map is intended to be used with `symmetric=True`.
+"""

ocr_stringdist-0.0.3/src/lib.rs

@@ -0,0 +1,8 @@
+mod weighted_levenshtein;
+
+pub use weighted_levenshtein::{custom_levenshtein_distance_with_cost_map, OcrCostMap};
+
+#[cfg(feature = "python")]
+mod rust_stringdist;
+#[cfg(feature = "python")]
+pub use rust_stringdist::_rust_stringdist;

{ocr_stringdist-0.0.1 → ocr_stringdist-0.0.3}/src/rust_stringdist.rs

@@ -1,23 +1,17 @@
-use crate::custom_levenshtein_distance as _weighted_lev;
 use crate::custom_levenshtein_distance_with_cost_map as _weighted_lev_with_map;
 use crate::OcrCostMap;
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
 use std::collections::HashMap;
 
-// Calculates the Levenshtein distance between two strings.
-#[pyfunction]
-fn ocr_weighted_levenshtein_distance(a: &str, b: &str) -> PyResult<f64> {
-    Ok(_weighted_lev(a, b))
-}
-
 // Calculates the weighted Levenshtein distance with a custom cost map from Python.
 #[pyfunction]
-#[pyo3(signature = (a, b, cost_map, default_cost = None))]
-fn custom_weighted_levenshtein_distance(
+#[pyo3(signature = (a, b, cost_map, symmetric = true, default_cost = 1.0))]
+fn _weighted_levenshtein_distance(
     a: &str,
     b: &str,
     cost_map: &Bound<'_, PyDict>,
+    symmetric: bool,
     default_cost: Option<f64>,
 ) -> PyResult<f64> {
     let default_cost_value = default_cost.unwrap_or(1.0);
@@ -38,14 +32,13 @@ fn custom_weighted_levenshtein_distance(
     }
 
     // Create a custom cost map and calculate the distance
-    let custom_cost_map = OcrCostMap::new(char_costs, default_cost_value);
+    let custom_cost_map = OcrCostMap::new(char_costs, default_cost_value, symmetric);
     Ok(_weighted_lev_with_map(a, b, &custom_cost_map))
 }
 
 /// A Python module implemented in Rust.
 #[pymodule]
 pub fn _rust_stringdist(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
-    m.add_function(wrap_pyfunction!(ocr_weighted_levenshtein_distance, m)?)?;
-    m.add_function(wrap_pyfunction!(custom_weighted_levenshtein_distance, m)?)?;
+    m.add_function(wrap_pyfunction!(_weighted_levenshtein_distance, m)?)?;
     Ok(())
 }

{ocr_stringdist-0.0.1 → ocr_stringdist-0.0.3}/src/weighted_levenshtein.rs

@@ -1,4 +1,3 @@
-use once_cell::sync::Lazy;
 use smallvec::SmallVec;
 use std::collections::HashMap;
 
@@ -14,15 +13,18 @@ pub struct OcrCostMap {
 impl OcrCostMap {
     /// Creates a new OcrCostMap with specified costs.
     /// Ensures symmetry by adding both (a, b) and (b, a) if only one is provided.
+    /// If symmetric, keys are inserted in both directions.
     pub fn new(
         custom_costs_input: HashMap<(char, char), f64>,
         default_substitution_cost: f64,
+        symmetric: bool,
     ) -> Self {
         let mut costs = HashMap::with_capacity(custom_costs_input.len() * 2); // Pre-allocate
         for ((c1, c2), cost) in custom_costs_input {
-            // Ensure symmetry and avoid overwriting if both orders are present
             costs.entry((c1, c2)).or_insert(cost);
-            costs.entry((c2, c1)).or_insert(cost);
+            if symmetric {
+                costs.entry((c2, c1)).or_insert(cost);
+            }
         }
 
         OcrCostMap {
@@ -32,7 +34,7 @@ impl OcrCostMap {
     }
 
     /// Gets the substitution cost between two characters.
-    /// Checks the custom map (symmetrically) first, then falls back to the
+    /// Checks the custom map first, then falls back to the
     /// default substitution cost configured within this map instance.
     pub fn get_substitution_cost(&self, c1: char, c2: char) -> f64 {
         if c1 == c2 {
@@ -48,35 +50,6 @@ impl OcrCostMap {
     }
 }
 
-impl Default for OcrCostMap {
-    fn default() -> Self {
-        DEFAULT_OCR_COST_MAP.clone()
-    }
-}
-
-// --- Default OCR Map Initialization (Immutable HashMap) ---
-
-// Define the costs as a static array of tuples
-const DEFAULT_OCR_PAIRS: &[((char, char), f64)] = &[
-    (('G', '6'), 0.2),
-    (('O', '0'), 0.2),
-    (('o', '0'), 0.2),
-    (('l', '1'), 0.2),
-    (('I', '1'), 0.2),
-    (('2', 'Z'), 0.2),
-    (('B', '8'), 0.2),
-    (('S', '5'), 0.3),
-    (('s', '5'), 0.3),
-    (('E', 'F'), 0.8),
-];
-
-// Use Lazy and collect from the static array for initialization
-static DEFAULT_OCR_COST_MAP: Lazy<OcrCostMap> = Lazy::new(|| {
-    // Collect the static array into a HashMap directly
-    let ocr_costs: HashMap<(char, char), f64> = DEFAULT_OCR_PAIRS.iter().copied().collect();
-    OcrCostMap::new(ocr_costs, 1.0)
-});
-
 // Helper to create a range vector with f64 values
 fn range_vec_f64(size: usize) -> SmallVec<[f64; 16]> {
     let mut vec = SmallVec::with_capacity(size);
@@ -86,11 +59,6 @@ fn range_vec_f64(size: usize) -> SmallVec<[f64; 16]> {
     vec
 }
 
-/// Calculates Levenshtein distance between two vectors using custom costs.
-pub fn vec_custom_levenshtein_distance(v1: &[char], v2: &[char]) -> f64 {
-    vec_custom_levenshtein_distance_with_cost_map(v1, v2, &OcrCostMap::default())
-}
-
 /// Calculates Levenshtein distance between two vectors using a specified cost map.
 pub fn vec_custom_levenshtein_distance_with_cost_map(
     v1: &[char],
@@ -131,18 +99,6 @@ pub fn vec_custom_levenshtein_distance_with_cost_map(
     cur[cols - 1]
 }
 
-/// Calculates custom Levenshtein distance between two strings using OCR cost map.
-pub fn custom_levenshtein_distance(s1: &str, s2: &str) -> f64 {
-    if s1 == s2 {
-        return 0.0;
-    }
-
-    let v1: Vec<char> = s1.chars().collect();
-    let v2: Vec<char> = s2.chars().collect();
-
-    vec_custom_levenshtein_distance(&v1, &v2)
-}
-
 /// Calculates custom Levenshtein distance between two strings using a provided cost map.
 pub fn custom_levenshtein_distance_with_cost_map(s1: &str, s2: &str, cost_map: &OcrCostMap) -> f64 {
     if s1 == s2 {
@@ -169,31 +125,11 @@ mod test {
         );
     }
 
-    #[test]
-    fn test_custom_levenshtein_simple() {
-        assert_approx_eq(custom_levenshtein_distance("abc", "axc"), 1.0, 1e-9);
-        assert_approx_eq(custom_levenshtein_distance("abc", "ac"), 1.0, 1e-9);
-        assert_approx_eq(custom_levenshtein_distance("ac", "abc"), 1.0, 1e-9);
-    }
-
-    #[test]
-    fn test_custom_levenshtein_ocr_pairs() {
-        assert_approx_eq(custom_levenshtein_distance("ABCDEFG", "ABCDEF6"), 0.2, 1e-9);
-
-        assert_approx_eq(custom_levenshtein_distance("ABCDEF6", "ABCDEFG"), 0.2, 1e-9);
-
-        assert_approx_eq(
-            custom_levenshtein_distance("ABCDEFG", "ABCDEF6X"),
-            0.2 + 1.0,
-            1e-9,
-        );
-    }
-
     #[test]
     fn test_custom_levenshtein_with_custom_map() {
         let mut custom_costs = HashMap::new();
         custom_costs.insert(('a', 'b'), 0.1);
-        let cost_map = OcrCostMap::new(custom_costs, 1.0);
+        let cost_map = OcrCostMap::new(custom_costs, 1.0, true);
 
         assert_approx_eq(
             custom_levenshtein_distance_with_cost_map("abc", "bbc", &cost_map),

ocr_stringdist-0.0.3/tests/test_ocr_stringdist.py

@@ -0,0 +1,5 @@
+from ocr_stringdist import weighted_levenshtein_distance
+
+
+def test_weighted_levenshtein_distance() -> None:
+    assert weighted_levenshtein_distance("a", "b") == 1.0

ocr_stringdist-0.0.1/PKG-INFO

@@ -1,16 +0,0 @@
-Metadata-Version: 2.4
-Name: ocr_stringdist
-Version: 0.0.1
-Classifier: Programming Language :: Rust
-Classifier: Programming Language :: Python :: Implementation :: PyPy
-Classifier: Operating System :: OS Independent
-Summary: String distances considering OCR errors.
-Author: Niklas von Moers <niklasvmoers@protonmail.com>
-Author-email: Niklas von Moers <niklasvmoers@protonmail.com>
-License: MIT
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
-Project-URL: repository, https://github.com/NiklasvonM/ocr-stringdist
-
-# OCR-Stringdist
-

ocr_stringdist-0.0.1/README.md

@@ -1 +0,0 @@
-# OCR-Stringdist

ocr_stringdist-0.0.1/example.py

@@ -1,50 +0,0 @@
-from ocr_stringdist import (
-    ocr_weighted_levenshtein_distance,
-    custom_weighted_levenshtein_distance,
-)
-
-# Example with default OCR cost map
-print("Using default OCR cost map:")
-default_result = ocr_weighted_levenshtein_distance("12345G", "123456")
-print(f"Distance between '12345G' and '123456': {default_result}")
-
-# Example with custom cost map
-custom_cost_map: dict[tuple[str, str], float] = {
-    ("G", "6"): 0.1,  # Make G/6 even more similar (default is 0.2)
-    ("A", "B"): 0.3,  # Make A/B somewhat similar
-    ("X", "Y"): 0.5,  # Make X/Y moderately similar
-}
-
-print("\nUsing custom cost map:")
-custom_result = custom_weighted_levenshtein_distance(
-    "12345G", "123456", custom_cost_map
-)
-print(f"Distance between '12345G' and '123456' with custom map: {custom_result}")
-
-# Example with custom default cost
-print("\nUsing custom default cost:")
-custom_default_result = custom_weighted_levenshtein_distance(
-    "ABCDE",
-    "XBCDE",
-    cost_map={("A", "X"): 0.5},
-    default_cost=0.8,  # Lower default substitution cost (default is 1.0)
-)
-print(
-    f"Distance between 'ABCDE' and 'XBCDE' with custom default cost: {custom_default_result}"
-)
-
-# More complex example - comparing names with custom costs for similar looking characters
-name_cost_map = {
-    ("O", "0"): 0.1,  # Letter O and number 0
-    ("l", "1"): 0.1,  # Lowercase L and number 1
-    ("I", "1"): 0.1,  # Uppercase I and number 1
-    ("S", "5"): 0.2,  # Letter S and number 5
-    ("Z", "2"): 0.2,  # Letter Z and number 2
-    ("B", "8"): 0.2,  # Letter B and number 8
-}
-
-print("\nComparing names with OCR-like errors:")
-name1 = "ROBERT"
-name2 = "R0BERT"  # Using 0 instead of O
-distance = custom_weighted_levenshtein_distance(name1, name2, name_cost_map)
-print(f"Distance between '{name1}' and '{name2}': {distance}")

ocr_stringdist-0.0.1/python/ocr_stringdist/__init__.py

@@ -1 +0,0 @@
-from ._rust_stringdist import *

ocr_stringdist-0.0.1/python/ocr_stringdist/__init__.pyi

@@ -1,8 +0,0 @@
-def levenshtein_distance(s1: str, s2: str) -> int: ...
-def ocr_weighted_levenshtein_distance(s1: str, s2: str) -> float: ...
-def custom_weighted_levenshtein_distance(
-    s1: str, 
-    s2: str, 
-    cost_map: dict[tuple[str, str], float], 
-    default_cost: float | None = None
-) -> float: ...

ocr_stringdist-0.0.1/src/lib.rs

@@ -1,11 +0,0 @@
-mod weighted_levenshtein;
-
-pub use weighted_levenshtein::{
-    custom_levenshtein_distance, custom_levenshtein_distance_with_cost_map,
-    vec_custom_levenshtein_distance, vec_custom_levenshtein_distance_with_cost_map, OcrCostMap,
-};
-
-#[cfg(feature = "python")]
-mod rust_stringdist;
-#[cfg(feature = "python")]
-pub use rust_stringdist::_rust_stringdist;

ocr_stringdist-0.0.1/tests/test_ocr_stringdist.py

@@ -1,5 +0,0 @@
-from ocr_stringdist import ocr_weighted_levenshtein_distance
-
-
-def test_ocr_weighted_levenshtein_distance() -> None:
-    assert ocr_weighted_levenshtein_distance("a", "b") == 1.0