lionagi 0.16.2__py3-none-any.whl → 0.16.3__py3-none-any.whl

lionagi/libs/unstructured/pdf_to_image.py

@@ -1,45 +0,0 @@
-from lionagi.utils import import_module, is_import_installed
-
-_HAS_PDF2IMAGE = is_import_installed("pdf2image")
-
-
-def pdf_to_images(
-    pdf_path: str, output_folder: str, dpi: int = 300, fmt: str = "jpeg"
-) -> list:
-    """
-    Convert a PDF file into images, one image per page.
-
-    Args:
-        pdf_path (str): Path to the input PDF file.
-        output_folder (str): Directory to save the output images.
-        dpi (int): Dots per inch (resolution) for conversion (default: 300).
-        fmt (str): Image format (default: 'jpeg'). Use 'png' if preferred.
-
-    Returns:
-        list: A list of file paths for the saved images.
-    """
-    if not _HAS_PDF2IMAGE:
-        raise ModuleNotFoundError(
-            "pdf2image is not installed, please install it with `pip install lionagi[unstructured]`"
-        )
-
-    import os
-
-    convert_from_path = import_module(
-        "pdf2image", import_name="convert_from_path"
-    )
-
-    # Ensure the output folder exists
-    os.makedirs(output_folder, exist_ok=True)
-
-    # Convert PDF to a list of PIL Image objects
-    images = convert_from_path(pdf_path, dpi=dpi)
-
-    saved_paths = []
-    for i, image in enumerate(images):
-        # Construct the output file name
-        image_file = os.path.join(output_folder, f"page_{i + 1}.{fmt}")
-        image.save(image_file, fmt.upper())
-        saved_paths.append(image_file)
-
-    return saved_paths

lionagi/libs/unstructured/read_image_to_base64.py

@@ -1,33 +0,0 @@
-from pathlib import Path
-
-from lionagi.utils import is_import_installed
-
-_HAS_OPENCV = is_import_installed("cv2")
-
-
-__all__ = ("read_image_to_base64",)
-
-
-def read_image_to_base64(image_path: str | Path) -> str:
-    if not _HAS_OPENCV:
-        raise ModuleNotFoundError(
-            "OpenCV is not installed, please install it with `pip install lionagi[unstructured]`"
-        )
-
-    import base64
-
-    import cv2
-
-    image_path = str(image_path)
-    image = cv2.imread(image_path, cv2.COLOR_BGR2RGB)
-
-    if image is None:
-        raise ValueError(f"Could not read image from path: {image_path}")
-
-    file_extension = "." + image_path.split(".")[-1]
-
-    success, buffer = cv2.imencode(file_extension, image)
-    if not success:
-        raise ValueError(f"Could not encode image to {file_extension} format.")
-    encoded_image = base64.b64encode(buffer).decode("utf-8")
-    return encoded_image

lionagi/libs/validate/fuzzy_match_keys.py

@@ -1,7 +0,0 @@
-from lionagi.ln.fuzzy._fuzzy_match import (
-    FuzzyMatchKeysParams,
-    HandleUnmatched,
-    fuzzy_match_keys,
-)
-
-__all__ = ("fuzzy_match_keys", "FuzzyMatchKeysParams", "HandleUnmatched")

lionagi/libs/validate/fuzzy_validate_mapping.py

