lionagi 0.5.4__py3-none-any.whl → 0.6.0__py3-none-any.whl

lionagi/libs/parse/xml/parser.py

@@ -1,93 +0,0 @@
-import re
-from typing import Any
-
-
-class XMLParser:
-    def __init__(self, xml_string: str):
-        self.xml_string = xml_string.strip()
-        self.index = 0
-
-    def parse(self) -> dict[str, Any]:
-        """Parse the XML string and return the root element as a dictionary."""
-        return self._parse_element()
-
-    def _parse_element(self) -> dict[str, Any]:
-        """Parse a single XML element and its children."""
-        self._skip_whitespace()
-        if self.xml_string[self.index] != "<":
-            raise ValueError(
-                f"Expected '<', found '{self.xml_string[self.index]}'"
-            )
-
-        tag, attributes = self._parse_opening_tag()
-        children: dict[str, str | list | dict] = {}
-        text = ""
-
-        while self.index < len(self.xml_string):
-            self._skip_whitespace()
-            if self.xml_string.startswith("</", self.index):
-                closing_tag = self._parse_closing_tag()
-                if closing_tag != tag:
-                    raise ValueError(
-                        f"Mismatched tags: '{tag}' and '{closing_tag}'"
-                    )
-                break
-            elif self.xml_string.startswith("<", self.index):
-                child = self._parse_element()
-                child_tag, child_data = next(iter(child.items()))
-                if child_tag in children:
-                    if not isinstance(children[child_tag], list):
-                        children[child_tag] = [children[child_tag]]
-                    children[child_tag].append(child_data)
-                else:
-                    children[child_tag] = child_data
-            else:
-                text += self._parse_text()
-
-        result: dict[str, Any] = {}
-        if attributes:
-            result["@attributes"] = attributes
-        if children:
-            result.update(children)
-        elif text.strip():
-            result = text.strip()
-
-        return {tag: result}
-
-    def _parse_opening_tag(self) -> tuple[str, dict[str, str]]:
-        """Parse an opening XML tag and its attributes."""
-        match = re.match(
-            r'<(\w+)((?:\s+\w+="[^"]*")*)\s*/?>',
-            self.xml_string[self.index :],  # noqa
-        )
-        if not match:
-            raise ValueError("Invalid opening tag")
-        self.index += match.end()
-        tag = match.group(1)
-        attributes = dict(re.findall(r'(\w+)="([^"]*)"', match.group(2)))
-        return tag, attributes
-
-    def _parse_closing_tag(self) -> str:
-        """Parse a closing XML tag."""
-        match = re.match(r"</(\w+)>", self.xml_string[self.index :])  # noqa
-        if not match:
-            raise ValueError("Invalid closing tag")
-        self.index += match.end()
-        return match.group(1)
-
-    def _parse_text(self) -> str:
-        """Parse text content between XML tags."""
-        start = self.index
-        while (
-            self.index < len(self.xml_string)
-            and self.xml_string[self.index] != "<"
-        ):
-            self.index += 1
-        return self.xml_string[start : self.index]  # noqa
-
-    def _skip_whitespace(self) -> None:
-        """Skip any whitespace characters at the current parsing position."""
-        p_ = len(self.xml_string[self.index :])  # noqa
-        m_ = len(self.xml_string[self.index :].lstrip())  # noqa
-
-        self.index += p_ - m_

lionagi/libs/string_similarity/__init__.py

@@ -1,32 +0,0 @@
-"""String similarity calculation and matching functionality."""
-
-from .algorithms import (
-    SIMILARITY_ALGO_MAP,
-    cosine_similarity,
-    hamming_similarity,
-    jaro_distance,
-    jaro_winkler_similarity,
-    levenshtein_distance,
-    levenshtein_similarity,
-    sequence_matcher_similarity,
-)
-from .matcher import MatchResult, string_similarity
-from .utils import SIMILARITY_TYPE, SimilarityFunc
-
-__all__ = [
-    # Main functionality
-    "string_similarity",
-    "MatchResult",
-    # Algorithms
-    "cosine_similarity",
-    "hamming_similarity",
-    "jaro_distance",
-    "jaro_winkler_similarity",
-    "levenshtein_distance",
-    "levenshtein_similarity",
-    "sequence_matcher_similarity",
-    # Types and constants
-    "SIMILARITY_TYPE",
-    "SimilarityFunc",
-    "SIMILARITY_ALGO_MAP",
-]

