lionagi 0.5.5__py3-none-any.whl → 0.6.1__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/pandas_adapter.py

@@ -1,96 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import logging
-from pathlib import Path
-
-import pandas as pd
-
-from lionagi.integrations.pandas_ import to_df
-from lionagi.protocols.adapters.adapter import Adapter, T
-
-
-class PandasSeriesAdapter(Adapter):
-
-    obj_key = "pd_series"
-    alias = ("pandas_series", "pd.series", "pd_series")
-
-    @classmethod
-    def from_obj(cls, subj_cls: type[T], obj: pd.Series, /, **kwargs) -> dict:
-        return obj.to_dict(**kwargs)
-
-    @classmethod
-    def to_obj(cls, subj: T, /, **kwargs) -> pd.Series:
-        return pd.Series(subj.to_dict(), **kwargs)
-
-
-class PandasDataFrameAdapter(Adapter):
-
-    obj_key = "pd_dataframe"
-    alias = ("pandas_dataframe", "pd.DataFrame", "pd_dataframe")
-
-    @classmethod
-    def from_obj(
-        cls, subj_cls: type[T], obj: pd.DataFrame, /, **kwargs
-    ) -> list[dict]:
-        """kwargs for pd.DataFrame.to_dict"""
-        return obj.to_dict(orient="records", **kwargs)
-
-    @classmethod
-    def to_obj(cls, subj: list[T], /, **kwargs) -> pd.DataFrame:
-        """kwargs for pd.DataFrame"""
-        out_ = []
-        for i in subj:
-            _dict = i.to_dict()
-            _dict["timestamp"] = i.created_datetime
-            out_.append(_dict)
-        df = to_df(out_, **kwargs)
-        if "timestamp" in df.columns:
-            df["timestamp"] = pd.to_datetime(df["timestamp"])
-        return df
-
-
-class CSVFileAdapter(Adapter):
-
-    obj_key = ".csv"
-    alias = (".csv", "csv_file", "csv")
-
-    @classmethod
-    def from_obj(
-        cls, subj_cls: type[T], obj: str | Path, /, **kwargs
-    ) -> list[dict]:
-        """kwargs for pd.read_csv"""
-        df = pd.read_csv(obj, **kwargs)
-        return df.to_dict(orient="records")
-
-    @classmethod
-    def to_obj(
-        cls,
-        subj: list[T],
-        /,
-        fp: str | Path,
-        **kwargs,
-    ) -> None:
-        """kwargs for pd.DataFrame.to_csv"""
-        kwargs["index"] = False
-        to_df([i.to_dict() for i in subj]).to_csv(fp, **kwargs)
-        logging.info(f"Successfully saved data to {fp}")
-
-
-class ExcelFileAdapter(Adapter):
-
-    obj_key = ".xlsx"
-    alias = (".xlsx", "excel_file", "excel", "xlsx", "xls", ".xls")
-
-    @classmethod
-    def from_obj(
-        cls, subj_cls: type[T], obj: str | Path, /, **kwargs
-    ) -> list[dict]:
-        return pd.read_excel(obj, **kwargs).to_dict(orient="records")
-
-    @classmethod
-    def to_obj(cls, subj: list[T], /, fp: str | Path, **kwargs) -> None:
-        kwargs["index"] = False
-        to_df([i.to_dict() for i in subj]).to_excel(fp, **kwargs)
-        logging.info(f"Saved {subj.class_name()} to {fp}")

lionagi/protocols/configs/branch_config.py

@@ -1,86 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from typing import Any, Literal
-
-from lionagi.core.models.schema_model import SchemaModel
-from lionagi.core.typing._pydantic import Field
-
-from .imodel_config import iModelConfig
-from .log_config import LogConfig
-from .retry_config import TimedFuncCallConfig
-
-
-class MessageConfig(SchemaModel):
-    """Configuration for message handling in Branch"""
-
-    validation_mode: Literal["raise", "return_value", "return_none"] = Field(
-        default="return_value",
-        description="How to handle message validation failures",
-    )
-    auto_retries: bool = Field(
-        False, description="Whether to automatically retry message parsing"
-    )
-
-    max_retries: int = Field(
-        default=0, description="Maximum retries for message parsing"
-    )
-    allow_actions: bool = Field(
-        default=True,
-        description="Whether to allow action requests in messages",
-    )
-    auto_invoke_action: bool = Field(
-        default=True, description="Whether to automatically invoke actions"
-    )
-
-
-class BranchConfig(SchemaModel):
-    """Main configuration for Branch class.
-
-    Combines all aspects of Branch configuration including logging,
-    message handling, tool management, and iModel integration.
-    """
-
-    name: str | None = Field(
-        default=None, description="Branch name for identification"
-    )
-    user: str | None = Field(
-        default=None, description="User ID/name for the branch"
-    )
-    message_log_config: LogConfig = Field(
-        default_factory=LogConfig,
-        description="Configuration for log management",
-    )
-    action_log_config: LogConfig = Field(
-        default_factory=LogConfig,
-        description="Configuration for action log management",
-    )
-    message_config: MessageConfig = Field(
-        default_factory=MessageConfig,
-        description="Configuration for message handling",
-    )
-    auto_register_tools: bool = Field(
-        default=True,
-        description="Whether to automatically register tools when needed",
-    )
-    action_call_config: TimedFuncCallConfig = Field(
-        default_factory=TimedFuncCallConfig,
-        description="Configuration for action execution",
-    )
-    imodel_config: iModelConfig | None = Field(
-        default=None, description="Configuration for iModel integration"
-    )
-    retry_imodel_config: iModelConfig | None = Field(
-        default=None, description="Configuration for iModel integration"
-    )
-    kwargs: dict[str, Any] = Field(
-        default_factory=dict,
-        description="Additional branch-specific configurations",
-    )
-
-
-__all__ = [
-    "MessageConfig",
-    "BranchConfig",
-]