@@ -1,144 +0,0 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from collections.abc import Callable, Sequence
-from typing import Any, Literal
-
-from lionagi.utils import KeysDict, Params, to_dict, to_json
-
-from .fuzzy_match_keys import fuzzy_match_keys
-from .string_similarity import SIMILARITY_TYPE
-
-
-class FuzzyValidateMappingParams(Params):
-    similarity_algo: SIMILARITY_TYPE | Callable[[str, str], float] = (
-        "jaro_winkler"
-    )
-    similarity_threshold: float = 0.85
-    fuzzy_match: bool = True
-    handle_unmatched: Literal["ignore", "raise", "remove", "fill", "force"] = (
-        "ignore"
-    )
-    fill_value: Any = None
-    fill_mapping: dict[str, Any] | None = None
-    strict: bool = False
-    suppress_conversion_errors: bool = False
-
-    def __call__(
-        self, d_: dict[str, Any], keys: Sequence[str] | KeysDict
-    ) -> dict[str, Any]:
-        return fuzzy_validate_mapping(
-            d_,
-            keys,
-            similarity_algo=self.similarity_algo,
-            similarity_threshold=self.similarity_threshold,
-            fuzzy_match=self.fuzzy_match,
-            handle_unmatched=self.handle_unmatched,
-            fill_value=self.fill_value,
-            fill_mapping=self.fill_mapping,
-            strict=self.strict,
-            suppress_conversion_errors=self.suppress_conversion_errors,
-        )
-
-
-def fuzzy_validate_mapping(
-    d: Any,
-    keys: Sequence[str] | KeysDict,
-    /,
-    *,
-    similarity_algo: (
-        SIMILARITY_TYPE | Callable[[str, str], float]
-    ) = "jaro_winkler",
-    similarity_threshold: float = 0.85,
-    fuzzy_match: bool = True,
-    handle_unmatched: Literal[
-        "ignore", "raise", "remove", "fill", "force"
-    ] = "ignore",
-    fill_value: Any = None,
-    fill_mapping: dict[str, Any] | None = None,
-    strict: bool = False,
-    suppress_conversion_errors: bool = False,
-) -> dict[str, Any]:
-    """
-    Validate and correct any input into a dictionary with expected keys.
-
-    Args:
-        d: Input to validate. Can be:
-            - Dictionary
-            - JSON string or markdown code block
-            - XML string
-            - Object with to_dict/model_dump method
-            - Any type convertible to dictionary
-        keys: List of expected keys or dictionary mapping keys to types.
-        similarity_algo: String similarity algorithm or custom function.
-        similarity_threshold: Minimum similarity score for fuzzy matching.
-        fuzzy_match: If True, use fuzzy matching for key correction.
-        handle_unmatched: How to handle unmatched keys:
-            - "ignore": Keep unmatched keys
-            - "raise": Raise error for unmatched keys
-            - "remove": Remove unmatched keys
-            - "fill": Fill missing keys with default values
-            - "force": Combine "fill" and "remove" behaviors
-        fill_value: Default value for filling unmatched keys.
-        fill_mapping: Dictionary mapping keys to default values.
-        strict: Raise error if any expected key is missing.
-        suppress_conversion_errors: Return empty dict on conversion errors.
-
-    Returns:
-        Validated and corrected dictionary.
-
-    Raises:
-        ValueError: If input cannot be converted or validation fails.
-        TypeError: If input types are invalid.
-    """
-    if d is None:
-        raise TypeError("Input cannot be None")
-
-    # Try converting to dictionary
-    try:
-        if isinstance(d, str):
-            # First try to_json for JSON strings and code blocks
-            try:
-                json_result = to_json(d)
-                dict_input = (
-                    json_result[0]
-                    if isinstance(json_result, list)
-                    else json_result
-                )
-            except Exception:
-                # Fall back to to_dict for other string formats
-                dict_input = to_dict(
-                    d, str_type="json", fuzzy_parse=True, suppress=True
-                )
-        else:
-            dict_input = to_dict(
-                d, use_model_dump=True, fuzzy_parse=True, suppress=True
-            )
-
-        if not isinstance(dict_input, dict):
-            if suppress_conversion_errors:
-                dict_input = {}
-            else:
-                raise ValueError(
-                    f"Failed to convert input to dictionary: {type(dict_input)}"
-                )
-
-    except Exception as e:
-        if suppress_conversion_errors:
-            dict_input = {}
-        else:
-            raise ValueError(f"Failed to convert input to dictionary: {e}")
-
-    # Validate the dictionary
-    return fuzzy_match_keys(
-        dict_input,
-        keys,
-        similarity_algo=similarity_algo,
-        similarity_threshold=similarity_threshold,
-        fuzzy_match=fuzzy_match,
-        handle_unmatched=handle_unmatched,
-        fill_value=fill_value,
-        fill_mapping=fill_mapping,
-        strict=strict,
-    )

lionagi/libs/validate/string_similarity.py

