veridica 0.1.0__tar.gz

veridica-0.1.0/LICENCE

@@ -0,0 +1,7 @@
+Copyright 2025 Sebastiaan Swanenberg
+
+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.

veridica-0.1.0/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.3
+Name: veridica
+Version: 0.1.0
+Summary: Fuzzy matching for the use in gherkin based automated tests.
+License: MIT
+Author: Sebastiaan Swanenberg
+Author-email: Sebastiaan@staeble.it
+Requires-Python: >=3.12,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Description-Content-Type: text/markdown
+
+# Veridica
+
+This project was made for the use of fuzzy comparison algorithmic comparisons for the use in gherkin based test automation.
+
+We found that it was required to have full control over the system to limit dependencies. However that does not mean that others cannot use the code that I have developed and will use.
+
+## Overview
+
+Veridica provides a set of pure Python algorithms to compare strings reliably based on fixed math based algorithms.
+
+It includes:
+
+- Classic string similarity metrics Classic string to string matching based on algorithms like levenstein.
+
+- One-to-many batch comparisons While one to one comparisons can give you a sence of what you are looking for, most usecases involve the comparion for one item to a set. Therefore an implementation was made using classic and recursive techniques that can be directly implemented.
+
+- Timing utilities for measuring comparison performance For now limited to a wrapper function that can give back the time it took to complete for compartive data.
+
+## Installation
+
+You can install the package via **PyPI** or from **source**.
+
+### Install from PyPI
+
+```bash
+pip install veridica
+
+```
+
+### Install from Source (GitHub)
+
+```bash
+git clone https://github.com/sebastiaanswanenberg/veridica.git
+cd veridica
+pip install .
+```
+
+## Usage
+
+After installation, you can use `veridica` to compare strings one to one or compare a string to a set.
+
+### Example: Comparing strings one-to-one.
+
+```python
+from veridica.similarity import levenshtein
+
+```
+
+### Example: Comparing string to a set of strings.
+
+```python
+from veridica.similarity import levenshtein
+from veridica.batch import compare_many
+
+
+```
+
+### Example: Time your string to set calculations.
+
+```python
+from veridica.similarity import levenshtein
+from veridica.batch import compare_many
+from veridica.timing import timed
+
+```
+
+## Testing
+
+This project includes a test suite. You can run tests using `pytest`:
+
+```bash
+pip install pytest
+pytest tests
+```
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for more details.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit pull requests or open issues if you have any suggestions or find bugs.
+

veridica-0.1.0/README.md

@@ -0,0 +1,82 @@
+# Veridica
+
+This project was made for the use of fuzzy comparison algorithmic comparisons for the use in gherkin based test automation.
+
+We found that it was required to have full control over the system to limit dependencies. However that does not mean that others cannot use the code that I have developed and will use.
+
+## Overview
+
+Veridica provides a set of pure Python algorithms to compare strings reliably based on fixed math based algorithms.
+
+It includes:
+
+- Classic string similarity metrics Classic string to string matching based on algorithms like levenstein.
+
+- One-to-many batch comparisons While one to one comparisons can give you a sence of what you are looking for, most usecases involve the comparion for one item to a set. Therefore an implementation was made using classic and recursive techniques that can be directly implemented.
+
+- Timing utilities for measuring comparison performance For now limited to a wrapper function that can give back the time it took to complete for compartive data.
+
+## Installation
+
+You can install the package via **PyPI** or from **source**.
+
+### Install from PyPI
+
+```bash
+pip install veridica
+
+```
+
+### Install from Source (GitHub)
+
+```bash
+git clone https://github.com/sebastiaanswanenberg/veridica.git
+cd veridica
+pip install .
+```
+
+## Usage
+
+After installation, you can use `veridica` to compare strings one to one or compare a string to a set.
+
+### Example: Comparing strings one-to-one.
+
+```python
+from veridica.similarity import levenshtein
+
+```
+
+### Example: Comparing string to a set of strings.
+
+```python
+from veridica.similarity import levenshtein
+from veridica.batch import compare_many
+
+
+```
+
+### Example: Time your string to set calculations.
+
+```python
+from veridica.similarity import levenshtein
+from veridica.batch import compare_many
+from veridica.timing import timed
+
+```
+
+## Testing
+
+This project includes a test suite. You can run tests using `pytest`:
+
+```bash
+pip install pytest
+pytest tests
+```
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for more details.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit pull requests or open issues if you have any suggestions or find bugs.

veridica-0.1.0/pyproject.toml

@@ -0,0 +1,19 @@
+[tool.poetry]
+name = "veridica"
+version = "0.1.0"
+description = "Fuzzy matching for the use in gherkin based automated tests."
+authors = ["Sebastiaan Swanenberg <Sebastiaan@staeble.it>"]
+license = "MIT"
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.12"
+
+[tool.poetry.dev-dependencies]
+pytest = "^7.4"
+black = "^24.9"
+isort = "^6.0"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

veridica-0.1.0/src/veridica/batch.py

