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

lionagi/session/branch.py

@@ -50,7 +50,7 @@ from lionagi.settings import Settings
 from lionagi.tools.base import LionTool
 from lionagi.utils import UNDEFINED
 from lionagi.utils import alcall as alcall_legacy
-from lionagi.utils import copy, is_coro_func
+from lionagi.utils import copy
 
 from .prompts import LION_SYSTEM_MESSAGE
 
@@ -1307,68 +1307,6 @@ class Branch(Element, Communicatable, Relational):
             )
         return results
 
-    async def translate(
-        self,
-        text: str,
-        technique: Literal["SynthLang"] = "SynthLang",
-        technique_kwargs: dict = None,
-        compress: bool = False,
-        chat_model: iModel = None,
-        compress_model: iModel = None,
-        compression_ratio: float = 0.2,
-        compress_kwargs=None,
-        verbose: bool = True,
-        new_branch: bool = True,
-        **kwargs,
-    ) -> str:
-        """
-        An example "translate" operation that transforms text using a chosen technique
-        (e.g., "SynthLang"). Optionally compresses text with a custom `compress_model`.
-
-        Args:
-            text (str):
-                The text to be translated or transformed.
-            technique (Literal["SynthLang"]):
-                The translation/transform technique (currently only "SynthLang").
-            technique_kwargs (dict, optional):
-                Additional parameters for the chosen technique.
-            compress (bool):
-                Whether to compress the resulting text further.
-            chat_model (iModel, optional):
-                A custom model for the translation step (defaults to self.chat_model).
-            compress_model (iModel, optional):
-                A separate model for compression (if `compress=True`).
-            compression_ratio (float):
-                Desired compression ratio if compressing text (0.0 - 1.0).
-            compress_kwargs (dict, optional):
-                Additional arguments for the compression step.
-            verbose (bool):
-                If True, prints debug/logging info.
-            new_branch (bool):
-                If True, performs the translation in a new branch context.
-            **kwargs:
-                Additional parameters passed through to the technique function.
-
-        Returns:
-            str: The transformed (and optionally compressed) text.
-        """
-        from lionagi.operations.translate.translate import translate
-
-        return await translate(
-            branch=self,
-            text=text,
-            technique=technique,
-            technique_kwargs=technique_kwargs,
-            compress=compress,
-            chat_model=chat_model,
-            compress_model=compress_model,
-            compression_ratio=compression_ratio,
-            compress_kwargs=compress_kwargs,
-            verbose=verbose,
-            new_branch=new_branch,
-            **kwargs,
-        )
-
     async def select(
         self,
         instruct: Instruct | dict[str, Any],
@@ -1411,44 +1349,6 @@ class Branch(Element, Communicatable, Relational):
             **kwargs,
         )
 
-    async def compress(
-        self,
-        text: str,
-        system: str = None,
-        compression_ratio: float = 0.2,
-        n_samples: int = 5,
-        max_tokens_per_sample=80,
-        verbose=True,
-    ) -> str:
-        """
-        Uses the `chat_model`'s built-in compression routine to shorten text.
-
-        Args:
-            text (str):
-                The text to compress.
-            system (str, optional):
-                System-level instructions, appended to the prompt.
-            compression_ratio (float):
-                Desired compression ratio (0.0-1.0).
-            n_samples (int):
-                How many compression attempts to combine or evaluate.
-            max_tokens_per_sample (int):
-                Max token count per sample chunk.
-            verbose (bool):
-                If True, logs or prints progress.
-
-        Returns:
-            str: The compressed text.
-        """
-        return await self.chat_model.compress_text(
-            text=text,
-            system=system,
-            compression_ratio=compression_ratio,
-            n_samples=n_samples,
-            max_tokens_per_sample=max_tokens_per_sample,
-            verbose=verbose,
-        )
-
     async def interpret(
         self,
         text: str,

lionagi/session/session.py

@@ -79,7 +79,7 @@ class Session(Node, Communicatable, Relational):
 
     def include_branches(self, branches: ID[Branch].ItemSeq):
         def _take_in_branch(branch: Branch):
-            if not branch in self.branches:
+            if branch not in self.branches:
                 self.branches.include(branch)
                 self.mail_manager.add_sources(branch)
 
@@ -171,19 +171,14 @@ class Session(Node, Communicatable, Relational):
         as_default_branch: bool = False,
         **kwargs,
     ) -> Branch:
