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

lionagi/libs/parse/json/parse.py

@@ -1,179 +0,0 @@
-import contextlib
-import json
-import re
-from typing import Any
-
-
-def fuzzy_parse_json(
-    str_to_parse: str, /
-) -> dict[str, Any] | list[dict[str, Any]]:
-    """Parse a JSON string with automatic fixing of common formatting issues.
-
-    Args:
-        str_to_parse: The JSON string to parse
-
-    Returns:
-        The parsed JSON object as a dictionary
-
-    Raises:
-        ValueError: If the string cannot be parsed as valid JSON
-        TypeError: If the input is not a string or the result is not a dict
-    """
-    _check_valid_str(str_to_parse)
-
-    with contextlib.suppress(Exception):
-        return json.loads(str_to_parse)
-
-    with contextlib.suppress(Exception):
-        return json.loads(_fix_braces(str_to_parse))
-
-    with contextlib.suppress(Exception):
-        str_ = _fix_braces(str_to_parse.replace("'", '"'))
-        return json.loads(str_)
-
-    with contextlib.suppress(Exception):
-        return json.loads(fix_json_string(str_to_parse))
-
-    with contextlib.suppress(Exception):
-        return json.loads(_clean_json_string(str_to_parse))
-
-    with contextlib.suppress(Exception):
-        return json.loads(fix_json_string(_clean_json_string(str_to_parse)))
-
-    with contextlib.suppress(Exception):
-        assembled = _assemble(str_to_parse)
-        return json.loads(assembled)
-
-    with contextlib.suppress(Exception):
-        assembled = _assemble(str_to_parse.replace("'", '"'))
-        return json.loads(str_)
-
-    raise ValueError("Invalid JSON string")
-
-
-def _clean_json_string(s: str) -> str:
-    """Clean and standardize a JSON string."""
-    s = re.sub(r"(?<!\\)'", '"', s)
-    s = re.sub(r"\s+", " ", s)
-    s = re.sub(r'([{,])\s*([^"\s]+):', r'\1"\2":', s)
-    return s.strip()
-
-
-def fix_json_string(str_to_parse: str, /) -> str:
-    """Fix a JSON string by ensuring all brackets are properly closed.
-
-    Args:
-        str_to_parse: JSON string to fix
-
-    Returns:
-        Fixed JSON string with proper bracket closure
-
-    Raises:
-        ValueError: If mismatched or extra closing brackets are found
-    """
-    if not str_to_parse:
-        raise ValueError("Input string is empty")
-
-    brackets = {"{": "}", "[": "]"}
-    open_brackets = []
-    pos = 0
-    length = len(str_to_parse)
-
-    while pos < length:
-        char = str_to_parse[pos]
-
-        # Handle escape sequences
-        if char == "\\":
-            pos += 2  # Skip escape sequence
-            continue
-
-        # Handle string content
-        if char == '"':
-            pos += 1
-            # Skip until closing quote, accounting for escapes
-            while pos < length:
-                if str_to_parse[pos] == "\\":
-                    pos += 2  # Skip escape sequence
-                    continue
-                if str_to_parse[pos] == '"':
-                    break
-                pos += 1
-            pos += 1
-            continue
-
-        # Handle brackets
-        if char in brackets:
-            open_brackets.append(brackets[char])
-        elif char in brackets.values():
-            if not open_brackets:
-                raise ValueError(
-                    f"Extra closing bracket '{char}' at position {pos}"
-                )
-            if open_brackets[-1] != char:
-                raise ValueError(
-                    f"Mismatched bracket '{char}' at position {pos}"
-                )
-            open_brackets.pop()
-
-        pos += 1
-
-    # Add missing closing brackets
-    closing_brackets = "".join(reversed(open_brackets))
-    return str_to_parse + closing_brackets
-
-
-def _check_valid_str(str_to_parse, /):
-    if not isinstance(str_to_parse, str):
-        raise TypeError("Input must be a string")
-
-    if not str_to_parse.strip():
-        raise ValueError("Input string is empty")
-
-
-def _fix_braces(str_to_parse):
-    fixed = fix_json_string(str_to_parse)
-    str_ = fixed.strip()
-    if not str_.endswith("}"):
-        str_ += "}"
-    if not str_.startswith("{"):
-        str_ = "{" + str_
-    if str_.endswith(",}"):
-        str_ = str_[:-2] + "}"
-    return str_
-
-
-def _assemble(str_to_parse):
-    fixed = fix_json_string(str_to_parse)
-    if fixed.startswith("{"):
-        fixed = fixed[1:]
-    if fixed.endswith("}"):
-        fixed = fixed[:-1]
-    parts = []
-    for i in fixed.split(":"):
-        str_ = i.strip().replace("'", '"')
-        if str_.count('"') == 2 and ' "' in str_:
-            parts.append(str_.split(' "')[0])
-            parts.append('"' + str_.split(' "')[1])
-
-        elif str_.count('"') == 4 and ' "' in str_:
-            parts.append(str_.split(' "')[0])
-            parts.append('"' + str_.split(' "')[1])
-
-        else:
-            parts.append(i.strip())
-
-    assembled = ""
-    for i in range(len(parts)):
-        if i % 2 == 0:
-            assembled += parts[i] + ":"
-        else:
-            assembled += parts[i] + ","
-
-    if assembled.endswith(","):
-        assembled = assembled[:-1]
-    if not assembled.startswith("{"):
-        assembled = "{" + assembled
-    if not assembled.endswith("}"):
-        assembled += "}"
-
-    return assembled

