ocr-stringdist 0.0.7__tar.gz → 0.1.0__tar.gz

ocr_stringdist-0.1.0/CHANGELOG.md

@@ -0,0 +1,16 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - 2025-04-26
+
+### Added
+
+- Custom insertion and deletion costs for weighted Levenshtein distance.
+
+### Changed
+
+- Breaking changes to Levenshtein distance functions signatures.

{ocr_stringdist-0.0.7 → ocr_stringdist-0.1.0}/Cargo.lock

@@ -74,7 +74,7 @@ dependencies = [
 
 [[package]]
 name = "ocr_stringdist"
-version = "0.0.7"
+version = "0.1.0"
 dependencies = [
  "pyo3",
  "rayon",

{ocr_stringdist-0.0.7 → ocr_stringdist-0.1.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ocr_stringdist"
-version = "0.0.7"
+version = "0.1.0"
 edition = "2021"
 description = "String distances considering OCR errors."
 authors = ["Niklas von Moers <niklasvmoers@protonmail.com>"]

{ocr_stringdist-0.0.7 → ocr_stringdist-0.1.0}/Justfile

@@ -5,10 +5,11 @@ venv:
 
 pytest:
     uv run maturin develop
-    uv run pytest
+    uv run pytest --cov=python/ocr_stringdist tests
 
 test:
-    cargo test
+    cargo llvm-cov
+    #cargo test
 
 mypy:
     uv run mypy .

{ocr_stringdist-0.0.7 → ocr_stringdist-0.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ocr_stringdist
-Version: 0.0.7
+Version: 0.1.0
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python
 Classifier: Operating System :: OS Independent
@@ -40,7 +40,6 @@ pip install ocr-stringdist
 - **Unicode Support**: Arbitrary unicode strings can be compared.
 - **Substitution of Multiple Characters**: Not just character pairs, but string pairs may be substituted, for example the Korean syllable "이" for the two letters "OI".
 - **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.
 - **Best Match Finder**: Utility function `find_best_candidate` to efficiently find the best matching string from a collection of candidates using any specified distance function (including the library's OCR-aware ones).
 
 ## Usage

{ocr_stringdist-0.0.7 → ocr_stringdist-0.1.0}/README.md

@@ -25,7 +25,6 @@ pip install ocr-stringdist
 - **Unicode Support**: Arbitrary unicode strings can be compared.
 - **Substitution of Multiple Characters**: Not just character pairs, but string pairs may be substituted, for example the Korean syllable "이" for the two letters "OI".
 - **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.
 - **Best Match Finder**: Utility function `find_best_candidate` to efficiently find the best matching string from a collection of candidates using any specified distance function (including the library's OCR-aware ones).
 
 ## Usage

{ocr_stringdist-0.0.7 → ocr_stringdist-0.1.0}/docs/source/api/index.rst

@@ -3,8 +3,6 @@
 API Reference
 =============
 
-This page contains the auto-generated API reference documentation.
-
 .. automodule:: ocr_stringdist.levenshtein
    :members:
    :undoc-members:

ocr_stringdist-0.1.0/docs/source/changelog.rst

@@ -0,0 +1 @@
+.. mdinclude:: ../../CHANGELOG.md

{ocr_stringdist-0.0.7 → ocr_stringdist-0.1.0}/docs/source/conf.py

@@ -4,6 +4,7 @@
 # https://www.sphinx-doc.org/en/master/usage/configuration.html
 
 
+import importlib.metadata
 import os
 import sys
 
@@ -17,6 +18,8 @@ sys.path.insert(0, os.path.abspath("../../python"))
 project = "OCR-StringDist"
 copyright = "2025, Niklas von Moers"
 author = "Niklas von Moers"
+release = importlib.metadata.version("ocr_stringdist")
+version = release
 
 # -- General configuration ---------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration

ocr_stringdist-0.1.0/docs/source/examples.rst

@@ -0,0 +1,20 @@
+==========
+ Examples
+==========
+
+.. code-block:: 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 = {("In", "h"): 0.5}
+    distance = osd.weighted_levenshtein_distance(
+        "hi", "Ini",
+        cost_map=custom_map,
+        symmetric=True,
+    )
+    print(f"Distance with custom map: {distance}")

ocr_stringdist-0.1.0/docs/source/getting-started.rst

@@ -0,0 +1,10 @@
+=================
+ Getting Started
+=================
+
+Installation
+============
+
+.. code-block:: console
+
+    pip install ocr-stringdist

ocr_stringdist-0.1.0/docs/source/index.rst

@@ -0,0 +1,36 @@
+================
+ OCR-StringDist
+================
+
+A Python library for string distance calculations that account for common OCR (optical character recognition) errors, written in Rust.
+
+:Repository: https://niklasvonm.github.io/ocr-stringdist/
+:Current version: |release|
+
+.. image:: https://img.shields.io/badge/PyPI-Package-blue
+   :target: https://pypi.org/project/ocr-stringdist/
+   :alt: PyPI
+
+.. image:: https://img.shields.io/badge/License-MIT-green
+   :target: LICENSE
+   :alt: License
+
+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, including efficient batch processing.
+- **Unicode Support**: Arbitrary unicode strings can be compared.
+- **Substitution of Multiple Characters**: Not just character pairs, but string pairs may be substituted, for example the Korean syllable "이" for the two letters "OI".
+- **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").
+- **Best Match Finder**: Utility function ``find_best_candidate`` to efficiently find the best matching string from a collection of candidates using any specified distance function (including the library's OCR-aware ones).
+
+Contents
+========
+
+.. toctree::
+   :maxdepth: 1
+
+   getting-started
+   examples
+   api/index
+   changelog

{ocr_stringdist-0.0.7 → ocr_stringdist-0.1.0}/examples/weighted_levenshtein.py

@@ -31,13 +31,13 @@ ic(
     weighted_levenshtein_distance(
         "ABCDE",
         "XBCDE",
-        cost_map={},
-        default_cost=0.8,  # Lower default substitution cost (default is 1.0)
+        substitution_costs={},
+        default_substitution_cost=0.8,  # Lower default substitution cost (default is 1.0)
     )
 )
 
-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("A", "B", {("A", "B"): 0.0}, symmetric_substitution=False))
+ic(weighted_levenshtein_distance("A", "B", {("B", "A"): 0.0}, symmetric_substitution=False))
 
 ic(
     find_best_candidate(

{ocr_stringdist-0.0.7 → ocr_stringdist-0.1.0}/pyproject.toml

@@ -27,6 +27,7 @@ dev = [
     "maturin>=1.8.3",
     "mypy>=1.15.0",
     "pytest>=8.3.5",
+    "pytest-cov>=6.1.1",
     "ruff>=0.11.6",
     "wheel>=0.45.1",
 ]

ocr_stringdist-0.1.0/python/ocr_stringdist/levenshtein.py

@@ -0,0 +1,118 @@
+from typing import Optional
+
+from ._rust_stringdist import *  # noqa: F403
+from .default_ocr_distances import ocr_distance_map
+
+
+def weighted_levenshtein_distance(
+    s1: str,
+    s2: str,
+    /,
+    substitution_costs: Optional[dict[tuple[str, str], float]] = None,
+    insertion_costs: Optional[dict[str, float]] = None,
+    deletion_costs: Optional[dict[str, float]] = None,
+    *,
+    symmetric_substitution: bool = True,
+    default_substitution_cost: float = 1.0,
+    default_insertion_cost: float = 1.0,
+    default_deletion_cost: float = 1.0,
+) -> float:
+    """
+    Levenshtein distance with custom substitution, insertion and deletion costs.
+
+    The default `substitution_costs` considers common OCR errors, see
+    :py:data:`ocr_stringdist.default_ocr_distances.ocr_distance_map`.
+
+    :param s1: First string (interpreted as the string read via OCR)
+    :param s2: Second string
+    :param substitution_costs: Dictionary mapping tuples of strings ("substitution tokens") to their
+                     substitution costs. Only one direction needs to be configured unless
+                     `symmetric_substitution` is False.
+                     Note that the runtime scales in the length of the longest substitution token.
+                     Defaults to `ocr_stringdist.ocr_distance_map`.
+    :param insertion_costs: Dictionary mapping strings to their insertion costs.
+    :param deletion_costs: Dictionary mapping strings to their deletion costs.
+    :param symmetric_substitution: Should the keys of `substitution_costs` be considered to be
+                                   symmetric? Defaults to True.
+    :param default_substitution_cost: The default substitution cost for character pairs not found
+                                      in `substitution_costs`.
+    :param default_insertion_cost: The default insertion cost for characters not found in
+                                   `insertion_costs`.
+    :param default_deletion_cost: The default deletion cost for characters not found in
+                                  `deletion_costs`.
+    """
+    if substitution_costs is None:
+        substitution_costs = ocr_distance_map
+    if insertion_costs is None:
+        insertion_costs = {}
+    if deletion_costs is None:
+        deletion_costs = {}
+    # _weighted_levenshtein_distance is written in Rust, see src/rust_stringdist.rs.
+    return _weighted_levenshtein_distance(  # type: ignore  # noqa: F405
+        s1,
+        s2,
+        substitution_costs=substitution_costs,
+        insertion_costs=insertion_costs,
+        deletion_costs=deletion_costs,
+        symmetric_substitution=symmetric_substitution,
+        default_substitution_cost=default_substitution_cost,
+        default_insertion_cost=default_insertion_cost,
+        default_deletion_cost=default_deletion_cost,
+    )
+
+
+def batch_weighted_levenshtein_distance(
+    s: str,
+    candidates: list[str],
+    /,
+    substitution_costs: Optional[dict[tuple[str, str], float]] = None,
+    insertion_costs: Optional[dict[str, float]] = None,
+    deletion_costs: Optional[dict[str, float]] = None,
+    *,
+    symmetric_substitution: bool = True,
+    default_substitution_cost: float = 1.0,
+    default_insertion_cost: float = 1.0,
+    default_deletion_cost: float = 1.0,
+) -> list[float]:
+    """
+    Calculate weighted Levenshtein distances between a string and multiple candidates.
+
+    This is more efficient than calling :func:`weighted_levenshtein_distance` multiple times.
+
+    :param s: The string to compare (interpreted as the string read via OCR)
+    :param candidates: List of candidate strings to compare against
+    :param substitution_costs: Dictionary mapping tuples of strings ("substitution tokens") to their
+                     substitution costs. Only one direction needs to be configured unless
+                     `symmetric_substitution` is False.
+                     Note that the runtime scales in the length of the longest substitution token.
+                     Defaults to `ocr_stringdist.ocr_distance_map`.
+    :param insertion_costs: Dictionary mapping strings to their insertion costs.
+    :param deletion_costs: Dictionary mapping strings to their deletion costs.
+    :param symmetric_substitution: Should the keys of `substitution_costs` be considered to be
+                                   symmetric? Defaults to True.
+    :param default_substitution_cost: The default substitution cost for character pairs not found
+                                      in `substitution_costs`.
+    :param default_insertion_cost: The default insertion cost for characters not found in
+                                   `insertion_costs`.
+    :param default_deletion_cost: The default deletion cost for characters not found in
+                                  `deletion_costs`.
+    :return: A list of distances corresponding to each candidate
+    """
+    if substitution_costs is None:
+        substitution_costs = ocr_distance_map
+    if insertion_costs is None:
+        insertion_costs = {}
+    if deletion_costs is None:
+        deletion_costs = {}
+    # _batch_weighted_levenshtein_distance is written in Rust, see src/rust_stringdist.rs.
+    return _batch_weighted_levenshtein_distance(  # type: ignore  # noqa: F405
+        s,
+        candidates,
+        substitution_costs=substitution_costs,
+        insertion_costs=insertion_costs,
+        deletion_costs=deletion_costs,
+        symmetric_substitution=symmetric_substitution,
+        default_substitution_cost=default_substitution_cost,
+        default_insertion_cost=default_insertion_cost,
+        default_deletion_cost=default_deletion_cost,
+    )

ocr_stringdist-0.1.0/src/cost_map.rs

@@ -0,0 +1,306 @@
+use crate::types::{SingleTokenCostMap, SingleTokenKey, SubstitutionCostMap, SubstitutionKey};
+use std::collections::HashMap;
+use std::fmt::Debug;
+use std::hash::Hash;
+
+#[cfg(feature = "python")]
+use pyo3::prelude::*;
+
+/// A trait for cost map keys, allowing us to constrain the generic parameter
+pub trait CostKey: Clone + Debug + Eq + Hash {}
+
+// Implement the trait for both key types
+impl CostKey for SingleTokenKey {}
+impl CostKey for SubstitutionKey {}
+
+/// Generic cost map structure that works with different key types
+#[derive(Clone, Debug)]
+pub struct CostMap<K: CostKey> {
+    /// The costs map
+    pub costs: HashMap<K, f64>,
+    /// Default cost for operations not found in the map
+    default_cost: f64,
+    /// Maximum token length in the map
+    pub max_token_length: usize,
+}
+
+impl<K: CostKey> Default for CostMap<K>
+where
+    K: Default,
+{
+    /// Creates a new CostMap with default values
+    fn default() -> Self {
+        Self {
+            costs: HashMap::new(),
+            default_cost: 1.0,
+            max_token_length: 1,
+        }
+    }
+}
+
+// Implementation for SubstitutionKey (pair of strings)
+impl CostMap<SubstitutionKey> {
+    /// Creates a new substitution CostMap with specified costs.
+    /// Ensures symmetry by adding both (a, b) and (b, a) if only one is provided when symmetric is true.
+    pub fn new(
+        custom_costs_input: SubstitutionCostMap,
+        default_cost: f64,
+        symmetric: bool,
+    ) -> Self {
+        let mut costs = HashMap::with_capacity(custom_costs_input.len() * 2);
+        let mut max_length = 1;
+
+        for ((s1, s2), cost) in custom_costs_input {
+            costs.entry((s1.clone(), s2.clone())).or_insert(cost);
+            if symmetric {
+                costs.entry((s2.clone(), s1.clone())).or_insert(cost);
+            }
+
+            // Update max token length
+            max_length = max_length.max(s1.chars().count()).max(s2.chars().count());
+        }
+
+        CostMap {
+            costs,
+            default_cost,
+            max_token_length: max_length,
+        }
+    }
+
+    /// Creates a new substitution CostMap with the specified custom costs.
+    /// Uses default values for other parameters.
+    pub fn with_costs(custom_costs: SubstitutionCostMap) -> Self {
+        Self::new(custom_costs, 1.0, true)
+    }
+
+    #[cfg(feature = "python")]
+    /// Creates a substitution CostMap from a Python dictionary.
+    /// This method is only available when the "python" feature is enabled.
+    pub fn from_py_dict<'a, D>(py_dict: &'a D, default_cost: f64, symmetric: bool) -> Self
+    where
+        D: PyDictMethods<'a>,
+    {
+        let mut substitution_costs = SubstitutionCostMap::new();
+        let mut max_length = 1;
+
+        // Convert Python dictionary to Rust HashMap
+        for (key, value) in py_dict.iter() {
+            if let Ok(key_tuple) = key.extract::<(String, String)>() {
+                if let Ok(cost) = value.extract::<f64>() {
+                    substitution_costs.insert((key_tuple.0.clone(), key_tuple.1.clone()), cost);
+
+                    // Update max token length
+                    max_length = max_length
+                        .max(key_tuple.0.chars().count())
+                        .max(key_tuple.1.chars().count());
+                }
+            }
+        }
+
+        // Create the CostMap
+        Self::new(substitution_costs, default_cost, symmetric)
+    }
+
+    /// Gets the substitution cost between two strings.
+    pub fn get_cost(&self, s1: &str, s2: &str) -> f64 {
+        if s1 == s2 {
+            0.0 // No cost if strings are identical
+        } else {
+            let key_pair = (s1.to_string(), s2.to_string());
+
+            // Lookup the pair (symmetry is handled by storage in `new`)
+            // Use the map's configured default_cost as the fallback.
+            self.costs
+                .get(&key_pair)
+                .copied()
+                .unwrap_or(self.default_cost)
+        }
+    }
+
+    /// Checks if the cost map contains a specific substitution
+    pub fn has_key(&self, s1: &str, s2: &str) -> bool {
+        let key_pair = (s1.to_string(), s2.to_string());
+        self.costs.contains_key(&key_pair)
+    }
+}
+
+// Implementation for SingleTokenKey (single string)
+impl CostMap<SingleTokenKey> {
+    /// Creates a new single token CostMap for insertion or deletion operations
+    pub fn new(custom_costs_input: SingleTokenCostMap, default_cost: f64) -> Self {
+        let mut max_length = 1;
+
+        // Calculate max token length
+        for key in custom_costs_input.keys() {
+            max_length = max_length.max(key.chars().count());
+        }
+
+        CostMap {
+            costs: custom_costs_input,
+            default_cost,
+            max_token_length: max_length,
+        }
+    }
+
+    /// Creates a new single token CostMap with the specified custom costs.
+    /// Uses default value for default cost.
+    pub fn with_costs(custom_costs: SingleTokenCostMap) -> Self {
+        Self::new(custom_costs, 1.0)
+    }
+
+    #[cfg(feature = "python")]
+    /// Creates a single token CostMap from a Python dictionary.
+    /// This method is only available when the "python" feature is enabled.
+    pub fn from_py_dict<'a, D>(py_dict: &'a D, default_cost: f64) -> Self
+    where
+        D: PyDictMethods<'a>,
+    {
+        let mut single_token_costs = SingleTokenCostMap::new();
+        let mut max_length = 1;
+
+        // Convert Python dictionary to Rust HashMap
+        for (key, value) in py_dict.iter() {
+            if let Ok(token) = key.extract::<String>() {
+                if let Ok(cost) = value.extract::<f64>() {
+                    single_token_costs.insert(token.clone(), cost);
+
+                    // Update max token length
+                    max_length = max_length.max(token.chars().count());
+                }
+            }
+        }
+
+        // Create the CostMap
+        Self::new(single_token_costs, default_cost)
+    }
+
+    /// Gets the cost for a single token (insertion or deletion).
+    pub fn get_cost(&self, token: &str) -> f64 {
+        self.costs.get(token).copied().unwrap_or(self.default_cost)
+    }
+
+    /// Checks if the cost map contains a specific single token
+    pub fn has_key(&self, token: &str) -> bool {
+        self.costs.contains_key(token)
+    }
+}
+
+// Common methods for any type of CostMap
+impl<K: CostKey> CostMap<K> {
+    /// Returns the default cost for this cost map
+    pub fn default_cost(&self) -> f64 {
+        self.default_cost
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_single_token_map_default() {
+        // Test with default initialization
+        let cost_map: CostMap<SingleTokenKey> = CostMap::default();
+        assert_eq!(cost_map.default_cost(), 1.0);
+        assert_eq!(cost_map.get_cost("any_token"), 1.0);
+        assert!(!cost_map.has_key("any_token"));
+    }
+
+    #[test]
+    fn test_single_token_map_with_costs() {
+        let mut custom_costs = SingleTokenCostMap::new();
+        custom_costs.insert("a".to_string(), 0.5);
+        custom_costs.insert("b".to_string(), 0.8);
+
+        // Test with_costs constructor (default cost 1.0)
+        let cost_map = CostMap::<SingleTokenKey>::with_costs(custom_costs);
+
+        // Test getting costs for tokens
+        assert_eq!(cost_map.get_cost("a"), 0.5);
+        assert_eq!(cost_map.get_cost("b"), 0.8);
+        assert_eq!(cost_map.get_cost("c"), 1.0); // Default cost
+
+        // Test has_key
+        assert!(cost_map.has_key("a"));
+        assert!(cost_map.has_key("b"));
+        assert!(!cost_map.has_key("c"));
+    }
+
+    #[test]
+    fn test_single_token_map_with_custom_default() {
+        let mut custom_costs = SingleTokenCostMap::new();
+        custom_costs.insert("test".to_string(), 0.3);
+
+        // Test new constructor with custom default cost
+        let cost_map = CostMap::<SingleTokenKey>::new(custom_costs, 2.0);
+
+        assert_eq!(cost_map.default_cost(), 2.0);
+        assert_eq!(cost_map.get_cost("test"), 0.3);
+        assert_eq!(cost_map.get_cost("unknown"), 2.0);
+    }
+
+    #[test]
+    fn test_substitution_map_default() {
+        let cost_map: CostMap<SubstitutionKey> = CostMap {
+            costs: HashMap::new(),
+            default_cost: 1.0,
+            max_token_length: 1,
+        };
+
+        assert_eq!(cost_map.default_cost(), 1.0);
+        assert_eq!(cost_map.get_cost("a", "b"), 1.0);
+        assert!(!cost_map.has_key("a", "b"));
+    }
+
+    #[test]
+    fn test_substitution_map_with_costs() {
+        let mut custom_costs = SubstitutionCostMap::new();
+        custom_costs.insert(("0".to_string(), "o".to_string()), 0.2);
+        custom_costs.insert(("l".to_string(), "1".to_string()), 0.3);
+
+        // Test with_costs constructor (symmetric by default)
+        let cost_map = CostMap::<SubstitutionKey>::with_costs(custom_costs);
+
+        // Test getting costs
+        assert_eq!(cost_map.get_cost("0", "o"), 0.2);
+        assert_eq!(cost_map.get_cost("o", "0"), 0.2); // Symmetry check
+        assert_eq!(cost_map.get_cost("l", "1"), 0.3);
+        assert_eq!(cost_map.get_cost("1", "l"), 0.3); // Symmetry check
+        assert_eq!(cost_map.get_cost("a", "b"), 1.0); // Default
+
+        // Test same character
+        assert_eq!(cost_map.get_cost("a", "a"), 0.0); // Same char = 0 cost
+
+        // Test has_key
+        assert!(cost_map.has_key("0", "o"));
+        assert!(cost_map.has_key("o", "0")); // Symmetry check
+        assert!(!cost_map.has_key("a", "b"));
+    }
+
+    #[test]
+    fn test_substitution_map_asymmetric() {
+        let mut custom_costs = SubstitutionCostMap::new();
+        custom_costs.insert(("a".to_string(), "b".to_string()), 0.4);
+
+        // Create with symmetric=false
+        let cost_map = CostMap::<SubstitutionKey>::new(custom_costs, 1.5, false);
+
+        // Test asymmetry
+        assert_eq!(cost_map.get_cost("a", "b"), 0.4);
+        assert_eq!(cost_map.get_cost("b", "a"), 1.5); // Should be default cost
+
+        assert!(cost_map.has_key("a", "b"));
+        assert!(!cost_map.has_key("b", "a")); // Should not exist
+    }
+
+    #[test]
+    fn test_default_cost_accessor() {
+        // Test for SubstitutionKey
+        let sub_map = CostMap::<SubstitutionKey>::new(HashMap::new(), 2.5, true);
+        assert_eq!(sub_map.default_cost(), 2.5);
+
+        // Test for SingleTokenKey
+        let single_map = CostMap::<SingleTokenKey>::new(HashMap::new(), 3.0);
+        assert_eq!(single_map.default_cost(), 3.0);
+    }
+}

ocr_stringdist-0.1.0/src/lib.rs

@@ -0,0 +1,12 @@
+mod cost_map;
+mod types;
+mod weighted_levenshtein;
+
+pub use cost_map::CostMap;
+pub use types::*;
+pub use weighted_levenshtein::custom_levenshtein_distance_with_cost_maps;
+
+#[cfg(feature = "python")]
+mod rust_stringdist;
+#[cfg(feature = "python")]
+pub use rust_stringdist::_rust_stringdist;