-        kwargs["system"] = system
-        kwargs["system_sender"] = system_sender
-        kwargs["system_datetime"] = system_datetime
-        kwargs["user"] = user
-        kwargs["name"] = name
-        kwargs["imodel"] = imodel
-        kwargs["messages"] = messages
-        kwargs["progress"] = progress
-        kwargs["tool_manager"] = tool_manager
-        kwargs["tools"] = tools
-        kwargs = {k: v for k, v in kwargs.items() if v is not None}
-
-        branch = Branch(**kwargs)  # type: ignore
+        """Create and include a new branch in the session."""
+        params = {
+            k: v
+            for k, v in locals().items()
+            if k not in ("self", "as_default_branch", "kwargs")
+            and v is not None
+        }
+        branch = Branch(**params, **kwargs)  # type: ignore
         self.include_branches(branch)
         if as_default_branch:
             self.default_branch = branch

lionagi/utils.py

@@ -2,23 +2,12 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-import contextlib
 import copy as _copy
-import dataclasses
-import json
 import logging
 import types
 import uuid
-from collections.abc import (
-    AsyncGenerator,
-    Callable,
-    Iterable,
-    Mapping,
-    Sequence,
-)
+from collections.abc import AsyncGenerator, Callable, Iterable, Mapping
 from datetime import datetime, timezone
