lionagi 0.4.0__py3-none-any.whl → 0.5.1__py3-none-any.whl

lionagi/libs/string_similarity/algorithms.py

@@ -0,0 +1,219 @@
+"""String similarity calculation algorithms."""
+
+from difflib import SequenceMatcher
+from itertools import product
+
+
+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,
+}

lionagi/libs/string_similarity/matcher.py

@@ -0,0 +1,102 @@
+"""String matching functionality using similarity algorithms."""
+
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass
+
+from .algorithms import SIMILARITY_ALGO_MAP
+from .utils import SIMILARITY_TYPE
+
+
+@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))
+
+    # Return results
+    if return_most_similar:
+        return results[0].word
+
+    # 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 [r.word for r in results]

lionagi/libs/string_similarity/utils.py

@@ -0,0 +1,15 @@
+"""Type definitions for string similarity calculations."""
+
+from collections.abc import Callable
+from typing import Literal
+
+SIMILARITY_TYPE = Literal[
+    "jaro_winkler",
+    "levenshtein",
+    "sequence_matcher",
+    "hamming",
+    "cosine",
+]
+
+# Type alias for similarity functions
+SimilarityFunc = Callable[[str, str], float]

lionagi/libs/utils.py

@@ -0,0 +1,255 @@
+import ast
+import copy as _copy
+import importlib
+import importlib.metadata
+import importlib.util
+import os
+import random
+import subprocess
+import sys
+from collections.abc import Mapping, Sequence
+from datetime import datetime, timezone
+from hashlib import sha256
+from typing import Literal, TypeVar
+
+T = TypeVar("T")
+
+
+def unique_hash(n: int = 32) -> str:
+    """unique random hash"""
+    current_time = datetime.now().isoformat().encode("utf-8")
+    random_bytes = os.urandom(42)
+    return sha256(current_time + random_bytes).hexdigest()[:n]
+
+
+def is_same_dtype(
+    input_: list | dict, dtype: type | None = None, return_dtype: bool = False
+) -> bool | tuple[bool, type]:
+    """Check if all elements in input have the same data type."""
+    if not input_:
+        return True if not return_dtype else (True, None)
+
+    iterable = input_.values() if isinstance(input_, Mapping) else input_
+    first_element_type = type(next(iter(iterable), None))
+
+    dtype = dtype or first_element_type
+    result = all(isinstance(element, dtype) for element in iterable)
+    return (result, dtype) if return_dtype else result
+
+
+def insert_random_hyphens(
+    s: str,
+    num_hyphens: int = 1,
+    start_index: int | None = None,
+    end_index: int | None = None,
+) -> str:
+    """Insert random hyphens into a string."""
+    if len(s) < 2:
+        return s
+
+    prefix = s[:start_index] if start_index else ""
+    postfix = s[end_index:] if end_index else ""
+    modifiable_part = s[start_index:end_index] if start_index else s
+
+    positions = random.sample(range(len(modifiable_part)), num_hyphens)
+    positions.sort()
+
+    for pos in reversed(positions):
+        modifiable_part = modifiable_part[:pos] + "-" + modifiable_part[pos:]
+
+    return prefix + modifiable_part + postfix
+
+
+def get_file_classes(file_path):
+    with open(file_path) as file:
+        file_content = file.read()
+
+    tree = ast.parse(file_content)
+
+    class_file_dict = {}
+    for node in tree.body:
+        if isinstance(node, ast.ClassDef):
+            class_file_dict[node.name] = file_path
+
+    return class_file_dict
+
+
+def get_class_file_registry(folder_path, pattern_list):
+    class_file_registry = {}
+    for root, _, files in os.walk(folder_path):
+        for file in files:
+            if file.endswith(".py"):
+                if any(pattern in root for pattern in pattern_list):
+                    class_file_dict = get_file_classes(
+                        os.path.join(root, file)
+                    )
+                    class_file_registry.update(class_file_dict)
+    return class_file_registry
+
+
+def get_class_objects(file_path):
+    class_objects = {}
+    spec = importlib.util.spec_from_file_location("module.name", file_path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+
+    for class_name in dir(module):
+        obj = getattr(module, class_name)
+        if isinstance(obj, type):
+            class_objects[class_name] = obj
+
+    return class_objects
+
+
+def time(
+    *,
+    tz: timezone = timezone.utc,
+    type_: Literal["timestamp", "datetime", "iso", "custom"] = "timestamp",
+    sep: str | None = "T",
+    timespec: str | None = "auto",
+    custom_format: str | None = None,
+    custom_sep: str | None = None,
+) -> float | str | datetime:
+    """
+    Get current time in various formats.
+
+    Args:
+        tz: Timezone for the time (default: utc).
+        type_: Type of time to return (default: "timestamp").
+            Options: "timestamp", "datetime", "iso", "custom".
+        sep: Separator for ISO format (default: "T").
+        timespec: Timespec for ISO format (default: "auto").
+        custom_format: Custom strftime format string for
+            type_="custom".
+        custom_sep: Custom separator for type_="custom",
+            replaces "-", ":", ".".
+
+    Returns:
+        Current time in the specified format.
+
+    Raises:
+        ValueError: If an invalid type_ is provided or if custom_format
+            is not provided when type_="custom".
+    """
+    now = datetime.now(tz=tz)
+
+    if type_ == "iso":
+        return now.isoformat(sep=sep, timespec=timespec)
+    elif type_ == "timestamp":
+        return now.timestamp()
+    elif type_ == "datetime":
+        return now
+    elif type_ == "custom":
+        if not custom_format:
+            raise ValueError(
+                "custom_format must be provided when type_='custom'"
+            )
+        formatted_time = now.strftime(custom_format)
+        if custom_sep is not None:
+            for old_sep in ("-", ":", "."):
+                formatted_time = formatted_time.replace(old_sep, custom_sep)
+        return formatted_time
+
+    raise ValueError(
+        f"Invalid value <{type_}> for `type_`, must be"
+        " one of 'timestamp', 'datetime', 'iso', or 'custom'."
+    )
+
+
+def copy(obj: T, /, *, deep: bool = True, num: int = 1) -> T | list[T]:
+    """
+    Create one or more copies of an object.
+
+    Args:
+        obj: The object to be copied.
+        deep: If True, create a deep copy. Otherwise, create a shallow
+            copy.
+        num: The number of copies to create.
+
+    Returns:
+        A single copy if num is 1, otherwise a list of copies.
+
+    Raises:
+        ValueError: If num is less than 1.
+    """
+    if num < 1:
+        raise ValueError("Number of copies must be at least 1")
+
+    copy_func = _copy.deepcopy if deep else _copy.copy
+    return [copy_func(obj) for _ in range(num)] if num > 1 else copy_func(obj)
+
+
+def run_pip_command(
+    args: Sequence[str],
+) -> subprocess.CompletedProcess[bytes]:
+    """Run a pip command."""
+    return subprocess.run(
+        [sys.executable, "-m", "pip"] + list(args),
+        check=True,
+        capture_output=True,
+    )
+
+
+def format_deprecation_msg(
+    deprecated_name: str,
+    type_: str,
+    deprecated_version: str,
+    removal_version: str,
+    replacement: str | Literal["python"] | None = None,
+    additional_msg: str | None = None,
+) -> None:
+
+    msg = (
+        f"{type_}: <{deprecated_name}> is deprecated since "
+        f"<{deprecated_version}> and will be removed in {removal_version}."
+    )
+    if replacement is None:
+        msg += " No replacement is available."
+    elif replacement == "python":
+        msg += " Use the Python standard library instead."
+    elif replacement:
+        msg += f" Use <{replacement}> instead."
+    if additional_msg:
+        msg += f" {additional_msg}"
+    return msg
+
+
+def get_bins(input_: list[str], upper: int) -> list[list[int]]:
+    """Organizes indices of strings into bins based on a cumulative upper limit.
+
+    Args:
+        input_ (List[str]): The list of strings to be binned.
+        upper (int): The cumulative length upper limit for each bin.
+
+    Returns:
+        List[List[int]]: A list of bins, each bin is a list of indices from the input list.
+    """
+    current = 0
+    bins = []
+    current_bin = []
+    for idx, item in enumerate(input_):
+        if current + len(item) < upper:
+            current_bin.append(idx)
+            current += len(item)
+        else:
+            bins.append(current_bin)
+            current_bin = [idx]
+            current = len(item)
+    if current_bin:
+        bins.append(current_bin)
+    return bins
+
+
+__all__ = [
+    "unique_hash",
+    "is_same_dtype",
+    "insert_random_hyphens",
+    "get_file_classes",
+    "get_class_file_registry",
+    "get_class_objects",
+    "time",
+    "copy",
+    "run_pip_command",
+    "format_deprecation_msg",
+    "get_bins",
+]

lionagi/operations/__init__.py

@@ -1,6 +1,3 @@
-from .brainstorm import brainstorm
-from .rank import rank
-from .score import score
-from .select import select
-
-__all__ = ["brainstorm", "rank", "score", "select"]
+from .brainstorm import *
+from .plan import *
+from .select import *

lionagi/operations/brainstorm/__init__.py

@@ -0,0 +1,3 @@
+from .brainstorm import brainstorm
+
+__all__ = ["brainstorm"]