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

lionagi/protocols/generic/element.py

@@ -313,27 +313,16 @@ class Element(BaseModel, Observable):
         if mode == "db":
             dict_ = orjson.loads(self.to_json(decode=False))
             dict_["node_metadata"] = dict_.pop("metadata", {})
-            dict_["created_at"] = self.created_datetime.isoformat(sep=" ")
             return dict_
 
-    def as_jsonable(self) -> dict:
-        """Converts this Element to a JSON-serializable dictionary."""
-        return self.to_dict(mode="json")
-
     @classmethod
-    def from_dict(cls, data: dict, /, mode: str = "python") -> Element:
+    def from_dict(cls, data: dict) -> Element:
         """Deserializes a dictionary into an Element or subclass of Element.
 
         If `lion_class` in `metadata` refers to a subclass, this method
         is polymorphic, it will attempt to create an instance of that subclass.
-
-        Args:
-            data (dict): A dictionary of field data.
-            mode (str): Format mode - "python" for normal dicts, "db" for database format.
         """
         # Preprocess database format if needed
-        if mode == "db":
-            data = cls._preprocess_db_data(data.copy())
         metadata = {}
 
         if "node_metadata" in data:
@@ -367,72 +356,17 @@ class Element(BaseModel, Observable):
         data["metadata"] = metadata
         return cls.model_validate(data)
 
-    @classmethod
-    def _preprocess_db_data(cls, data: dict) -> dict:
-        """Preprocess raw database data for Element compatibility."""
-        import datetime as dt
-        import json
-
-        # Handle created_at field - convert datetime string to timestamp
-        if "created_at" in data and isinstance(data["created_at"], str):
-            try:
-                # Parse datetime string and convert to timestamp
-                dt_obj = dt.datetime.fromisoformat(
-                    data["created_at"].replace(" ", "T")
-                )
-                # Treat as UTC if naive
-                if dt_obj.tzinfo is None:
-                    dt_obj = dt_obj.replace(tzinfo=dt.timezone.utc)
-                data["created_at"] = dt_obj.timestamp()
-            except (ValueError, TypeError):
-                # Keep as string if parsing fails
-                pass
-
-        # Handle JSON string fields - parse to dict/list
-        json_fields = ["content", "node_metadata", "embedding"]
-        for field in json_fields:
-            if field in data and isinstance(data[field], str):
-                if data[field] in ("null", ""):
-                    data[field] = None if field == "embedding" else {}
-                else:
-                    try:
-                        data[field] = json.loads(data[field])
-                    except (json.JSONDecodeError, TypeError):
-                        # Keep as empty dict for metadata fields, None for embedding
-                        data[field] = {} if field != "embedding" else None
-
-        # Handle node_metadata -> metadata mapping
-        if "node_metadata" in data:
-            if (
-                data["node_metadata"] == "null"
-                or data["node_metadata"] is None
-            ):
-                data["metadata"] = {}
-            else:
-                data["metadata"] = (
-                    data["node_metadata"] if data["node_metadata"] else {}
-                )
-            # Remove node_metadata to avoid Pydantic validation error
-            data.pop("node_metadata", None)
-
-        return data
-
     def to_json(self, decode: bool = True) -> str:
         """Converts this Element to a JSON string."""
         dict_ = self._to_dict()
-        if decode:
-            return orjson.dumps(
-                dict_,
-                default=DEFAULT_ELEMENT_SERIALIZER,
-                option=ln.DEFAULT_SERIALIZER_OPTION,
-            ).decode()
-        return orjson.dumps(dict_, default=DEFAULT_ELEMENT_SERIALIZER)
+        return ln.json_dumps(
+            dict_, default=DEFAULT_ELEMENT_SERIALIZER, decode=decode
+        )
 
     @classmethod
-    def from_json(cls, json_str: str, mode: str = "python") -> Element:
+    def from_json(cls, json_str: str) -> Element:
         """Deserializes a JSON string into an Element or subclass of Element."""
-        data = orjson.loads(json_str)
-        return cls.from_dict(data, mode=mode)
+        return cls.from_dict(orjson.loads(json_str))
 
 
 DEFAULT_ELEMENT_SERIALIZER = ln.get_orjson_default(

lionagi/protocols/generic/log.py

@@ -176,9 +176,9 @@ class DataLogger:
         suffix = fp.suffix.lower()
         try:
             if suffix == ".csv":
-                self.logs.to_csv_file(fp)
+                self.logs.dump(fp, "csv")
             elif suffix == ".json":
-                self.logs.to_json_file(fp)
+                self.logs.dump(fp, "json")
             else:
                 raise ValueError(f"Unsupported file extension: {suffix}")
 

lionagi/protocols/graph/graph.py

@@ -87,8 +87,7 @@ class Graph(Element, Relational, Generic[T]):
             or edge.tail not in self.internal_nodes
         ):
             raise RelationError(
-                "Failed to add edge: Either edge head or tail node does"
-                " not exist in the graph."
+                "Failed to add edge: Either edge head or tail node does not exist in the graph."
             )
         try:
             self.internal_edges.insert(len(self.internal_edges), edge)

lionagi/protocols/graph/node.py

@@ -63,7 +63,7 @@ class Node(Element, Relational, AsyncAdaptable, Adaptable):
         self, obj_key: str, many=False, **kwargs: Any
     ) -> Any:
         kwargs["adapt_meth"] = "to_dict"
-        kwargs["mode"] = "db"
+        kwargs["adapt_kw"] = {"mode": "db"}
         return await super().adapt_to_async(
             obj_key=obj_key, many=many, **kwargs
         )