@@ -0,0 +1,18 @@
+"""One-to-many string comparison helpers."""
+
+from typing import Iterable, Callable
+
+def compare_many(target: str, candidates: Iterable[str], comparator: Callable[[str, str], float]) -> list[tuple[str, float]]:
+    """
+    Compare a single target string against many candidates using the given comparator that returns a list with a numeric score.
+
+    Args:
+        target (str): string to compare
+        candidates (Iterable[str]): strings to compare against
+        comparator (Callable[[str, str], float]): function returning a numeric score for similarity
+
+    Returns:
+        list[tuple[str, float]]: (candidate, score) pairs ordered by descending score (best matches first)
+    """
+    scores = [(candidate, float(comparator(target, candidate))) for candidate in candidates]
+    return sorted(scores, key=lambda pair: pair[1], reverse=True)

veridica-0.1.0/src/veridica/normalisation.py

@@ -0,0 +1 @@
+"""Helper functions for the normalisation of scores when using multiple algorithms."""

veridica-0.1.0/src/veridica/similarity.py

@@ -0,0 +1,107 @@
+"""String similarity measurement functions."""
+
+from collections import defaultdict
+
+def levenshtein_distance(s1: str, s2: str) -> int:
+    """Calculate the levenstein distance between two strings"""
+
+    if s1 == s2:
+        return 0
+    rows = len(s1) + 1
+    cols = len(s2) + 1
+
+    if not s1:
+        return cols - 1
+    if not s2:
+        return rows - 1
+
+    prev = None
+    cur = range(cols)
+    for r in range(1, rows):
+        prev, cur = cur, [r] + [0] * (cols - 1)
+        for c in range(1, cols):
+            deletion = prev[c] + 1
+            insertion = cur[c - 1] + 1
+            edit = prev[c - 1] + (0 if s1[r - 1] == s2[c - 1] else 1)
+            cur[c] = min(edit, deletion, insertion)
+
+    return cur[-1]
+
+def jaccard_distance(s1: str, s2: str) -> float:
+    """Calculate the Jaccard distance between two strings."""
+    # split on whitespace into token sets
+    set1 = set(s1.split())
+    set2 = set(s2.split())
+
+    # both empty -> identical
+    if not set1 and not set2:
+        return 0.0
+
+    intersection = set1 & set2
+    union = set1 | set2
+
+    # guard against division by zero (shouldn't happen due to check above)
+    if not union:
+        return 0.0
+
+    return 1.0 - (len(intersection) / len(union))
+
+def hamming_distance(s1: str, s2: str) -> float:
+    """Calculate the Hamming distance between two strings."""
+    # ensure length of s1 >= s2
+    if len(s2) > len(s1):
+        s1, s2 = s2, s1
+
+    # distance is difference in length + differing chars
+    distance = len(s1) - len(s2)
+    for i, c in enumerate(s2):
+        if c != s1[i]:
+            distance += 1
+
+    return distance
+
+def damerau_levenshtein_distance(s1: str, s2: str) -> int:
+    """Calculate the Damerau-Levenshtein distance between two strings."""
+
+    if not isinstance(s1, str):
+        return 0
+    if not isinstance(s2, str):
+        return 0
+
+    len1 = len(s1)
+    len2 = len(s2)
+    infinite = len1 + len2
+
+    # character array
+    da = defaultdict(int)
+
+    # distance matrix
+    score = [[0] * (len2 + 2) for x in range(len1 + 2)]
+
+    score[0][0] = infinite
+    for i in range(0, len1 + 1):
+        score[i + 1][0] = infinite
+        score[i + 1][1] = i
+    for i in range(0, len2 + 1):
+        score[0][i + 1] = infinite
+        score[1][i + 1] = i
+
+    for i in range(1, len1 + 1):
+        db = 0
+        for j in range(1, len2 + 1):
+            i1 = da[s2[j - 1]]
+            j1 = db
+            cost = 1
+            if s1[i - 1] == s2[j - 1]:
+                cost = 0
+                db = j
+
+            score[i + 1][j + 1] = min(
+                score[i][j] + cost,
+                score[i + 1][j] + 1,
+                score[i][j + 1] + 1,
+                score[i1][j1] + (i - i1 - 1) + 1 + (j - j1 - 1),
+            )
+        da[s1[i - 1]] = i
+
+    return score[len1 + 1][len2 + 1]

veridica-0.1.0/src/veridica/timing.py

@@ -0,0 +1,26 @@
+"""Timing decorators and utilities for measuring comparison performance."""
+
+import time
+from functools import wraps
+from typing import Callable, Any
+
+def timed(func: Callable) -> Callable:
+    """
+    Decorator to measure the execution time of a function.
+
+    Usage:
+        @timed
+        def my_func(...):
+            ...
+
+    Returns:
+        function: wrapped function
+    """
+    @wraps(func)
+    def wrapper(*args, **kwargs) -> tuple[Any, float]:
+        start = time.perf_counter()
+        end = time.perf_counter()
+        elapsed = end - start
+        result = func(*args, **kwargs)
+        return elapsed, result
+    return wrapper