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

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

lionagi/libs/parse/type_convert/to_dict.py

@@ -1,333 +0,0 @@
-import json
-from collections.abc import Callable, Iterable, Mapping, Sequence
-from enum import Enum
-from functools import partial
-from typing import Any, Literal
-
-from pydantic import BaseModel
-from pydantic_core import PydanticUndefinedType
-
-from lionagi.libs.constants import UndefinedType
-
-from ..json.parse import fuzzy_parse_json
-from ..xml.convert import xml_to_dict
-
-
-def to_dict(
-    input_: Any,
-    /,
-    *,
-    use_model_dump: bool = True,
-    fuzzy_parse: bool = False,
-    suppress: bool = False,
-    str_type: Literal["json", "xml"] | None = "json",
-    parser: Callable[[str], Any] | None = None,
-    recursive: bool = False,
-    max_recursive_depth: int = None,
-    recursive_python_only: bool = True,
-    use_enum_values: bool = False,
-    **kwargs: Any,
-) -> dict[str, Any]:
-    """
-    Convert various input types to a dictionary, with optional recursive processing.
-
-    Args:
-        input_: The input to convert.
-        use_model_dump: Use model_dump() for Pydantic models if available.
-        fuzzy_parse: Use fuzzy parsing for string inputs.
-        suppress: Return empty dict on errors if True.
-        str_type: Input string type ("json" or "xml").
-        parser: Custom parser function for string inputs.
-        recursive: Enable recursive conversion of nested structures.
-        max_recursive_depth: Maximum recursion depth (default 5, max 10).
-        recursive_python_only: If False, attempts to convert custom types recursively.
-        use_enum_values: Use enum values instead of names.
-        **kwargs: Additional arguments for parsing functions.
-
-    Returns:
-        dict[str, Any]: A dictionary derived from the input.
-
-    Raises:
-        ValueError: If parsing fails and suppress is False.
-
-    Examples:
-        >>> to_dict({"a": 1, "b": [2, 3]})
-        {'a': 1, 'b': [2, 3]}
-        >>> to_dict('{"x": 10}', str_type="json")
-        {'x': 10}
-        >>> to_dict({"a": {"b": {"c": 1}}}, recursive=True, max_recursive_depth=2)
-        {'a': {'b': {'c': 1}}}
-    """
-
-    try:
-        if recursive:
-            return recursive_to_dict(
-                input_,
-                use_model_dump=use_model_dump,
-                fuzzy_parse=fuzzy_parse,
-                str_type=str_type,
-                parser=parser,
-                max_recursive_depth=max_recursive_depth,
-                recursive_custom_types=not recursive_python_only,
-                use_enum_values=use_enum_values,
-                **kwargs,
-            )
-
-        return _to_dict(
-            input_,
-            fuzzy_parse=fuzzy_parse,
-            parser=parser,
-            str_type=str_type,
-            use_model_dump=use_model_dump,
-            use_enum_values=use_enum_values,
-            **kwargs,
-        )
-    except Exception as e:
-        if suppress or input_ == "":
-            return {}
-        raise e
-
-
-def recursive_to_dict(
-    input_: Any,
-    /,
-    *,
-    max_recursive_depth: int = None,
-    recursive_custom_types: bool = False,
-    **kwargs: Any,
-) -> Any:
-
-    if not isinstance(max_recursive_depth, int):
-        max_recursive_depth = 5
-    else:
-        if max_recursive_depth < 0:
-            raise ValueError(
-                "max_recursive_depth must be a non-negative integer"
-            )
-        if max_recursive_depth == 0:
-            return input_
-        if max_recursive_depth > 10:
-            raise ValueError(
-                "max_recursive_depth must be less than or equal to 10"
-            )
-
-    return _recur_to_dict(
-        input_,
-        max_recursive_depth=max_recursive_depth,
-        current_depth=0,
-        recursive_custom_types=recursive_custom_types,
-        **kwargs,
-    )
-
-
-def _recur_to_dict(
-    input_: Any,
-    /,
-    *,
-    max_recursive_depth: int,
-    current_depth: int = 0,
-    recursive_custom_types: bool = False,
-    **kwargs: Any,
-) -> Any:
-
-    if current_depth >= max_recursive_depth:
-        return input_
-
-    if isinstance(input_, str):
-        try:
-            # Attempt to parse the string
-            parsed = _to_dict(input_, **kwargs)
-            # Recursively process the parsed result
-            return _recur_to_dict(
-                parsed,
-                max_recursive_depth=max_recursive_depth,
-                current_depth=current_depth + 1,
-                recursive_custom_types=recursive_custom_types,
-                **kwargs,
-            )
-        except Exception:
-            # Return the original string if parsing fails
-            return input_
-
-    elif isinstance(input_, dict):
-        # Recursively process dictionary values
-        return {
-            key: _recur_to_dict(
-                value,
-                max_recursive_depth=max_recursive_depth,
-                current_depth=current_depth + 1,
-                recursive_custom_types=recursive_custom_types,
-                **kwargs,
-            )
-            for key, value in input_.items()
-        }
-
-    elif isinstance(input_, (list, tuple, set)):
-        # Recursively process list or tuple elements
-        processed = [
-            _recur_to_dict(
-                element,
-                max_recursive_depth=max_recursive_depth,
-                current_depth=current_depth + 1,
-                recursive_custom_types=recursive_custom_types,
-                **kwargs,
-            )
-            for element in input_
-        ]
-        return type(input_)(processed)
-
-    elif isinstance(input_, type) and issubclass(input_, Enum):
-        try:
-            obj_dict = _to_dict(input_, **kwargs)
-            return _recur_to_dict(
-                obj_dict,
-                max_recursive_depth=max_recursive_depth,
-                current_depth=current_depth + 1,
-                **kwargs,
-            )
-        except Exception:
-            return input_
-
-    elif recursive_custom_types:
-        # Process custom classes if enabled
-        try:
-            obj_dict = _to_dict(input_, **kwargs)
-            return _recur_to_dict(
-                obj_dict,
-                max_recursive_depth=max_recursive_depth,
-                current_depth=current_depth + 1,
-                recursive_custom_types=recursive_custom_types,
-                **kwargs,
-            )
-        except Exception:
-            return input_
-
-    else:
-        # Return the input as is for other data types
-        return input_
-
-
-def _enum_to_dict(input_, /, use_enum_values: bool = True):
-    dict_ = dict(input_.__members__).copy()
-    if use_enum_values:
-        return {key: value.value for key, value in dict_.items()}
-    return dict_
-
-
-def _str_to_dict(
-    input_: str,
-    /,
-    fuzzy_parse: bool = False,
-    str_type: Literal["json", "xml"] | None = "json",
-    parser: Callable[[str], Any] | None = None,
-    remove_root: bool = False,
-    root_tag: str = "root",
-    **kwargs: Any,
-):
-    """
-    kwargs for parser
-    """
-    if not parser:
-        if str_type == "xml" and not parser:
-            parser = partial(
-                xml_to_dict, remove_root=remove_root, root_tag=root_tag
-            )
-
-        elif fuzzy_parse:
-            parser = fuzzy_parse_json
-        else:
-            parser = json.loads
-
-    return parser(input_, **kwargs)
-
-
-def _na_to_dict(input_: type[None] | UndefinedType | PydanticUndefinedType, /):
-    return {}
-
-
-def _model_to_dict(input_: Any, /, use_model_dump=True, **kwargs):
-    """
-    kwargs: built-in serialization methods kwargs
-    accepted built-in serialization methods:
-        - mdoel_dump
-        - to_dict
-        - to_json
-        - dict
-        - json
-    """
-
-    if use_model_dump and hasattr(input_, "model_dump"):
-        return input_.model_dump(**kwargs)
-
-    methods = (
-        "to_dict",
-        "to_json",
-        "json",
-        "dict",
-    )
-    for method in methods:
-        if hasattr(input_, method):
-            result = getattr(input_, method)(**kwargs)
-            return json.loads(result) if isinstance(result, str) else result
-
-    if hasattr(input_, "__dict__"):
-        return input_.__dict__
-
-    try:
-        return dict(input_)
-    except Exception as e:
-        raise ValueError(f"Unable to convert input to dictionary: {e}")
-
-
-def _set_to_dict(input_: set, /) -> dict:
-    return {v: v for v in input_}
-
-
-def _iterable_to_dict(input_: Iterable, /) -> dict:
-    return {idx: v for idx, v in enumerate(input_)}
-
-
-def _to_dict(
-    input_: Any,
-    /,
-    *,
-    fuzzy_parse: bool = False,
-    str_type: Literal["json", "xml"] | None = "json",
-    parser: Callable[[str], Any] | None = None,
-    remove_root: bool = False,
-    root_tag: str = "root",
-    use_model_dump: bool = True,
-    use_enum_values: bool = True,
-    **kwargs: Any,
-) -> dict[str, Any]:
-
-    if isinstance(input_, set):
-        return _set_to_dict(input_)
-
-    if isinstance(input_, type) and issubclass(input_, Enum):
-        return _enum_to_dict(input_, use_enum_values=use_enum_values)
-
-    if isinstance(input_, Mapping):
-        return dict(input_)
-
-    if isinstance(input_, type(None) | UndefinedType | PydanticUndefinedType):
-        return _na_to_dict(input_)
-
-    if isinstance(input_, str):
-        return _str_to_dict(
-            input_,
-            fuzzy_parse=fuzzy_parse,
-            str_type=str_type,
-            parser=parser,
-            remove_root=remove_root,
-            root_tag=root_tag,
-            **kwargs,
-        )
-
-    if isinstance(input_, BaseModel) or not isinstance(input_, Sequence):
-        return _model_to_dict(input_, use_model_dump=use_model_dump, **kwargs)
-
-    if isinstance(input_, Iterable):
-        return _iterable_to_dict(input_)
-
-    return dict(input_)