lionagi/libs/parse/json/to_json.py

@@ -1,71 +0,0 @@
-import json
-import re
-from typing import Any
-
-from .parse import fuzzy_parse_json
-
-
-def to_json(
-    string: str | list[str], /, fuzzy_parse: bool = False
-) -> list[dict[str, Any]] | dict:
-    """Extract and parse JSON content from a string or markdown code blocks.
-
-    This function attempts to parse JSON directly from the input string first.
-    If that fails, it looks for JSON content within markdown code blocks
-    (denoted by ```json).
-
-    Args:
-        string: Input string or list of strings to parse. If a list is provided,
-               it will be joined with newlines.
-
-    Returns:
-        - A dictionary if a single JSON object is found
-        - A list of dictionaries if multiple JSON objects are found
-        - An empty list if no valid JSON is found
-
-    Examples:
-        >>> to_json('{"key": "value"}')
-        {'key': 'value'}
-
-        >>> to_json('''
-        ... ```json
-        ... {"key": "value"}
-        ... ```
-        ... ''')
-        {'key': 'value'}
-
-        >>> to_json('''
-        ... ```json
-        ... {"key1": "value1"}
-        ... ```
-        ... ```json
-        ... {"key2": "value2"}
-        ... ```
-        ... ''')
-        [{'key1': 'value1'}, {'key2': 'value2'}]
-    """
-
-    if isinstance(string, list):
-        string = "\n".join(string)
-
-    # Try direct JSON parsing first
-    try:
-        if fuzzy_parse:
-            return fuzzy_parse_json(string)
-        return json.loads(string)
-    except Exception:
-        pass
-
-    # Look for JSON in markdown code blocks
-    pattern = r"```json\s*(.*?)\s*```"
-    matches = re.findall(pattern, string, re.DOTALL)
-
-    if not matches:
-        return []
-
-    if len(matches) == 1:
-        return json.loads(matches[0])
-
-    if fuzzy_parse:
-        return [fuzzy_parse_json(match) for match in matches]
-    return [json.loads(match) for match in matches]

lionagi/libs/parse/nested/__init__.py

