lionagi 0.10.7__py3-none-any.whl → 0.12.0__py3-none-any.whl

lionagi/libs/parse/to_num.py

@@ -0,0 +1,378 @@
+from __future__ import annotations
+
+import re
+from decimal import Decimal
+from typing import Any, Literal, TypeVar
+
+# Type definitions
+NUM_TYPE_LITERAL = Literal["int", "float", "complex"]
+NUM_TYPES = type[int] | type[float] | type[complex] | NUM_TYPE_LITERAL
+NumericType = TypeVar("NumericType", int, float, complex)
+
+# Type mapping
+TYPE_MAP = {"int": int, "float": float, "complex": complex}
+
+# Regex patterns for different numeric formats
+PATTERNS = {
+    "scientific": r"[-+]?(?:\d*\.)?\d+[eE][-+]?\d+",
+    "complex_sci": r"[-+]?(?:\d*\.)?\d+(?:[eE][-+]?\d+)?[-+](?:\d*\.)?\d+(?:[eE][-+]?\d+)?[jJ]",
+    "complex": r"[-+]?(?:\d*\.)?\d+[-+](?:\d*\.)?\d+[jJ]",
+    "pure_imaginary": r"[-+]?(?:\d*\.)?\d*[jJ]",
+    "percentage": r"[-+]?(?:\d*\.)?\d+%",
+    "fraction": r"[-+]?\d+/\d+",
+    "decimal": r"[-+]?(?:\d*\.)?\d+",
+    "special": r"[-+]?(?:inf|infinity|nan)",
+}
+
+
+def to_num(
+    input_: Any,
+    /,
+    *,
+    upper_bound: int | float | None = None,
+    lower_bound: int | float | None = None,
+    num_type: NUM_TYPES = float,
+    precision: int | None = None,
+    num_count: int = 1,
+) -> int | float | complex | list[int | float | complex]:
+    """Convert input to numeric type(s) with validation and bounds checking.
+
+    Args:
+        input_value: The input to convert to number(s).
+        upper_bound: Maximum allowed value (inclusive).
+        lower_bound: Minimum allowed value (inclusive).
+        num_type: Target numeric type ('int', 'float', 'complex' or type objects).
+        precision: Number of decimal places for rounding (float only).
+        num_count: Number of numeric values to extract.
+
+    Returns:
+        Converted number(s). Single value if num_count=1, else list.
+
+    Raises:
+        ValueError: For invalid input or out of bounds values.
+        TypeError: For invalid input types or invalid type conversions.
+    """
+    # Validate input
+    if isinstance(input_, (list, tuple)):
+        raise TypeError("Input cannot be a sequence")
+
+    # Handle boolean input
+    if isinstance(input_, bool):
+        return validate_num_type(num_type)(input_)
+
+    # Handle direct numeric input
+    if isinstance(input_, (int, float, complex, Decimal)):
+        inferred_type = type(input_)
+        if isinstance(input_, Decimal):
+            inferred_type = float
+        value = float(input_) if not isinstance(input_, complex) else input_
+        value = apply_bounds(value, upper_bound, lower_bound)
+        value = apply_precision(value, precision)
+        return convert_type(value, validate_num_type(num_type), inferred_type)
+
+    # Convert input to string and extract numbers
+    input_str = str(input_)
+    number_matches = extract_numbers(input_str)
+
+    if not number_matches:
+        raise ValueError(f"No valid numbers found in: {input_str}")
+
+    # Process numbers
+    results = []
+    target_type = validate_num_type(num_type)
+
+    number_matches = (
+        number_matches[:num_count]
+        if num_count < len(number_matches)
+        else number_matches
+    )
+
+    for type_and_value in number_matches:
+        try:
+            # Infer appropriate type
+            inferred_type = infer_type(type_and_value)
+
+            # Parse to numeric value
+            value = parse_number(type_and_value)
+
+            # Apply bounds if not complex
+            value = apply_bounds(value, upper_bound, lower_bound)
+
+            # Apply precision
+            value = apply_precision(value, precision)
+
+            # Convert to target type if different from inferred
+            value = convert_type(value, target_type, inferred_type)
+
+            results.append(value)
+
+        except Exception as e:
+            if len(type_and_value) == 2:
+                raise type(e)(
+                    f"Error processing {type_and_value[1]}: {str(e)}"
+                )
+            raise type(e)(f"Error processing {type_and_value}: {str(e)}")
+
+    if results and num_count == 1:
+        return results[0]
+    return results
+
+
+def extract_numbers(text: str) -> list[tuple[str, str]]:
+    """Extract numeric values from text using ordered regex patterns.
+
+    Args:
+        text: The text to extract numbers from.
+
+    Returns:
+        List of tuples containing (pattern_type, matched_value).
+    """
+    combined_pattern = "|".join(PATTERNS.values())
+    matches = re.finditer(combined_pattern, text, re.IGNORECASE)
+    numbers = []
+
+    for match in matches:
+        value = match.group()
+        # Check which pattern matched
+        for pattern_name, pattern in PATTERNS.items():
+            if re.fullmatch(pattern, value, re.IGNORECASE):
+                numbers.append((pattern_name, value))
+                break
+
+    return numbers
+
+
+def validate_num_type(num_type: NUM_TYPES) -> type:
+    """Validate and normalize numeric type specification.
+
+    Args:
+        num_type: The numeric type to validate.
+
+    Returns:
+        The normalized Python type object.
+
+    Raises:
+        ValueError: If the type specification is invalid.
+    """
+    if isinstance(num_type, str):
+        if num_type not in TYPE_MAP:
+            raise ValueError(f"Invalid number type: {num_type}")
+        return TYPE_MAP[num_type]
+
+    if num_type not in (int, float, complex):
+        raise ValueError(f"Invalid number type: {num_type}")
+    return num_type
+
+
+def infer_type(value: tuple[str, str]) -> type:
+    """Infer appropriate numeric type from value.
+
+    Args:
+        value: Tuple of (pattern_type, matched_value).
+
+    Returns:
+        The inferred Python type.
+    """
+    pattern_type, _ = value
+    if pattern_type in ("complex", "complex_sci", "pure_imaginary"):
+        return complex
+    return float
+
+
+def convert_special(value: str) -> float:
+    """Convert special float values (inf, -inf, nan).
+
+    Args:
+        value: The string value to convert.
+
+    Returns:
+        The converted float value.
+    """
+    value = value.lower()
+    if "infinity" in value or "inf" in value:
+        return float("-inf") if value.startswith("-") else float("inf")
+    return float("nan")
+
+
+def convert_percentage(value: str) -> float:
+    """Convert percentage string to float.
+
+    Args:
+        value: The percentage string to convert.
+
+    Returns:
+        The converted float value.
+
+    Raises:
+        ValueError: If the percentage value is invalid.
+    """
+    try:
+        return float(value.rstrip("%")) / 100
+    except ValueError as e:
+        raise ValueError(f"Invalid percentage value: {value}") from e
+
+
+def convert_complex(value: str) -> complex:
+    """Convert complex number string to complex.
+
+    Args:
+        value: The complex number string to convert.
+
+    Returns:
+        The converted complex value.
+
+    Raises:
+        ValueError: If the complex number is invalid.
+    """
+    try:
+        # Handle pure imaginary numbers
+        if value.endswith("j") or value.endswith("J"):
+            if value in ("j", "J"):
+                return complex(0, 1)
+            if value in ("+j", "+J"):
+                return complex(0, 1)
+            if value in ("-j", "-J"):
+                return complex(0, -1)
+            if "+" not in value and "-" not in value[1:]:
+                # Pure imaginary number
+                imag = float(value[:-1] or "1")
+                return complex(0, imag)
+
+        return complex(value.replace(" ", ""))
+    except ValueError as e:
+        raise ValueError(f"Invalid complex number: {value}") from e
+
+
+def convert_type(
+    value: float | complex,
+    target_type: type,
+    inferred_type: type,
+) -> int | float | complex:
+    """Convert value to target type if specified, otherwise use inferred type.
+
+    Args:
+        value: The value to convert.
+        target_type: The requested target type.
+        inferred_type: The inferred type from the value.
+
+    Returns:
+        The converted value.
+
+    Raises:
+        TypeError: If the conversion is not possible.
+    """
+    try:
+        # If no specific type requested, use inferred type
+        if target_type is float and inferred_type is complex:
+            return value
+
+        # Handle explicit type conversions
+        if target_type is int and isinstance(value, complex):
+            raise TypeError("Cannot convert complex number to int")
+        return target_type(value)
+    except (ValueError, TypeError) as e:
+        raise TypeError(
+            f"Cannot convert {value} to {target_type.__name__}"
+        ) from e
+
+
+def apply_bounds(
+    value: float | complex,
+    upper_bound: float | None = None,
+    lower_bound: float | None = None,
+) -> float | complex:
+    """Apply bounds checking to numeric value.
+
+    Args:
+        value: The value to check.
+        upper_bound: Maximum allowed value (inclusive).
+        lower_bound: Minimum allowed value (inclusive).
+
+    Returns:
+        The validated value.
+
+    Raises:
+        ValueError: If the value is outside bounds.
+    """
+    if isinstance(value, complex):
+        return value
+
+    if upper_bound is not None and value > upper_bound:
+        raise ValueError(f"Value {value} exceeds upper bound {upper_bound}")
+    if lower_bound is not None and value < lower_bound:
+        raise ValueError(f"Value {value} below lower bound {lower_bound}")
+    return value
+
+
+def apply_precision(
+    value: float | complex,
+    precision: int | None,
+) -> float | complex:
+    """Apply precision rounding to numeric value.
+
+    Args:
+        value: The value to round.
+        precision: Number of decimal places.
+
+    Returns:
+        The rounded value.
+    """
+    if precision is None or isinstance(value, complex):
+        return value
+    if isinstance(value, float):
+        return round(value, precision)
+    return value
+
+
+def parse_number(type_and_value: tuple[str, str]) -> float | complex:
+    """Parse string to numeric value based on pattern type.
+
+    Args:
+        type_and_value: Tuple of (pattern_type, matched_value).
+
+    Returns:
+        The parsed numeric value.
+
+    Raises:
+        ValueError: If parsing fails.
+    """
+    num_type, value = type_and_value
+    value = value.strip()
+
+    try:
+        if num_type == "special":
+            return convert_special(value)
+
+        if num_type == "percentage":
+            return convert_percentage(value)
+
+        if num_type == "fraction":
+            if "/" not in value:
+                raise ValueError(f"Invalid fraction: {value}")
+            if value.count("/") > 1:
+                raise ValueError(f"Invalid fraction: {value}")
+            num, denom = value.split("/")
+            if not (num.strip("-").isdigit() and denom.isdigit()):
+                raise ValueError(f"Invalid fraction: {value}")
+            denom_val = float(denom)
+            if denom_val == 0:
+                raise ValueError("Division by zero")
+            return float(num) / denom_val
+        if num_type in ("complex", "complex_sci", "pure_imaginary"):
+            return convert_complex(value)
+        if num_type == "scientific":
+            if "e" not in value.lower():
+                raise ValueError(f"Invalid scientific notation: {value}")
+            parts = value.lower().split("e")
+            if len(parts) != 2:
+                raise ValueError(f"Invalid scientific notation: {value}")
+            if not (parts[1].lstrip("+-").isdigit()):
+                raise ValueError(f"Invalid scientific notation: {value}")
+            return float(value)
+        if num_type == "decimal":
+            return float(value)
+
+        raise ValueError(f"Unknown number type: {num_type}")
+    except Exception as e:
+        # Preserve the specific error type but wrap with more context
+        raise type(e)(f"Failed to parse {value} as {num_type}: {str(e)}")