lionagi/libs/string_similarity/matcher.py

@@ -1,102 +0,0 @@
-"""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

@@ -1,15 +0,0 @@
-"""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

@@ -1,266 +0,0 @@
-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 dataclasses import asdict
-from datetime import datetime, timezone
-from hashlib import sha256
-from typing import Literal, Self, TypeVar
-
-T = TypeVar("T")
-
-
-class DataClass:
-
-    def to_dict(self) -> dict:
-        return asdict(self)
-
-    @classmethod
-    def from_dict(cls, data: dict) -> Self:
-        return cls(**data)
-
-
-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/protocols/adapters/adapter.py

@@ -1,79 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import logging
-from typing import Any, Protocol, TypeVar, runtime_checkable
-
-from typing_extensions import get_protocol_members
-
-T = TypeVar("T")
-
-
-@runtime_checkable
-class Adapter(Protocol):
-
-    obj_key: str
-
-    @classmethod
-    def from_obj(
-        cls, subj_cls: type[T], obj: Any, /, **kwargs
-    ) -> dict | list[dict]: ...
-
-    @classmethod
-    def to_obj(cls, subj: T, /, **kwargs) -> Any: ...
-
-
-adapter_members = get_protocol_members(Adapter)  # duck typing
-
-
-class AdapterRegistry:
-
-    _adapters: dict[str, Adapter] = {}
-
-    @classmethod
-    def list_adapters(cls) -> list[tuple[str | type, ...]]:
-        return list(cls._adapters.keys())
-
-    @classmethod
-    def register(cls, adapter: type[Adapter]) -> None:
-        for member in adapter_members:
-            if not hasattr(adapter, member):
-                _str = getattr(adapter, "obj_key", None) or repr(adapter)
-                _str = _str[:50] if len(_str) > 50 else _str
-                raise AttributeError(
-                    f"Adapter {_str} missing required methods."
-                )
-
-        if isinstance(adapter, type):
-            cls._adapters[adapter.obj_key] = adapter()
-        else:
-            cls._adapters[adapter.obj_key] = adapter
-
-    @classmethod
-    def get(cls, obj_key: type | str) -> Adapter:
-        try:
-            return cls._adapters[obj_key]
-        except Exception as e:
-            logging.error(f"Error getting adapter for {obj_key}. Error: {e}")
-
-    @classmethod
-    def adapt_from(
-        cls, subj_cls: type[T], obj: Any, obj_key: type | str, **kwargs
-    ) -> dict | list[dict]:
-        try:
-            return cls.get(obj_key).from_obj(subj_cls, obj, **kwargs)
-        except Exception as e:
-            logging.error(f"Error adapting data from {obj_key}. Error: {e}")
-            raise e
-
-    @classmethod
-    def adapt_to(cls, subj: T, obj_key: type | str, **kwargs) -> Any:
-        try:
-            return cls.get(obj_key).to_obj(subj, **kwargs)
-        except Exception as e:
-            logging.error(f"Error adapting data to {obj_key}. Error: {e}")
-            raise e
-
-
-__all__ = ["AdapterRegistry", "Adapter"]

lionagi/protocols/adapters/json_adapter.py

@@ -1,43 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import json
-import logging
-from pathlib import Path
-
-from lionagi.protocols.adapters.adapter import Adapter, T
-
-
-class JsonAdapter(Adapter):
-
-    obj_key = "json"
-
-    @classmethod
-    def from_obj(cls, subj_cls: type[T], obj: str, /) -> dict:
-        return json.loads(obj)
-
-    @classmethod
-    def to_obj(cls, subj: T) -> str:
-        return json.dumps(subj.to_dict())
-
-
-class JsonFileAdapter(Adapter):
-
-    obj_key = ".json"
-
-    @classmethod
-    def from_obj(cls, subj_cls: type[T], obj: str | Path, /) -> dict:
-        with open(obj) as f:
-            return json.load(f)
-
-    @classmethod
-    def to_obj(
-        cls,
-        subj: T,
-        /,
-        fp: str | Path,
-    ) -> None:
-        with open(fp, "w") as f:
-            json.dump(subj.to_dict(), f)
-        logging.info(f"Successfully saved data to {fp}")