@@ -77,7 +77,6 @@ class Node(Element, Relational, AsyncAdaptable, Adaptable):
         **kwargs: Any,
     ) -> Node:
         kwargs["adapt_meth"] = "from_dict"
-        kwargs["mode"] = "db"
         return await super().adapt_from_async(
             obj, obj_key=obj_key, many=many, **kwargs
         )
@@ -87,7 +86,7 @@ class Node(Element, Relational, AsyncAdaptable, Adaptable):
         Convert this Node to another format using a registered adapter.
         """
         kwargs["adapt_meth"] = "to_dict"
-        kwargs["mode"] = "db"
+        kwargs["adapt_kw"] = {"mode": "db"}
         return super().adapt_to(obj_key=obj_key, many=many, **kwargs)
 
     @classmethod
@@ -104,7 +103,6 @@ class Node(Element, Relational, AsyncAdaptable, Adaptable):
         auto-delegate to the correct subclass via from_dict.
         """
         kwargs["adapt_meth"] = "from_dict"
-        kwargs["mode"] = "db"
         return super().adapt_from(obj, obj_key=obj_key, many=many, **kwargs)
 
     @field_serializer("content")

lionagi/protocols/messages/instruction.py

@@ -587,8 +587,7 @@ class Instruction(RoledMessage):
 
         if request_model and request_fields:
             raise ValueError(
-                "You cannot pass both request_model and request_fields "
-                "to create_instruction"
+                "You cannot pass both request_model and request_fields to create_instruction"
             )
         if guidance:
             self.guidance = guidance

lionagi/protocols/messages/manager.py

@@ -216,8 +216,7 @@ class MessageManager(Manager):
         """
         if not isinstance(action_request, ActionRequest):
             raise ValueError(
-                "Error: please provide a corresponding action request for an "
-                "action response."
+                "Error: please provide a corresponding action request for an action response."
             )
         params = {
             "action_request": action_request,

lionagi/protocols/messages/message.py

@@ -116,7 +116,14 @@ class RoledMessage(Node, Sendable):
             if isinstance(self.template, Template):
                 return self.template.render(**self.content)
         except Exception:
-            return ln.json_dumps(self.content)
+            return ln.json_dumps(
+                self.content,
+                pretty=True,
+                sort_keys=True,
+                append_newline=True,
+                deterministic_sets=True,
+                decimal_as_float=True,
+            )
 
     @classmethod
     def create(cls, **kwargs):
@@ -241,10 +248,7 @@ class RoledMessage(Node, Sendable):
             if len(str(self.content)) > 75
             else str(self.content)
         )
-        return (
-            f"Message(role={self.role}, sender={self.sender}, "
-            f"content='{content_preview}')"
-        )
+        return f"Message(role={self.role}, sender={self.sender}, content='{content_preview}')"
 
 
 # File: lionagi/protocols/messages/message.py

lionagi/service/connections/endpoint.py

@@ -150,6 +150,13 @@ class Endpoint:
                 "branch",
                 "aggregation_sources",
                 "aggregation_count",
+                "action_strategy",
+                "parse_model",
+                "reason",
+                "actions",
+                "return_operative",
+                "operative_model",
+                "request_model",
             }
             payload = {
                 k: v for k, v in payload.items() if k not in non_api_params

lionagi/service/connections/providers/claude_code_.py

@@ -56,8 +56,7 @@ class ClaudeCodeEndpoint(Endpoint):
                 "Please install it with `uv pip install lionagi[claude_code_sdk]`."
             )
         warnings.warn(
-            "The claude_code `query` endpoint is deprecated. "
-            "Use `query_cli` endpoint instead.",
+            "The claude_code `query` endpoint is deprecated. Use `query_cli` endpoint instead.",
             DeprecationWarning,
         )
 
@@ -267,7 +266,12 @@ def _verbose_output(res) -> str:
                 inp_ = None
 
                 if isinstance(block.input, dict | list):
-                    inp_ = ln.json_dumps(block.input)
+                    inp_ = ln.json_dumps(
+                        block.input,
+                        pretty=True,
+                        sort_keys=True,
+                        append_newline=True,
+                    )
                 else:
                     inp_ = str(block.input)
 

lionagi/service/resilience.py

@@ -216,8 +216,7 @@ class CircuitBreaker:
                     self._metrics["rejected_count"] += 1
 
                     logger.warning(
-                        f"Circuit '{self.name}' is HALF_OPEN and at capacity. "
-                        f"Try again later."
+                        f"Circuit '{self.name}' is HALF_OPEN and at capacity. Try again later."
                     )
 
                     return False

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

@@ -35,7 +35,6 @@ 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,
@@ -746,6 +745,8 @@ def _str_to_dict(
     """
     if not parser:
         if str_type == "xml" and not parser:
+            from .libs.validate.xml_parser import xml_to_dict
+
             parser = partial(
                 xml_to_dict, remove_root=remove_root, root_tag=root_tag
             )

lionagi/version.py

@@ -1 +1 @@
-__version__ = "0.16.0"
+__version__ = "0.16.2"

{lionagi-0.16.0.dist-info → lionagi-0.16.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lionagi
-Version: 0.16.0
+Version: 0.16.2
 Summary: An Intelligence Operating System.
 Author-email: HaiyangLi <quantocean.li@gmail.com>
 License:            Apache License
@@ -223,17 +223,16 @@ Requires-Dist: aiocache>=0.12.0
 Requires-Dist: aiohttp>=3.11.0
 Requires-Dist: anyio>=4.7.0
 Requires-Dist: backoff>=2.0.0
-Requires-Dist: exceptiongroup>=1.3.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: pydapter[pandas]>=1.0.5
+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'