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

lionagi/libs/parse/flatten/params.py

@@ -1,52 +0,0 @@
-from typing import Any, Literal
-
-from pydantic import BaseModel, Field, field_validator
-
-
-class FlattenParams(BaseModel):
-    """Parameters for flatten function.
-
-    Attributes:
-        parent_key: Base key for the current recursion level
-        sep: Separator for joining keys
-        coerce_keys: Join keys into strings if True, keep as tuples if False
-        dynamic: Handle sequences (except strings) dynamically if True
-        coerce_sequence: Force sequences to be treated as dicts or lists
-        max_depth: Maximum depth to flatten
-    """
-
-    parent_key: tuple[Any, ...] = Field(
-        default=(),
-        description="Base key for the current recursion level",
-    )
-    sep: str = Field(
-        default="|",
-        description="Separator for joining keys",
-    )
-    coerce_keys: bool = Field(
-        default=True,
-        description="Join keys into strings if True, keep as tuples if False",
-    )
-    dynamic: bool = Field(
-        default=True,
-        description="Handle sequences (except strings) dynamically if True",
-    )
-    coerce_sequence: Literal["dict", "list"] | None = Field(
-        default=None,
-        description="Force sequences to be treated as dicts or lists",
-    )
-    max_depth: int | None = Field(
-        default=None,
-        description="Maximum depth to flatten",
-        ge=0,
-    )
-
-    @field_validator("coerce_sequence")
-    def validate_coerce_sequence(
-        cls, v: Literal["dict", "list"] | None, values: dict[str, Any]
-    ) -> Literal["dict", "list"] | None:
-        if v == "list" and values.get("coerce_keys", True):
-            raise ValueError(
-                "coerce_sequence cannot be 'list' when coerce_keys is True"
-            )
-        return v

lionagi/libs/parse/json/__init__.py

@@ -1,27 +0,0 @@
-"""JSON parsing and manipulation utilities."""
-
-from .as_readable import as_readable, as_readable_json
-from .extract import extract_block, extract_json_blocks
-from .parse import _clean_json_string, fix_json_string, fuzzy_parse_json
-from .schema import (
-    extract_json_schema,
-    json_schema_to_cfg,
-    json_schema_to_regex,
-    print_cfg,
-)
-from .to_json import to_json
-
-__all__ = [
-    "as_readable",
-    "as_readable_json",
-    "extract_block",
-    "extract_json_blocks",
-    "fuzzy_parse_json",
-    "fix_json_string",
-    "_clean_json_string",
-    "extract_json_schema",
-    "json_schema_to_cfg",
-    "json_schema_to_regex",
-    "print_cfg",
-    "to_json",
-]

lionagi/libs/parse/json/extract.py

@@ -1,102 +0,0 @@
-import re
-from collections.abc import Callable
-from typing import Any
-
-from ..type_convert.to_dict import to_dict
-
-
-def extract_json_blocks(
-    str_to_parse: str,
-    suppress: bool = True,
-    fuzzy_parse: bool = True,
-    dropna: bool = True,
-) -> list[dict[str, Any]]:
-    """
-    Extract and parse JSON blocks from the given text.
-
-    This function searches for JSON blocks enclosed in triple backticks
-    within the input text, parses them, and returns a list of parsed
-    dictionaries.
-
-    Args:
-        text: The input text containing JSON blocks.
-        suppress: If True, suppress errors during parsing. Default is True.
-        fuzzy_parse: If True, use fuzzy parsing for JSON. Default is True.
-        dropna: If True, remove None values from the result. Default is True.
-
-    Returns:
-        A list of parsed JSON blocks as dictionaries.
-
-    Example:
-        >>> text = "```json\n{\"key\": \"value\"}\n```"
-        >>> extract_json_blocks(text)
-        [{'key': 'value'}]
-    """
-    pattern = r"```json\s*(.*?)\s*```"
-    matches = re.findall(pattern, str_to_parse, re.DOTALL)
-
-    json_blocks = [
-        to_dict(match, fuzzy_parse=fuzzy_parse, suppress=suppress)
-        for match in matches
-    ]
-
-    return [block for block in json_blocks if block] if dropna else json_blocks
-
-
-def extract_block(
-    str_to_parse: str,
-    language: str = "json",
-    regex_pattern: str | None = None,
-    *,
-    parser: Callable[[str], Any] | None = None,
-    suppress: bool = False,
-) -> dict[str, Any] | None:
-    """
-    Extract and parse a code block from the given string.
-
-    This function searches for a code block in the input string using a
-    regular expression pattern, extracts it, and parses it using the
-    provided parser function.
-
-    Args:
-        str_to_parse: The input string containing the code block.
-        language: The language of the code block. Default is "json".
-        regex_pattern: Custom regex pattern to find the code block.
-            If provided, overrides the default pattern.
-        parser: A function to parse the extracted code string.
-            If not provided, uses `to_dict` with fuzzy parsing.
-        suppress: If True, return None instead of raising an error
-            when no code block is found. Default is False.
-
-    Returns:
-        The parsed content of the code block as a dictionary,
-        or None if no block is found and suppress is True.
-
-    Raises:
-        ValueError: If no code block is found and suppress is False.
-
-    Example:
-        >>> text = "```json\n{\"key\": \"value\"}\n```"
-        >>> extract_block(text)
-        {'key': 'value'}
-    """
-    if not regex_pattern:
-        regex_pattern = rf"```{language}\n?(.*?)\n?```"
-    if not language:
-        regex_pattern = r"```\n?(.*?)\n?```"
-
-    match = re.search(regex_pattern, str_to_parse, re.DOTALL)
-
-    if match:
-        code_str = match.group(1).strip()
-    elif str_to_parse.startswith(f"```{language}\n") and str_to_parse.endswith(
-        "\n```"
-    ):
-        code_str = str_to_parse[4 + len(language) : -4].strip()
-    elif suppress:
-        return None
-    else:
-        raise ValueError("No code block found in the input string.")
-
-    parser = parser or (lambda x: to_dict(x, fuzzy_parse=True, suppress=True))
-    return parser(code_str)

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",
-]