-from enum import Enum as _Enum
-from functools import partial
 from inspect import isclass
 from pathlib import Path
 from typing import (
@@ -32,10 +21,8 @@ from typing import (
 )
 
 from pydantic import BaseModel
-from pydantic_core import PydanticUndefinedType
 from typing_extensions import deprecated
 
-from .libs.validate.xml_parser import xml_to_dict
 from .ln import (
     extract_json,
     fuzzy_json,
@@ -44,6 +31,7 @@ from .ln import (
     import_module,
     is_coro_func,
     is_import_installed,
+    to_dict,
     to_list,
 )
 from .ln.types import (
@@ -114,6 +102,7 @@ __all__ = (
     "MaybeUnset",
     "is_import_installed",
     "import_module",
+    "to_dict",
 )
 
 
@@ -532,326 +521,6 @@ def create_path(
     return full_path
 
 
-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:
-            input_ = 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_)
-
-    with contextlib.suppress(Exception):
-        return dataclasses.asdict(input_)
-
-    return dict(input_)
-
-
 def get_bins(input_: list[str], upper: int) -> list[list[int]]:
     """Organizes indices of strings into bins based on a cumulative upper limit.
 

lionagi/version.py

@@ -1 +1 @@
-__version__ = "0.16.1"
+__version__ = "0.16.3"

{lionagi-0.16.1.dist-info → lionagi-0.16.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lionagi
-Version: 0.16.1
+Version: 0.16.3
 Summary: An Intelligence Operating System.
 Author-email: HaiyangLi <quantocean.li@gmail.com>
 License:            Apache License
@@ -226,17 +226,13 @@ Requires-Dist: backoff>=2.0.0
 Requires-Dist: jinja2>=3.0.0
 Requires-Dist: json-repair>=0.40.0
 Requires-Dist: msgspec>=0.18.0
-Requires-Dist: pillow>=10.0.0
-Requires-Dist: psutil>=6.0.0
 Requires-Dist: pydantic-settings>=2.8.0
 Requires-Dist: pydantic>=2.8.0
 Requires-Dist: pydapter[pandas]>=1.1.1
 Requires-Dist: python-dotenv>=1.1.0
 Requires-Dist: tiktoken>=0.9.0
-Requires-Dist: toml>=0.8.0
 Provides-Extra: all
 Requires-Dist: aiosqlite>=0.21.0; extra == 'all'
-Requires-Dist: claude-code-sdk>=0.0.15; extra == 'all'
 Requires-Dist: datamodel-code-generator>=0.31.2; extra == 'all'
 Requires-Dist: docling>=2.15.0; extra == 'all'
 Requires-Dist: fastmcp>=2.10.5; extra == 'all'
@@ -245,8 +241,6 @@ Requires-Dist: networkx>=3.0.0; extra == 'all'
 Requires-Dist: ollama>=0.4.0; extra == 'all'
 Requires-Dist: pydapter[postgres]; extra == 'all'
 Requires-Dist: rich>=13.0.0; extra == 'all'
-Provides-Extra: claude-code
-Requires-Dist: claude-code-sdk>=0.0.15; extra == 'claude-code'
 Provides-Extra: graph
 Requires-Dist: matplotlib>=3.7.0; extra == 'graph'
 Requires-Dist: networkx>=3.0.0; extra == 'graph'
@@ -264,10 +258,6 @@ Provides-Extra: schema
 Requires-Dist: datamodel-code-generator>=0.31.2; extra == 'schema'
 Provides-Extra: sqlite
 Requires-Dist: aiosqlite>=0.21.0; extra == 'sqlite'
-Provides-Extra: tools
-Requires-Dist: docling>=2.15.0; extra == 'tools'
-Provides-Extra: unstructured
-Requires-Dist: opencv-python>=4.2.0.34; extra == 'unstructured'
 Provides-Extra: xml
 Requires-Dist: xmltodict>=0.12.0; extra == 'xml'
 Description-Content-Type: text/markdown
@@ -275,6 +265,7 @@ Description-Content-Type: text/markdown
 ![PyPI - Version](https://img.shields.io/pypi/v/lionagi?labelColor=233476aa&color=231fc935)
 ![PyPI - Downloads](https://img.shields.io/pypi/dm/lionagi?color=blue)
 ![Python Version](https://img.shields.io/badge/python-3.10%2B-blue)
+[![codecov](https://codecov.io/github/khive-ai/lionagi/graph/badge.svg?token=FAE47FY26T)](https://codecov.io/github/khive-ai/lionagi)
 
 [Documentation](https://khive-ai.github.io/lionagi/) |
 [Discord](https://discord.gg/JDj9ENhUE8) |
@@ -417,7 +408,7 @@ Seamlessly route to different models in the same workflow.
 
 ### Claude Code Integration
 
-LionAGI now supports Anthropic's Claude Code [Python SDK](https://github.com/anthropics/claude-code-sdk-python), and [CLI SDK](https://docs.anthropic.com/en/docs/claude-code/sdk) enabling autonomous coding capabilities with persistent session management. The CLI endpoint
+LionAGI now supports Anthropic's Claude Code [CLI SDK](https://docs.anthropic.com/en/docs/claude-code/sdk) enabling autonomous coding capabilities with persistent session management. The CLI endpoint
 directly connects to claude code, and is recommended, you can either use it via a [proxy server](https://github.com/khive-ai/lionagi/tree/main/cookbooks/claude_proxy) or directly with `query_cli` endpoint, provided you have already logged onto claude code cli in your terminal.
 
 ```python
@@ -485,7 +476,6 @@ Key features:
 ```
 "lionagi[reader]" - Reader tool for any unstructured data and web pages
 "lionagi[ollama]" - Ollama model support for local inference
-"lionagi[claude-code]" - Claude code python SDK integration (cli endpoint does not require this)
 "lionagi[rich]" - Rich output formatting for better console display
 "lionagi[schema]" - Convert pydantic schema to make the Model class persistent
 "lionagi[postgres]" - Postgres database support for storing and retrieving structured data