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

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")

lionagi/models/note.py

@@ -1,387 +0,0 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from collections.abc import ItemsView, Iterator, ValuesView
-from typing import Any, TypeAlias
-
-from pydantic import BaseModel, ConfigDict, Field, field_serializer
-from typing_extensions import override
-
-from lionagi.libs.nested.flatten import flatten
-from lionagi.utils import UNDEFINED, copy, to_list
-
-IndiceType: TypeAlias = str | list[str | int]
-
-
-class Note(BaseModel):
-    """Container for managing nested dictionary data structures.
-
-    A flexible container that provides deep nested data access, dictionary-like
-    interface, flattening capabilities, and update operations for managing
-    complex nested data structures.
-
-    Args:
-        **kwargs: Key-value pairs for initial content.
-
-    Attributes:
-        content: Nested dictionary structure.
-        model_config: Configuration allowing arbitrary types.
-
-    Examples:
-        >>> note = Note(
-        ...     user={
-        ...         "name": "John",
-        ...         "settings": {
-        ...             "theme": "dark"
-        ...         }
-        ...     }
-        ... )
-        >>>
-        >>> # Access nested data
-        >>> name = note.get(["user", "name"])
-        >>> theme = note["user"]["settings"]["theme"]
-        >>>
-        >>> # Update nested structure
-        >>> note.update(["user", "settings"], {"language": "en"})
-    """
-
-    content: dict[str, Any] = Field(
-        default_factory=dict
-    )  # Nested data structure
-
-    model_config = ConfigDict(
-        arbitrary_types_allowed=True,
-        use_enum_values=True,
-        populate_by_name=True,
-    )
-
-    def __init__(self, **kwargs: Any) -> None:
-        """Initialize Note with dictionary data.
-
-        Args:
-            **kwargs: Key-value pairs that will form the initial nested
-                dictionary structure.
-        """
-        super().__init__()
-        self.content = kwargs
-
-    @field_serializer("content")
-    def _serialize_content(self, value: Any) -> dict[str, Any]:
-        """Serialize content to dictionary format.
-
-        Args:
-            value: Content to serialize
-
-        Returns:
-            Deep copy of content dictionary
-        """
-        output_dict = copy(value, deep=True)
-        return output_dict
-
-    def to_dict(self) -> dict[str, Any]:
-        """Convert Note to dictionary, excluding undefined values.
-
-        Returns:
-            Dictionary representation with UNDEFINED values removed
-        """
-        out = copy(self.content)
-        for k, v in self.content.items():
-            if v is UNDEFINED:
-                out.pop(k)
-        return out
-
-    def pop(
-        self,
-        indices: IndiceType,
-        /,
-        default: Any = UNDEFINED,
-    ) -> Any:
-        """Remove and return item from nested structure.
-
-        Removes and returns the value at the specified path in the nested
-        structure. If the path doesn't exist and no default is provided,
-        raises KeyError.
-
-        Args:
-            indices: Path to the item to remove, can be a string for top-level
-                keys or a list for nested access.
-            default: Value to return if the path is not found. If not provided
-                and path is not found, raises KeyError.
-
-        Returns:
-            The value that was removed, or the default value if provided and
-            path not found.
-
-        Raises:
-            KeyError: If the path is not found and no default value is provided.
-        """
-        from lionagi.libs.nested.npop import npop
-
-        indices = to_list(indices, flatten=True, dropna=True)
-        return npop(self.content, indices, default)
-
-    def insert(self, indices: IndiceType, value: Any, /) -> None:
-        """Insert value into nested structure at specified indices.
-
-        Args:
-            indices: Path where to insert
-            value: Value to insert
-        """
-        from lionagi.libs.nested.ninsert import ninsert
-
-        indices = to_list(indices, flatten=True, dropna=True)
-        ninsert(self.content, indices, value)
-
-    def set(self, indices: IndiceType, value: Any, /) -> None:
-        """Set value in nested structure at specified indices.
-
-        Args:
-            indices: Path where to set
-            value: Value to set
-        """
-        indices = to_list(indices, flatten=True, dropna=True)
-        if self.get(indices, None) is None:
-            self.insert(indices, value)
-        else:
-            from lionagi.libs.nested.nset import nset
-
-            nset(self.content, indices, value)
-
-    def get(
-        self,
-        indices: IndiceType,
-        /,
-        default: Any = UNDEFINED,
-    ) -> Any:
-        """Get value from nested structure at specified indices.
-
-        Retrieves the value at the specified path in the nested structure.
-        If the path doesn't exist and no default is provided, raises KeyError.
-
-        Args:
-            indices: Path to the value, can be a string for top-level keys
-                or a list for nested access.
-            default: Value to return if the path is not found. If not provided
-                and path is not found, raises KeyError.
-
-        Returns:
-            The value at the specified path, or the default value if provided
-            and path not found.
-
-        Raises:
-            KeyError: If the path is not found and no default value is provided.
-        """
-        from lionagi.libs.nested.nget import nget
-
-        indices = to_list(indices, flatten=True, dropna=True)
-        return nget(self.content, indices, default)
-
-    def keys(self, /, flat: bool = False, **kwargs: Any) -> list:
-        """Get keys of the Note.
-
-        Args:
-            flat: If True, return flattened keys
-            kwargs: Additional flattening options
-
-        Returns:
-            List of keys, optionally flattened
-        """
-        if flat:
-            kwargs["coerce_keys"] = kwargs.get("coerce_keys", False)
-            kwargs["coerce_sequence"] = kwargs.get("coerce_sequence", "list")
-            return flatten(self.content, **kwargs).keys()
-        return list(self.content.keys())
-
-    def values(self, /, flat: bool = False, **kwargs: Any) -> ValuesView:
-        """Get values of the Note.
-
-        Returns either a view of top-level values or, if flat=True, a view
-        of all values in the flattened nested structure.
-
-        Args:
-            flat: If True, returns values from all levels of the nested
-                structure. If False, returns only top-level values.
-            kwargs: Additional options for flattening behavior when flat=True.
-                Common options include coerce_keys and coerce_sequence.
-
-        Returns:
-            A ValuesView object containing either top-level values or all
-            values from the flattened structure if flat=True.
-        """
-        if flat:
-            kwargs["coerce_keys"] = kwargs.get("coerce_keys", False)
-            kwargs["coerce_sequence"] = kwargs.get("coerce_sequence", "list")
-            return flatten(self.content, **kwargs).values()
-        return self.content.values()
-
-    def items(self, /, flat: bool = False, **kwargs: Any) -> ItemsView:
-        """Get items of the Note.
-
-        Args:
-            flat: If True, return flattened items
-            kwargs: Additional flattening options
-
-        Returns:
-            View of items, optionally flattened
-        """
-        if flat:
-            kwargs["coerce_keys"] = kwargs.get("coerce_keys", False)
-            kwargs["coerce_sequence"] = kwargs.get("coerce_sequence", "list")
-            return flatten(self.content, **kwargs).items()
-        return self.content.items()
-
-    def clear(self) -> None:
-        """Clear all content."""
-        self.content.clear()
-
-    def update(
-        self,
-        indices: IndiceType,
-        value: Any,
-    ) -> None:
-        """Update nested structure at specified indices.
-
-        Updates the value at the specified path in the nested structure.
-        The behavior depends on the existing value and the update value:
-        - If path doesn't exist: creates it with value (wrapped in list if scalar)
-        - If existing is list: extends with value if list, appends if scalar
-        - If existing is dict: updates with value if dict, raises error if not
-
-        Args:
-            indices: Path to the location to update, can be a string for
-                top-level keys or a list for nested access.
-            value: The new value to set. Must be compatible with existing
-                value type (dict for dict, any value for list).
-
-        Raises:
-            ValueError: If trying to update a dictionary with a non-dictionary
-                value.
-        """
-        existing = None
-        if not indices:
-            existing = self.content
-        else:
-            existing = self.get(indices, None)
-
-        if existing is None:
-            if not isinstance(value, (list, dict)):
-                value = [value]
-            self.set(indices, value)
-
-        if isinstance(existing, list):
-            if isinstance(value, list):
-                existing.extend(value)
-            else:
-                existing.append(value)
-
-        elif isinstance(existing, dict):
-            if isinstance(value, self.__class__):
-                value = value.content
-
-            if isinstance(value, dict):
-                existing.update(value)
-            else:
-                raise ValueError(
-                    "Cannot update a dictionary with a non-dictionary value."
-                )
-
-    @classmethod
-    def from_dict(cls, kwargs: Any) -> "Note":
-        """Create Note instance from dictionary.
-
-        Args:
-            kwargs: Dictionary to initialize with
-
-        Returns:
-            New Note instance
-        """
-        return cls(**kwargs)
-
-    def __contains__(self, indices: IndiceType) -> bool:
-        """Check if indices exist in content.
-
-        Implements the 'in' operator for checking path existence in the nested
-        structure.
-
-        Args:
-            indices: Path to check, can be a string for top-level keys or a
-                list for nested access.
-
-        Returns:
-            True if the path exists in the nested structure, False otherwise.
-        """
-        return self.content.get(indices, UNDEFINED) is not UNDEFINED
-
-    def __len__(self) -> int:
-        """Get length of content.
-
-        Implements len() function to return the number of top-level keys in
-        the nested structure.
-
-        Returns:
-            The number of top-level keys in the content dictionary.
-        """
-        return len(self.content)
-
-    def __iter__(self) -> Iterator[str]:
-        """Get iterator over content.
-
-        Returns:
-            Iterator over top-level keys
-        """
-        return iter(self.content)
-
-    def __next__(self) -> str:
-        """Get next item from content iterator.
-
-        Returns:
-            Next key in iteration
-        """
-        return next(iter(self.content))
-
-    @override
-    def __str__(self) -> str:
-        """Get string representation of content.
-
-        Implements str() function to provide a simple string representation
-        of the Note's content. Uses the standard dictionary string format.
-
-        Returns:
-            A string representation of the content dictionary, showing its
-            current state.
-        """
-        return str(self.content)
-
-    @override
-    def __repr__(self) -> str:
-        """Get detailed string representation of content.
-
-        Returns:
-            Detailed string representation of content dict
-        """
-        return repr(self.content)
-
-    def __getitem__(self, indices: IndiceType) -> Any:
-        """Get item using index notation.
-
-        Args:
-            indices: Path to value
-
-        Returns:
-            Value at path
-
-        Raises:
-            KeyError: If path not found
-        """
-        indices = to_list(indices, flatten=True, dropna=True)
-        return self.get(indices)
-
-    def __setitem__(self, indices: IndiceType, value: Any) -> None:
-        """Set item using index notation.
-
-        Args:
-            indices: Path where to set
-            value: Value to set
-        """
-        self.set(indices, value)

lionagi/protocols/graph/_utils.py

@@ -1,22 +0,0 @@
-def check_networkx_available():
-    try:
-        from networkx import DiGraph  # noqa: F401
-
-        return True
-    except Exception:
-        return ImportError(
-            "The 'networkx' package is required for this feature. "
-            "Please install `networkx` or `'lionagi[graph]'`."
-        )
-
-
-def check_matplotlib_available():
-    try:
-        import matplotlib.pyplot as plt
-
-        return True
-    except Exception:
-        return ImportError(
-            "The 'matplotlib' package is required for this feature. "
-            "Please install `matplotlib` or `'lionagi[graph]'`."
-        )