@@ -1,7 +0,0 @@
-from lionagi.ln.fuzzy._string_similarity import (
-    SIMILARITY_TYPE,
-    SimilarityFunc,
-    string_similarity,
-)
-
-__all__ = ("string_similarity", "SIMILARITY_TYPE", "SimilarityFunc")

lionagi/libs/validate/xml_parser.py

@@ -1,203 +0,0 @@
-from __future__ import annotations
-
-import re
-import xml.etree.ElementTree as ET
-from typing import Any
-
-
-def to_xml(
-    obj: dict | list | str | int | float | bool | None,
-    root_name: str = "root",
-) -> str:
-    """
-    Convert a dictionary into an XML formatted string.
-
-    Rules:
-    - A dictionary key becomes an XML tag.
-    - If the dictionary value is:
-      - A primitive type (str, int, float, bool, None): it becomes the text content of the tag.
-      - A list: each element of the list will repeat the same tag.
-      - Another dictionary: it is recursively converted to nested XML.
-    - root_name sets the top-level XML element name.
-
-    Args:
-        obj: The Python object to convert (typically a dictionary).
-        root_name: The name of the root XML element.
-
-    Returns:
-        A string representing the XML.
-
-    Examples:
-        >>> to_xml({"a": 1, "b": {"c": "hello", "d": [10, 20]}}, root_name="data")
-        '<data><a>1</a><b><c>hello</c><d>10</d><d>20</d></b></data>'
-    """
-
-    def _convert(value: Any, tag_name: str) -> str:
-        # If value is a dict, recursively convert its keys
-        if isinstance(value, dict):
-            inner = "".join(_convert(v, k) for k, v in value.items())
-            return f"<{tag_name}>{inner}</{tag_name}>"
-        # If value is a list, repeat the same tag for each element
-        elif isinstance(value, list):
-            return "".join(_convert(item, tag_name) for item in value)
-        # If value is a primitive, convert to string and place inside tag
-        else:
-            text = "" if value is None else str(value)
-            # Escape special XML characters if needed (minimal)
-            text = (
-                text.replace("&", "&amp;")
-                .replace("<", "&lt;")
-                .replace(">", "&gt;")
-                .replace('"', "&quot;")
-                .replace("'", "&apos;")
-            )
-            return f"<{tag_name}>{text}</{tag_name}>"
-
-    # If top-level obj is not a dict, wrap it in one
-    if not isinstance(obj, dict):
-        obj = {root_name: obj}
-
-    inner_xml = "".join(_convert(v, k) for k, v in obj.items())
-    return f"<{root_name}>{inner_xml}</{root_name}>"
-
-
-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_
-
-
-def xml_to_dict(
-    xml_string: str,
-    /,
-    suppress=False,
-    remove_root: bool = True,
-    root_tag: str = None,
-) -> dict[str, Any]:
-    """
-    Parse an XML string into a nested dictionary structure.
-
-    This function converts an XML string into a dictionary where:
-    - Element tags become dictionary keys
-    - Text content is assigned directly to the tag key if there are no children
-    - Attributes are stored in a '@attributes' key
-    - Multiple child elements with the same tag are stored as lists
-
-    Args:
-        xml_string: The XML string to parse.
-
-    Returns:
-        A dictionary representation of the XML structure.
-
-    Raises:
-        ValueError: If the XML is malformed or parsing fails.
-    """
-    try:
-        a = XMLParser(xml_string).parse()
-        if remove_root and (root_tag or "root") in a:
-            a = a[root_tag or "root"]
-        return a
-    except ValueError as e:
-        if not suppress:
-            raise e
-
-
-def dict_to_xml(data: dict, /, root_tag: str = "root") -> str:
-    root = ET.Element(root_tag)
-
-    def convert(dict_obj: dict, parent: Any) -> None:
-        for key, val in dict_obj.items():
-            if isinstance(val, dict):
-                element = ET.SubElement(parent, key)
-                convert(dict_obj=val, parent=element)
-            else:
-                element = ET.SubElement(parent, key)
-                element.text = str(object=val)
-
-    convert(dict_obj=data, parent=root)
-    return ET.tostring(root, encoding="unicode")