lionagi 0.15.14__py3-none-any.whl → 0.16.1__py3-none-any.whl

lionagi/adapters/async_postgres_adapter.py

@@ -89,7 +89,7 @@ class LionAGIAsyncPostgresAdapter(AsyncPostgresAdapter[T]):
                         sa.Column("id", sa.String, primary_key=True),
                         sa.Column("content", json_type),
                         sa.Column("node_metadata", json_type),
-                        sa.Column("created_at", sa.DateTime),
+                        sa.Column("created_at", sa.Float),
                         sa.Column("embedding", json_type, nullable=True),
                     ).create(sync_conn, checkfirst=True)
                 )

lionagi/libs/nested/ninsert.py

@@ -50,8 +50,7 @@ def ninsert(
         if isinstance(part, int):
             if isinstance(nested_structure, dict):
                 raise TypeError(
-                    f"Unsupported key type: {type(part).__name__}."
-                    "Only string keys are acceptable.",
+                    f"Unsupported key type: {type(part).__name__}.Only string keys are acceptable.",
                 )
             while len(nested_structure) <= part:
                 nested_structure.append(None)
@@ -67,8 +66,7 @@ def ninsert(
                 raise TypeError("Cannot use NoneType as a key in a dictionary")
             if isinstance(part, (float, complex)):
                 raise TypeError(
-                    f"Unsupported key type: {type(part).__name__}."
-                    "Only string keys are acceptable.",
+                    f"Unsupported key type: {type(part).__name__}.Only string keys are acceptable.",
                 )
             if part not in nested_structure:
                 next_part = indices[i + 1]
@@ -77,8 +75,7 @@ def ninsert(
                 )
         else:
             raise TypeError(
-                f"Invalid container type: {type(nested_structure)} "
-                "encountered during insertion"
+                f"Invalid container type: {type(nested_structure)} encountered during insertion"
             )
 
         nested_structure = nested_structure[part]

lionagi/libs/nested/nmerge.py

@@ -51,8 +51,7 @@ def nmerge(
         return _merge_sequences(nested_structure, sort_list, custom_sort)
     else:
         raise TypeError(
-            "All items in the input list must be of the same type, "
-            "either dict, list, or Iterable."
+            "All items in the input list must be of the same type, either dict, list, or Iterable."
         )
 
 

lionagi/libs/validate/fuzzy_match_keys.py

@@ -1,184 +1,7 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from collections.abc import Callable, Sequence
-from typing import Any, Literal
-
-from lionagi.utils import KeysDict, Params
-
-from .string_similarity import (
-    SIMILARITY_ALGO_MAP,
-    SIMILARITY_TYPE,
-    string_similarity,
+from lionagi.ln.fuzzy._fuzzy_match import (
+    FuzzyMatchKeysParams,
+    HandleUnmatched,
+    fuzzy_match_keys,
 )
 
-__all__ = (
-    "fuzzy_match_keys",
-    "FuzzyMatchKeysParams",
-)
-
-
-class FuzzyMatchKeysParams(Params):
-    similarity_algo: SIMILARITY_TYPE | Callable[[str, str], float] = (
-        "jaro_winkler"
-    )
-    similarity_threshold: float = 0.85
-    fuzzy_match: bool = True
-    handle_unmatched: Literal["ignore", "raise", "remove", "fill", "force"] = (
-        "ignore"
-    )
-    fill_value: Any = None
-    fill_mapping: dict[str, Any] | None = None
-    strict: bool = False
-
-    def __call__(
-        self, d_: dict[str, Any], keys: Sequence[str] | KeysDict
-    ) -> dict[str, Any]:
-        return fuzzy_match_keys(
-            d_,
-            keys,
-            similarity_algo=self.similarity_algo,
-            similarity_threshold=self.similarity_threshold,
-            fuzzy_match=self.fuzzy_match,
-            handle_unmatched=self.handle_unmatched,
-            fill_value=self.fill_value,
-            fill_mapping=self.fill_mapping,
-            strict=self.strict,
-        )
-
-
-def fuzzy_match_keys(
-    d_: dict[str, Any],
-    keys: Sequence[str] | KeysDict,
-    /,
-    *,
-    similarity_algo: (
-        SIMILARITY_TYPE | Callable[[str, str], float]
-    ) = "jaro_winkler",
-    similarity_threshold: float = 0.85,
-    fuzzy_match: bool = True,
-    handle_unmatched: Literal[
-        "ignore", "raise", "remove", "fill", "force"
-    ] = "ignore",
-    fill_value: Any = None,
-    fill_mapping: dict[str, Any] | None = None,
-    strict: bool = False,
-) -> dict[str, Any]:
-    """
-    Validate and correct dictionary keys based on expected keys using string similarity.
-
-    Args:
-        d_: The dictionary to validate and correct keys for.
-        keys: List of expected keys or dictionary mapping keys to types.
-        similarity_algo: String similarity algorithm to use or custom function.
-        similarity_threshold: Minimum similarity score for fuzzy matching.
-        fuzzy_match: If True, use fuzzy matching for key correction.
-        handle_unmatched: Specifies how to handle unmatched keys:
-            - "ignore": Keep unmatched keys in output.
-            - "raise": Raise ValueError if unmatched keys exist.
-            - "remove": Remove unmatched keys from output.
-            - "fill": Fill unmatched keys with default value/mapping.
-            - "force": Combine "fill" and "remove" behaviors.
-        fill_value: Default value for filling unmatched keys.
-        fill_mapping: Dictionary mapping unmatched keys to default values.
-        strict: If True, raise ValueError if any expected key is missing.
-
-    Returns:
-        A new dictionary with validated and corrected keys.
-
-    Raises:
-        ValueError: If validation fails based on specified parameters.
-        TypeError: If input types are invalid.
-        AttributeError: If key validation fails.
-    """
-    # Input validation
-    if not isinstance(d_, dict):
-        raise TypeError("First argument must be a dictionary")
-    if keys is None:
-        raise TypeError("Keys argument cannot be None")
-    if not 0.0 <= similarity_threshold <= 1.0:
-        raise ValueError("similarity_threshold must be between 0.0 and 1.0")
-
-    # Extract expected keys
-    fields_set = set(keys) if isinstance(keys, list) else set(keys.keys())
-    if not fields_set:
-        return d_.copy()  # Return copy of original if no expected keys
-
-    # Initialize output dictionary and tracking sets
-    corrected_out = {}
-    matched_expected = set()
-    matched_input = set()
-
-    # Get similarity function
-    if isinstance(similarity_algo, str):
-        if similarity_algo not in SIMILARITY_ALGO_MAP:
-            raise ValueError(
-                f"Unknown similarity algorithm: {similarity_algo}"
-            )
-        similarity_func = SIMILARITY_ALGO_MAP[similarity_algo]
-    else:
-        similarity_func = similarity_algo
-
-    # First pass: exact matches
-    for key in d_:
-        if key in fields_set:
-            corrected_out[key] = d_[key]
-            matched_expected.add(key)
-            matched_input.add(key)
-
-    # Second pass: fuzzy matching if enabled
-    if fuzzy_match:
-        remaining_input = set(d_.keys()) - matched_input
-        remaining_expected = fields_set - matched_expected
-
-        for key in remaining_input:
-            if not remaining_expected:
-                break
-
-            matches = string_similarity(
-                key,
-                list(remaining_expected),
-                algorithm=similarity_func,
-                threshold=similarity_threshold,
-                return_most_similar=True,
-            )
-
-            if matches:
-                match = matches
-                corrected_out[match] = d_[key]
-                matched_expected.add(match)
-                matched_input.add(key)
-                remaining_expected.remove(match)
-            elif handle_unmatched == "ignore":
-                corrected_out[key] = d_[key]
-
-    # Handle unmatched keys based on handle_unmatched parameter
-    unmatched_input = set(d_.keys()) - matched_input
-    unmatched_expected = fields_set - matched_expected
-
-    if handle_unmatched == "raise" and unmatched_input:
-        raise ValueError(f"Unmatched keys found: {unmatched_input}")
-
-    elif handle_unmatched == "ignore":
-        for key in unmatched_input:
-            corrected_out[key] = d_[key]
-
-    elif handle_unmatched in ("fill", "force"):
-        # Fill missing expected keys
-        for key in unmatched_expected:
-            if fill_mapping and key in fill_mapping:
-                corrected_out[key] = fill_mapping[key]
-            else:
-                corrected_out[key] = fill_value
-
-        # For "fill" mode, also keep unmatched original keys
-        if handle_unmatched == "fill":
-            for key in unmatched_input:
-                corrected_out[key] = d_[key]
-
-    # Check strict mode
-    if strict and unmatched_expected:
-        raise ValueError(f"Missing required keys: {unmatched_expected}")
-
-    return corrected_out
+__all__ = ("fuzzy_match_keys", "FuzzyMatchKeysParams", "HandleUnmatched")

lionagi/libs/validate/string_similarity.py

@@ -1,332 +1,7 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
+from lionagi.ln.fuzzy._string_similarity import (
+    SIMILARITY_TYPE,
+    SimilarityFunc,
+    string_similarity,
+)
 
-from collections.abc import Callable, Sequence
-from dataclasses import dataclass
-from difflib import SequenceMatcher
-from itertools import product
-from typing import Literal
-
-__all__ = ("string_similarity",)
-
-
-def cosine_similarity(s1: str, s2: str) -> float:
-    """Calculate the cosine similarity between two strings.
-
-    Args:
-        s1: First input string
-        s2: Second input string
-
-    Returns:
-        float: Cosine similarity score between 0 and 1
-    """
-    if not s1 or not s2:
-        return 0.0
-
-    set1, set2 = set(s1), set(s2)
-    intersection = set1.intersection(set2)
-
-    if not set1 or not set2:
-        return 0.0
-
-    return len(intersection) / ((len(set1) * len(set2)) ** 0.5)
-
-
-def hamming_similarity(s1: str, s2: str) -> float:
-    """Calculate the Hamming similarity between two strings.
-
-    The strings must be of equal length. Returns the proportion of positions
-    at which corresponding symbols are the same.
-
-    Args:
-        s1: First input string
-        s2: Second input string
-
-    Returns:
-        float: Hamming similarity score between 0 and 1
-    """
-    if not s1 or not s2 or len(s1) != len(s2):
-        return 0.0
-
-    matches = sum(c1 == c2 for c1, c2 in zip(s1, s2))
-    return matches / len(s1)
-
-
-def jaro_distance(s: str, t: str) -> float:
-    """Calculate the Jaro distance between two strings.
-
-    Args:
-        s: First input string
-        t: Second input string
-
-    Returns:
-        float: Jaro distance score between 0 and 1
-    """
-    s_len = len(s)
-    t_len = len(t)
-
-    if s_len == 0 and t_len == 0:
-        return 1.0
-    elif s_len == 0 or t_len == 0:
-        return 0.0
-
-    match_distance = (max(s_len, t_len) // 2) - 1
-    match_distance = max(0, match_distance)  # Ensure non-negative
-
-    s_matches = [False] * s_len
-    t_matches = [False] * t_len
-
-    matches = 0
-    transpositions = 0
-
-    # Identify matches
-    for i in range(s_len):
-        start = max(0, i - match_distance)
-        end = min(i + match_distance + 1, t_len)
-
-        for j in range(start, end):
-            if t_matches[j] or s[i] != t[j]:
-                continue
-            s_matches[i] = t_matches[j] = True
-            matches += 1
-            break
-
-    if matches == 0:
-        return 0.0
-
-    # Count transpositions
-    k = 0
-    for i in range(s_len):
-        if not s_matches[i]:
-            continue
-        while not t_matches[k]:
-            k += 1
-        if s[i] != t[k]:
-            transpositions += 1
-        k += 1
-
-    transpositions //= 2
-
-    return (
-        matches / s_len
-        + matches / t_len
-        + (matches - transpositions) / matches
-    ) / 3.0
-
-
-def jaro_winkler_similarity(s: str, t: str, scaling: float = 0.1) -> float:
-    """Calculate the Jaro-Winkler similarity between two strings.
-
-    Args:
-        s: First input string
-        t: Second input string
-        scaling: Scaling factor for common prefix adjustment
-
-    Returns:
-        float: Jaro-Winkler similarity score between 0 and 1
-
-    Raises:
-        ValueError: If scaling factor is not between 0 and 0.25
-    """
-    if not 0 <= scaling <= 0.25:
-        raise ValueError("Scaling factor must be between 0 and 0.25")
-
-    jaro_sim = jaro_distance(s, t)
-
-    # Find length of common prefix (up to 4 chars)
-    prefix_len = 0
-    for s_char, t_char in zip(s, t):
-        if s_char != t_char:
-            break
-        prefix_len += 1
-        if prefix_len == 4:
-            break
-
-    return jaro_sim + (prefix_len * scaling * (1 - jaro_sim))
-
-
-def levenshtein_distance(a: str, b: str) -> int:
-    """Calculate the Levenshtein (edit) distance between two strings.
-
-    Args:
-        a: First input string
-        b: Second input string
-
-    Returns:
-        int: Minimum number of single-character edits needed to change one
-             string into the other
-    """
-    if not a:
-        return len(b)
-    if not b:
-        return len(a)
-
-    m, n = len(a), len(b)
-    d = [[0] * (n + 1) for _ in range(m + 1)]
-
-    for i in range(m + 1):
-        d[i][0] = i
-    for j in range(n + 1):
-        d[0][j] = j
-
-    for i, j in product(range(1, m + 1), range(1, n + 1)):
-        cost = 0 if a[i - 1] == b[j - 1] else 1
-        d[i][j] = min(
-            d[i - 1][j] + 1,  # deletion
-            d[i][j - 1] + 1,  # insertion
-            d[i - 1][j - 1] + cost,  # substitution
-        )
-
-    return d[m][n]
-
-
-def levenshtein_similarity(s1: str, s2: str) -> float:
-    """Calculate the Levenshtein similarity between two strings.
-
-    Converts Levenshtein distance to a similarity score between 0 and 1.
-
-    Args:
-        s1: First input string
-        s2: Second input string
-
-    Returns:
-        float: Levenshtein similarity score between 0 and 1
-    """
-    if not s1 and not s2:
-        return 1.0
-    if not s1 or not s2:
-        return 0.0
-
-    distance = levenshtein_distance(s1, s2)
-    max_len = max(len(s1), len(s2))
-    return 1 - (distance / max_len)
-
-
-def sequence_matcher_similarity(s1: str, s2: str) -> float:
-    """Calculate similarity using Python's SequenceMatcher.
-
-    Args:
-        s1: First input string
-        s2: Second input string
-
-    Returns:
-        float: Similarity score between 0 and 1
-    """
-    return SequenceMatcher(None, s1, s2).ratio()
-
-
-# Map of available similarity algorithms
-SIMILARITY_ALGO_MAP = {
-    "jaro_winkler": jaro_winkler_similarity,
-    "levenshtein": levenshtein_similarity,
-    "sequence_matcher": sequence_matcher_similarity,
-    "hamming": hamming_similarity,
-    "cosine": cosine_similarity,
-}
-
-
-SIMILARITY_TYPE = Literal[
-    "jaro_winkler",
-    "levenshtein",
-    "sequence_matcher",
-    "hamming",
-    "cosine",
-]
-
-# Type alias for similarity functions
-SimilarityFunc = Callable[[str, str], float]
-
-
-@dataclass(frozen=True)
-class MatchResult:
-    """Represents a string matching result."""
-
-    word: str
-    score: float
-    index: int
-
-
-def string_similarity(
-    word: str,
-    correct_words: Sequence[str],
-    algorithm: SIMILARITY_TYPE | Callable[[str, str], float] = "jaro_winkler",
-    threshold: float = 0.0,
-    case_sensitive: bool = False,
-    return_most_similar: bool = False,
-) -> str | list[str] | None:
-    """Find similar strings using specified similarity algorithm.
-
-    Args:
-        word: The input string to find matches for
-        correct_words: List of strings to compare against
-        algorithm: Similarity algorithm to use
-        threshold: Minimum similarity score (0.0 to 1.0)
-        case_sensitive: Whether to consider case when matching
-        return_most_similar: Return only the most similar match
-
-    Returns:
-        Matching string(s) or None if no matches found
-
-    Raises:
-        ValueError: If correct_words is empty or threshold is invalid
-    """
-    if not correct_words:
-        raise ValueError("correct_words must not be empty")
-
-    if not 0.0 <= threshold <= 1.0:
-        raise ValueError("threshold must be between 0.0 and 1.0")
-
-    # Convert inputs to strings
-    compare_word = str(word)
-    original_words = [str(w) for w in correct_words]
-
-    # Handle case sensitivity
-    if not case_sensitive:
-        compare_word = compare_word.lower()
-        compare_words = [w.lower() for w in original_words]
-    else:
-        compare_words = original_words.copy()
-
-    # Get scoring function
-    if isinstance(algorithm, str):
-        score_func = SIMILARITY_ALGO_MAP.get(algorithm)
-        if score_func is None:
-            raise ValueError(f"Unsupported algorithm: {algorithm}")
-    elif callable(algorithm):
-        score_func = algorithm
-    else:
-        raise ValueError(
-            "algorithm must be a string specifying a built-in algorithm or a callable"
-        )
-
-    # Calculate similarities
-    results = []
-    for idx, (orig_word, comp_word) in enumerate(
-        zip(original_words, compare_words)
-    ):
-        # Skip different length strings for hamming similarity
-        if algorithm == "hamming" and len(comp_word) != len(compare_word):
-            continue
-
-        score = score_func(compare_word, comp_word)
-        if score >= threshold:
-            results.append(MatchResult(orig_word, score, idx))
-
-    # Return None if no matches
-    if not results:
-        return None
-
-    # Sort by score (descending) and index (ascending) for stable ordering
-    results.sort(key=lambda x: (-x.score, x.index))
-
-    # Filter exact matches for case sensitive comparisons
-    if case_sensitive:
-        max_score = results[0].score
-        results = [r for r in results if r.score == max_score]
-
-    # Return results
-    if return_most_similar:
-        return results[0].word
-
-    return [r.word for r in results]
+__all__ = ("string_similarity", "SIMILARITY_TYPE", "SimilarityFunc")