@@ -1,33 +0,0 @@
-"""Nested data structure manipulation utilities."""
-
-from .nfilter import nfilter
-from .nget import nget
-from .ninsert import ninsert
-from .nmerge import nmerge
-from .npop import npop
-from .nset import nset
-from .to_flat_list import to_flat_list
-from .utils import (
-    deep_update,
-    ensure_list_index,
-    get_target_container,
-    is_homogeneous,
-    is_same_dtype,
-    is_structure_homogeneous,
-)
-
-__all__ = [
-    "nfilter",
-    "nget",
-    "ninsert",
-    "nmerge",
-    "npop",
-    "nset",
-    "to_flat_list",
-    "deep_update",
-    "ensure_list_index",
-    "get_target_container",
-    "is_homogeneous",
-    "is_same_dtype",
-    "is_structure_homogeneous",
-]

lionagi/libs/parse/nested/to_flat_list.py

@@ -1,64 +0,0 @@
-from collections.abc import Generator, Iterable
-from typing import Any
-
-from pydantic_core import PydanticUndefinedType
-
-from lionagi.libs.constants import UndefinedType
-
-
-def _flatten_list_generator(
-    lst_: list[Any], dropna: bool
-) -> Generator[Any, None, None]:
-    for i in lst_:
-        if isinstance(i, list):
-            yield from _flatten_list_generator(i, dropna)
-        else:
-            yield i
-
-
-def to_flat_list(
-    input_: Any, /, *, dropna: bool = False, unique: bool = True
-) -> list[Any]:
-    if isinstance(input_, type(None) | UndefinedType | PydanticUndefinedType):
-        return []
-
-    if not isinstance(input_, Iterable) or isinstance(
-        input_, (str, bytes, bytearray, dict)
-    ):
-        return [input_]
-
-    if isinstance(input_, list):
-        return _flatten_list(input_, dropna, unique=unique)
-
-    if isinstance(input_, tuple):
-        return _flatten_list(list(input_), dropna, unique=unique)
-
-    if isinstance(input_, set):
-        return list(_dropna_iterator(list(input_))) if dropna else list(input_)
-
-    try:
-        iterable_list = list(input_)
-        return _flatten_list(iterable_list, dropna, unique=unique)
-
-    except Exception as e:
-        raise ValueError(
-            f"Could not convert {type(input_)} object to list: {e}"
-        ) from e
-
-
-def _dropna_iterator(lst_: list[Any]) -> iter:
-    return (item for item in lst_ if item is not None)
-
-
-def _flatten_list(
-    lst_: list[Any], dropna: bool = False, unique: bool = False
-) -> list[Any]:
-    flattened_list = list(_flatten_list_generator(lst_, dropna))
-    if dropna:
-        flattened_list = list(_dropna_iterator(flattened_list))
-    if unique:
-        try:
-            flattened_list = list(set(flattened_list))
-        except Exception:
-            pass
-    return flattened_list

lionagi/libs/parse/string_parse/__init__.py

@@ -1,11 +0,0 @@
-"""String parsing utilities for code blocks and docstrings."""
-
-from .code_block import extract_code_block
-from .docstring import extract_docstring
-from .function_ import function_to_schema
-
-__all__ = [
-    "extract_code_block",
-    "extract_docstring",
-    "function_to_schema",
-]

lionagi/libs/parse/type_convert/__init__.py

@@ -1,19 +0,0 @@
-"""Type conversion utilities for various data formats."""
-
-from .params import ToDictParams, ToListParams, ToNumParams, ToStrParams
-from .to_dict import to_dict
-from .to_list import to_list
-from .to_num import to_num
-from .to_str import strip_lower, to_str
-
-__all__ = [
-    "to_dict",
-    "to_str",
-    "strip_lower",
-    "to_list",
-    "to_num",
-    "ToDictParams",
-    "ToListParams",
-    "ToNumParams",
-    "ToStrParams",
-]

lionagi/libs/parse/type_convert/params.py