lionagi/libs/parse/to_xml.py

@@ -0,0 +1,57 @@
+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}>"

lionagi/libs/parse/xml_parser.py

@@ -0,0 +1,148 @@
+from __future__ import annotations
+
+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_
+
+
+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:
+    import xml.etree.ElementTree as ET
+
+    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/libs/schema/breakdown_pydantic_annotation.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from inspect import isclass
+from typing import Any, get_args, get_origin
+
+from pydantic import BaseModel
+
+
+def breakdown_pydantic_annotation(
+    model: type[BaseModel],
+    max_depth: int | None = None,
+    current_depth: int = 0,
+) -> dict[str, Any]:
+
+    if not _is_pydantic_model(model):
+        raise TypeError("Input must be a Pydantic model")
+
+    if max_depth is not None and current_depth >= max_depth:
+        raise RecursionError("Maximum recursion depth reached")
+
+    out: dict[str, Any] = {}
+    for k, v in model.__annotations__.items():
+        origin = get_origin(v)
+        if _is_pydantic_model(v):
+            out[k] = breakdown_pydantic_annotation(
+                v, max_depth, current_depth + 1
+            )
+        elif origin is list:
+            args = get_args(v)
+            if args and _is_pydantic_model(args[0]):
+                out[k] = [
+                    breakdown_pydantic_annotation(
+                        args[0], max_depth, current_depth + 1
+                    )
+                ]
+            else:
+                out[k] = [args[0] if args else Any]
+        else:
+            out[k] = v
+
+    return out
+
+
+def _is_pydantic_model(x: Any) -> bool:
+    try:
+        return isclass(x) and issubclass(x, BaseModel)
+    except TypeError:
+        return False

lionagi/protocols/generic/log.py

@@ -11,7 +11,8 @@ from typing import Any
 
 from pydantic import BaseModel, Field, PrivateAttr, field_validator
 
-from lionagi.utils import create_path, to_dict
+from lionagi.libs.file.create_path import create_path
+from lionagi.utils import to_dict
 
 from .._concepts import Manager
 from .element import Element