lionagi/libs/parse/type_convert/to_list.py

@@ -1,186 +0,0 @@
-from collections.abc import Iterable, Mapping
-from enum import Enum
-from typing import Any, overload
-
-from pydantic import BaseModel
-from pydantic_core import PydanticUndefinedType
-
-from lionagi.libs.constants import UNDEFINED, UndefinedType
-
-
-@overload
-def to_list(
-    input_: None | UndefinedType | PydanticUndefinedType, /
-) -> list: ...
-
-
-@overload
-def to_list(
-    input_: str | bytes | bytearray, /, use_values: bool = False
-) -> list[str | int]: ...
-
-
-@overload
-def to_list(input_: Mapping, /, use_values: bool = False) -> list[Any]: ...
-
-
-@overload
-def to_list(
-    input_: Any,
-    /,
-    *,
-    flatten: bool = False,
-    dropna: bool = False,
-    unique: bool = False,
-) -> list: ...
-
-
-def to_list(
-    input_: Any,
-    /,
-    *,
-    flatten: bool = False,
-    dropna: bool = False,
-    unique: bool = False,
-    use_values: bool = False,
-) -> list:
-    """Convert various input types to a list.
-
-    Handles different input types and converts them to a list, with options
-    for flattening nested structures and removing None values.
-
-    Args:
-        input_: The input to be converted to a list.
-        flatten: If True, flattens nested list structures.
-        dropna: If True, removes None values from the result.
-        unique: If True, returns only unique values (requires flatten=True).
-        use_values: If True, uses .values() for dict-like inputs.
-
-    Returns:
-        A list derived from the input, processed as specified.
-
-    Raises:
-        ValueError: If unique=True and flatten=False.
-
-    Examples:
-        >>> to_list(1)
-        [1]
-        >>> to_list([1, [2, 3]], flatten=True)
-        [1, 2, 3]
-        >>> to_list([1, None, 2], dropna=True)
-        [1, 2]
-        >>> to_list({'a': 1, 'b': 2}, use_values=True)
-        [1, 2]
-    """
-    lst_ = _to_list_type(input_, use_values=use_values)
-
-    if any((flatten, dropna)):
-        lst_ = _process_list(
-            lst=lst_,
-            flatten=flatten,
-            dropna=dropna,
-        )
-
-    if unique:
-        out_ = []
-        for i in lst_:
-            if i not in out_:
-                out_.append(i)
-        return out_
-
-    return lst_
-
-
-def _undefined_to_list(
-    input_: None | UndefinedType | PydanticUndefinedType, /
-) -> list:
-    return []
-
-
-def _str_to_list(
-    input_: str | bytes | bytearray, /, use_values: bool = False
-) -> list[str | int]:
-    if use_values:
-        return list(input_)
-    return [input_]
-
-
-def _enum_to_list(
-    input_: type[Enum], /, use_values: bool = False
-) -> list[Any]:
-    if use_values:
-        return [i.value for i in input_.__members__.values()]
-    return list(input_)
-
-
-def _dict_to_list(input_: Mapping, /, use_values: bool = False) -> list[Any]:
-    if use_values:
-        return list(input_.values())
-    return [input_]
-
-
-def _to_list_type(input_: Any, /, use_values: bool = False) -> Any | None:
-
-    if isinstance(input_, BaseModel):
-        return [input_]
-
-    if use_values and hasattr(input_, "values"):
-        return list(input_.values())
-
-    if isinstance(input_, list):
-        return input_
-
-    if isinstance(input_, type(None) | UndefinedType | PydanticUndefinedType):
-        return _undefined_to_list(input_)
-
-    if isinstance(input_, type) and issubclass(input_, Enum):
-        return _enum_to_list(input_, use_values=use_values)
-
-    if isinstance(input_, str | bytes | bytearray):
-        return _str_to_list(input_, use_values=use_values)
-
-    if isinstance(input_, dict):
-        return _dict_to_list(input_, use_values=use_values)
-
-    if isinstance(input_, Iterable):
-        return list(input_)
-
-    return [input_]
-
-
-def _process_list(lst: list[Any], flatten: bool, dropna: bool) -> list[Any]:
-    """Process a list by optionally flattening and removing None values.
-
-    Args:
-        lst: The list to process.
-        flatten: If True, flattens nested list structures.
-        dropna: If True, removes None values.
-
-    Returns:
-        The processed list.
-    """
-    result = []
-    for item in lst:
-        if isinstance(item, Iterable) and not isinstance(
-            item, (str, bytes, bytearray, Mapping, BaseModel)
-        ):
-            if flatten:
-                result.extend(
-                    _process_list(
-                        lst=list(item),
-                        flatten=flatten,
-                        dropna=dropna,
-                    )
-                )
-            else:
-                result.append(
-                    _process_list(
-                        lst=list(item),
-                        flatten=flatten,
-                        dropna=dropna,
-                    )
-                )
-        elif not dropna or item not in [None, UNDEFINED]:
-            result.append(item)
-
-    return result