@@ -1,145 +0,0 @@
-from collections.abc import Callable
-from typing import Any, Literal, TypeVar
-
-from pydantic import BaseModel, Field, field_validator
-
-from lionagi.libs.constants import NUM_TYPES
-
-T = TypeVar("T")
-
-
-class ToDictParams(BaseModel):
-    """Parameters for to_dict conversion function."""
-
-    str_type: Literal["json", "xml"] | None = Field(
-        default="json",
-        description="Type of string to parse",
-    )
-    fuzzy_parse: bool = Field(
-        default=False,
-        description="Whether to use fuzzy parsing for JSON-like strings",
-    )
-    suppress: bool = Field(
-        default=False,
-        description="Whether to suppress errors and return empty dict",
-    )
-    parser: Callable[[str], Any] | None = Field(
-        default=None,
-        description="Custom parser function for string inputs",
-    )
-    recursive: bool = Field(
-        default=False,
-        description="Enable recursive conversion of nested structures",
-    )
-    max_recursive_depth: int | None = Field(
-        default=None,
-        description="Maximum recursion depth (default 5, max 10)",
-        ge=0,
-        le=10,
-    )
-    recursive_python_only: bool = Field(
-        default=True,
-        description="If False, attempts to convert custom types recursively",
-    )
-    use_model_dump: bool = Field(
-        default=True,
-        description="Whether to use model_dump for pydantic models",
-    )
-
-
-class ToNumParams(BaseModel):
-    """Parameters for to_num conversion function."""
-
-    upper_bound: int | float | None = Field(
-        default=None,
-        description="Maximum allowed value (inclusive)",
-    )
-    lower_bound: int | float | None = Field(
-        default=None,
-        description="Minimum allowed value (inclusive)",
-    )
-    num_type: NUM_TYPES = Field(
-        default=float,
-        description="Target numeric type (int, float, complex)",
-    )
-    precision: int | None = Field(
-        default=None,
-        description="Number of decimal places for rounding (float only)",
-        ge=0,
-    )
-    num_count: int = Field(
-        default=1,
-        description="Number of numeric values to extract",
-        gt=0,
-    )
-
-    @field_validator("upper_bound")
-    def validate_bounds(
-        cls, v: float | None, values: dict[str, Any]
-    ) -> float | None:
-        if v is not None and values.get("lower_bound") is not None:
-            if v < values["lower_bound"]:
-                raise ValueError(
-                    "upper_bound must be greater than lower_bound"
-                )
-        return v
-
-
-class ToStrParams(BaseModel):
-    """Parameters for to_str conversion function."""
-
-    strip_lower: bool = Field(
-        default=False,
-        description="Whether to strip and convert to lowercase",
-    )
-    chars: str | None = Field(
-        default=None,
-        description="Characters to strip from the result",
-    )
-    str_type: Literal["json", "xml"] | None = Field(
-        default=None,
-        description="Type of string input if applicable",
-    )
-    serialize_as: Literal["json", "xml"] | None = Field(
-        default=None,
-        description="Output serialization format",
-    )
-    use_model_dump: bool = Field(
-        default=False,
-        description="Whether to use model_dump for pydantic models",
-    )
-    str_parser: Callable[[str], Any] | None = Field(
-        default=None,
-        description="Custom parser function for string inputs",
-    )
-    parser_kwargs: dict[str, Any] = Field(
-        default_factory=dict,
-        description="Additional keyword arguments for the parser",
-    )
-
-
-class ToListParams(BaseModel):
-    """Parameters for to_list conversion function."""
-
-    flatten: bool = Field(
-        default=False,
-        description="Whether to flatten nested structures",
-    )
-    dropna: bool = Field(
-        default=False,
-        description="Whether to drop None values",
-    )
-    unique: bool = Field(
-        default=False,
-        description="Whether to return only unique values (requires flatten=True)",
-    )
-    use_values: bool = Field(
-        default=False,
-        description="Whether to use .values() for dict-like inputs",
-    )
-
-    @field_validator("unique")
-    def validate_unique(cls, v: bool, values: dict[str, Any]) -> bool:
-        if v and not values.get("flatten", False):
-            raise ValueError("unique=True requires flatten=True")
-        return v