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

lionagi/operations/operate/operate.py

@@ -9,18 +9,12 @@ from pydantic import BaseModel, JsonValue
 
 from lionagi.fields.instruct import Instruct
 from lionagi.models import FieldModel, ModelParams
-from lionagi.protocols.types import (
-    Instruction,
-    Operative,
-    Progression,
-    SenderRecipient,
-    Step,
-    ToolRef,
-)
+from lionagi.protocols.operatives.step import Operative, Step
+from lionagi.protocols.types import Instruction, Progression, SenderRecipient
 from lionagi.service.imodel import iModel
 
 if TYPE_CHECKING:
-    from lionagi.session.branch import Branch
+    from lionagi.session.branch import Branch, ToolRef
 
 
 def _handle_response_format_kwargs(
@@ -64,8 +58,8 @@ async def operate(
     image_detail: Literal["low", "high", "auto"] = None,
     parse_model: iModel = None,
     skip_validation: bool = False,
-    tools: ToolRef = None,
-    operative: Operative = None,
+    tools: "ToolRef" = None,
+    operative: "Operative" = None,
     response_format: type[BaseModel] = None,  # alias of operative.request_type
     return_operative: bool = False,
     actions: bool = False,

lionagi/operations/parse/parse.py

@@ -7,7 +7,6 @@ from typing import TYPE_CHECKING, Any, Literal
 from pydantic import BaseModel
 
 from lionagi.ln.fuzzy._fuzzy_validate import fuzzy_validate_mapping
-from lionagi.protocols.types import Operative
 from lionagi.utils import breakdown_pydantic_annotation
 
 if TYPE_CHECKING:
@@ -22,7 +21,7 @@ async def parse(
     ] = "return_value",
     max_retries: int = 3,
     request_type: type[BaseModel] = None,
-    operative: Operative = None,
+    operative=None,
     similarity_algo="jaro_winkler",
     similarity_threshold: float = 0.85,
     fuzzy_match: bool = True,

lionagi/operations/types.py

@@ -12,7 +12,6 @@ from .parse.parse import parse
 from .plan.plan import plan
 from .ReAct.ReAct import ReAct
 from .select.select import select
-from .translate.translate import translate
 
 __all__ = (
     "brainstorm",
@@ -25,5 +24,4 @@ __all__ = (
     "operate",
     "parse",
     "ReAct",
-    "translate",
 )

lionagi/operations/utils.py

@@ -2,18 +2,24 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+from typing import TYPE_CHECKING
+
 from lionagi.fields.instruct import Instruct
-from lionagi.session.session import Branch, Session
+
+if TYPE_CHECKING:
+    from lionagi.session.session import Branch, Session
 
 
 def prepare_session(
-    session: Session | None = None,
-    branch: Branch | None = None,
+    session: "Session" = None,
+    branch: "Branch" = None,
     branch_kwargs=None,
-) -> tuple[Session, Branch]:
+) -> tuple["Session", "Branch"]:
+    from lionagi.session.session import Branch, Session
+
     if session is not None:
         if branch is not None:
-            branch: Branch = session.branches[branch]
+            branch: "Branch" = session.branches[branch]
         else:
             branch = session.new_branch(**(branch_kwargs or {}))
     else:

lionagi/protocols/generic/pile.py

@@ -18,7 +18,6 @@ from functools import wraps
 from pathlib import Path
 from typing import Any, ClassVar, Generic, Literal, TypeVar
 
-import pandas as pd
 from pydantic import Field, field_serializer
 from pydantic.fields import FieldInfo
 from pydapter import Adaptable, AsyncAdaptable
@@ -1047,9 +1046,7 @@ class Pile(Element, Collective[T], Generic[T], Adaptable, AsyncAdaptable):
         kw["adapt_meth"] = "from_dict"
         return await super().adapt_from_async(obj, obj_key, many=many, **kw)
 
-    def to_df(
-        self, columns: list[str] | None = None, **kw: Any
-    ) -> pd.DataFrame:
+    def to_df(self, columns: list[str] | None = None, **kw: Any):
         """Convert to DataFrame."""
         from pydapter.extras.pandas_ import DataFrameAdapter
 
@@ -1207,11 +1204,10 @@ def to_list_type(value: Any, /) -> list[Any]:
 
 if not _ADAPATER_REGISTERED:
     from pydapter.adapters import CsvAdapter, JsonAdapter
-    from pydapter.extras.pandas_ import DataFrameAdapter
 
     Pile.register_adapter(CsvAdapter)
     Pile.register_adapter(JsonAdapter)
-    Pile.register_adapter(DataFrameAdapter)
+
     _ADAPATER_REGISTERED = True
 
 Pile = Pile

lionagi/protocols/graph/graph.py

@@ -19,10 +19,8 @@ from .node import Node
 
 T = TypeVar("T", bound=Node)
 
-from ._utils import check_matplotlib_available, check_networkx_available
-
-_NETWORKX_AVAILABLE = check_networkx_available()
-_MATPLIB_AVAILABLE = check_matplotlib_available()
+_NETWORKX_AVAILABLE = None
+_MATPLIB_AVAILABLE = None
 __all__ = ("Graph",)
 
 
@@ -219,8 +217,17 @@ class Graph(Element, Relational, Generic[T]):
 
     def to_networkx(self, **kwargs) -> Any:
         """Convert the graph to a NetworkX graph object."""
+        global _NETWORKX_AVAILABLE
+        if _NETWORKX_AVAILABLE is None:
+            from lionagi.ln import is_import_installed
+
+            _NETWORKX_AVAILABLE = is_import_installed("networkx")
+
         if _NETWORKX_AVAILABLE is not True:
-            raise _NETWORKX_AVAILABLE
+            raise ImportError(
+                "The 'networkx' package is required for this feature. "
+                "Please install `networkx` or `'lionagi[graph]'`."
+            )
 
         from networkx import DiGraph  # type: ignore
 
@@ -248,8 +255,18 @@ class Graph(Element, Relational, Generic[T]):
     ):
         """Display the graph using NetworkX and Matplotlib."""
         g = self.to_networkx(**kwargs)
+
+        global _MATPLIB_AVAILABLE
+        if _MATPLIB_AVAILABLE is None:
+            from lionagi.ln import is_import_installed
+
+            _MATPLIB_AVAILABLE = is_import_installed("matplotlib")
+
         if _MATPLIB_AVAILABLE is not True:
-            raise _MATPLIB_AVAILABLE
+            raise ImportError(
+                "The 'matplotlib' package is required for this feature. "
+                "Please install `matplotlib` or `'lionagi[graph]'`."
+            )
 
         import matplotlib.pyplot as plt  # type: ignore
         import networkx as nx  # type: ignore

lionagi/protocols/graph/node.py

@@ -62,6 +62,10 @@ class Node(Element, Relational, AsyncAdaptable, Adaptable):
     async def adapt_to_async(
         self, obj_key: str, many=False, **kwargs: Any
     ) -> Any:
+        # Only register postgres adapter if this specific operation needs it
+        if obj_key == "lionagi_async_pg":
+            _ensure_postgres_adapter()
+
         kwargs["adapt_meth"] = "to_dict"
         kwargs["adapt_kw"] = {"mode": "db"}
         return await super().adapt_to_async(
@@ -76,6 +80,10 @@ class Node(Element, Relational, AsyncAdaptable, Adaptable):
         many=False,
         **kwargs: Any,
     ) -> Node:
+        # Only register postgres adapter if this specific operation needs it
+        if obj_key == "lionagi_async_pg":
+            _ensure_postgres_adapter()
+
         kwargs["adapt_meth"] = "from_dict"
         return await super().adapt_from_async(
             obj, obj_key=obj_key, many=many, **kwargs
@@ -122,22 +130,31 @@ class Node(Element, Relational, AsyncAdaptable, Adaptable):
         return value
 
 
+def _ensure_postgres_adapter():
+    """Lazy registration of postgres adapter when needed"""
+    if not hasattr(Node, "_postgres_adapter_checked"):
+        from lionagi.adapters._utils import check_async_postgres_available
+
+        if check_async_postgres_available() is True:
+            try:
+                from lionagi.adapters.async_postgres_adapter import (
+                    LionAGIAsyncPostgresAdapter,
+                )
+
+                Node.register_async_adapter(LionAGIAsyncPostgresAdapter)
+            except ImportError:
+                pass  # Graceful degradation if postgres dependencies missing
+        Node._postgres_adapter_checked = True
+
+
 if not _ADAPATER_REGISTERED:
     from pydapter.adapters import JsonAdapter, TomlAdapter
-    from pydapter.extras.pandas_ import SeriesAdapter
 
     Node.register_adapter(JsonAdapter)
     Node.register_adapter(TomlAdapter)
-    Node.register_adapter(SeriesAdapter)
-
-    from lionagi.adapters._utils import check_async_postgres_available
-
-    if check_async_postgres_available() is True:
-        from lionagi.adapters.async_postgres_adapter import (
-            LionAGIAsyncPostgresAdapter,
-        )
 
-        Node.register_async_adapter(LionAGIAsyncPostgresAdapter)
+    # PostgreSQL adapter registration is now lazy - only loaded when needed
+    # Call _ensure_postgres_adapter() in methods that actually use async adapters
 
     _ADAPATER_REGISTERED = True
 

lionagi/protocols/messages/message.py

@@ -4,7 +4,6 @@
 
 from __future__ import annotations
 
-import json
 from pathlib import Path
 from typing import Any
 

lionagi/protocols/types.py

@@ -5,10 +5,7 @@
 from ._concepts import Collective, Communicatable, Condition, Manager
 from ._concepts import Observable as LegacyObservable
 from ._concepts import Observer, Ordering, Relational, Sendable
-from .action.manager import ActionManager, FunctionCalling, Tool, ToolRef
 from .contracts import Observable, ObservableProto
-from .forms.flow import FlowDefinition, FlowStep
-from .forms.report import BaseForm, Form, Report
 from .generic.element import ID, Element, IDError, IDType, validate_order
 from .generic.event import Event, EventStatus, Execution
 from .generic.log import (
@@ -43,7 +40,6 @@ from .messages.manager import (
     SenderRecipient,
     System,
 )
-from .operatives.step import Operative, Step
 
 __all__ = (
     "Collective",
@@ -98,17 +94,6 @@ __all__ = (
     "RoledMessage",
     "SenderRecipient",
     "System",
-    "FlowDefinition",
-    "FlowStep",
-    "BaseForm",
-    "Form",
-    "Report",
-    "Operative",
-    "Step",
-    "ActionManager",
-    "Tool",
-    "FunctionCalling",
-    "ToolRef",
     "MailManager",
     "DataLogger",
     "DataLoggerConfig",

lionagi/service/__init__.py

@@ -1,10 +1,28 @@
+# Eager imports for core functionality
 from .connections.api_calling import APICalling
 from .connections.endpoint import Endpoint, EndpointConfig
 from .hooks import *
 from .imodel import iModel
 from .manager import iModelManager
 from .rate_limited_processor import RateLimitedAPIExecutor
-from .token_calculator import TokenCalculator
+
+# Lazy loading cache
+_lazy_imports = {}
+
+
+def __getattr__(name: str):
+    """Lazy loading for heavy service imports."""
+    if name in _lazy_imports:
+        return _lazy_imports[name]
+
+    if name == "TokenCalculator":
+        from .token_calculator import TokenCalculator
+
+        _lazy_imports["TokenCalculator"] = TokenCalculator
+        return TokenCalculator
+
+    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
+
 
 __all__ = (
     "APICalling",

lionagi/service/connections/api_calling.py

@@ -12,10 +12,17 @@ from typing_extensions import Self
 from lionagi.protocols.generic.event import Event, EventStatus
 from lionagi.protocols.types import Log
 from lionagi.service.hooks import HookEvent, HookEventTypes, global_hook_logger
-from lionagi.service.token_calculator import TokenCalculator
 
 from .endpoint import Endpoint
 
+
+# Lazy import for TokenCalculator
+def _get_token_calculator():
+    from lionagi.service.token_calculator import TokenCalculator
+
+    return TokenCalculator
+
+
 logger = logging.getLogger(__name__)
 
 
@@ -129,7 +136,7 @@ class APICalling(Event):
 
         # Handle chat completions format
         if "messages" in self.payload:
-            return TokenCalculator.calculate_message_tokens(
+            return _get_token_calculator().calculate_message_tokens(
                 self.payload["messages"], **self.payload
             )
         # Handle responses API format
@@ -150,12 +157,14 @@ class APICalling(Event):
                             messages.append(item)
             else:
                 return None
-            return TokenCalculator.calculate_message_tokens(
+            return _get_token_calculator().calculate_message_tokens(
                 messages, **self.payload
             )
         # Handle embeddings endpoint
         elif "embed" in self.endpoint.config.endpoint:
-            return TokenCalculator.calculate_embed_token(**self.payload)
+            return _get_token_calculator().calculate_embed_token(
+                **self.payload
+            )
 
         return None
 

lionagi/service/connections/endpoint.py

@@ -5,18 +5,13 @@
 import asyncio
 import logging
 
-import aiohttp
-import backoff
-from aiocache import cached
 from pydantic import BaseModel
 
-from lionagi.config import settings
 from lionagi.service.resilience import (
     CircuitBreaker,
     RetryConfig,
     retry_with_backoff,
 )
-from lionagi.utils import to_dict
 
 from .endpoint_config import EndpointConfig
 from .header_factory import HeaderFactory
@@ -65,6 +60,8 @@ class Endpoint:
 
     def _create_http_session(self):
         """Create a new HTTP session (not thread-safe, create new for each request)."""
+        import aiohttp
+
         return aiohttp.ClientSession(
             timeout=aiohttp.ClientTimeout(self.config.timeout),
             **self.config.client_kwargs,
@@ -231,6 +228,9 @@ class Endpoint:
 
         # Handle caching if requested
         if cache_control:
+            from aiocache import cached
+
+            from lionagi.config import settings
 
             @cached(**settings.aiocache_config.as_kwargs())
             async def _cached_call(payload: dict, headers: dict, **kwargs):
@@ -268,6 +268,8 @@ class Endpoint:
         Returns:
             The response from the endpoint.
         """
+        import aiohttp
+        import backoff
 
         async def _make_request_with_backoff():
             # Create a new session for this request
@@ -382,6 +384,8 @@ class Endpoint:
                 **kwargs,
             ) as response:
                 if response.status != 200:
+                    import aiohttp
+
                     raise aiohttp.ClientResponseError(
                         request_info=response.request_info,
                         history=response.history,
@@ -409,6 +413,8 @@ class Endpoint:
 
     @classmethod
     def from_dict(cls, data: dict):
+        from lionagi.utils import to_dict
+
         data = to_dict(data, recursive=True)
         retry_config = data.get("retry_config")
         circuit_breaker = data.get("circuit_breaker")

lionagi/service/types.py

@@ -2,6 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+# Eager imports for core functionality
 from .connections.api_calling import APICalling
 from .connections.endpoint import Endpoint, EndpointConfig
 from .connections.providers.types import *
@@ -9,7 +10,24 @@ from .hooks import *
 from .imodel import iModel
 from .manager import iModelManager
 from .rate_limited_processor import RateLimitedAPIExecutor
-from .token_calculator import TokenCalculator
+
+# Lazy loading cache
+_lazy_imports = {}
+
+
+def __getattr__(name: str):
+    """Lazy loading for heavy service imports."""
+    if name in _lazy_imports:
+        return _lazy_imports[name]
+
+    if name == "TokenCalculator":
+        from .token_calculator import TokenCalculator
+
+        _lazy_imports["TokenCalculator"] = TokenCalculator
+        return TokenCalculator
+
+    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
+
 
 __all__ = (
     "APICalling",

lionagi/session/branch.py

@@ -4,10 +4,8 @@
 
 from collections.abc import AsyncGenerator, Callable
 from enum import Enum
-from typing import Any, Literal
+from typing import TYPE_CHECKING, Any, Literal, Optional
 
-import pandas as pd
-from jinja2 import Template
 from pydantic import BaseModel, Field, JsonValue, PrivateAttr, field_serializer
 
 from lionagi.config import settings
@@ -15,11 +13,11 @@ from lionagi.fields import Instruct
 from lionagi.libs.schema.as_readable import as_readable
 from lionagi.models.field_model import FieldModel
 from lionagi.operations.manager import OperationManager
+from lionagi.protocols.action.manager import ActionManager
 from lionagi.protocols.action.tool import FuncTool, Tool, ToolRef
 from lionagi.protocols.types import (
     ID,
     MESSAGE_FIELDS,
-    ActionManager,
     ActionRequest,
     ActionResponse,
     AssistantResponse,
@@ -34,8 +32,6 @@ from lionagi.protocols.types import (
     Mailbox,
     MessageManager,
     MessageRole,
-    Operative,
-    Package,
     PackageCategory,
     Pile,
     Progression,
@@ -54,6 +50,10 @@ from lionagi.utils import copy
 
 from .prompts import LION_SYSTEM_MESSAGE
 
+if TYPE_CHECKING:
+    from lionagi.protocols.operatives.operative import Operative
+
+
 __all__ = ("Branch",)
 
 
@@ -117,18 +117,18 @@ class Branch(Element, Communicatable, Relational):
     def __init__(
         self,
         *,
-        user: SenderRecipient = None,
+        user: "SenderRecipient" = None,
         name: str | None = None,
         messages: Pile[RoledMessage] = None,  # message manager kwargs
         system: System | JsonValue = None,
-        system_sender: SenderRecipient = None,
+        system_sender: "SenderRecipient" = None,
         chat_model: iModel | dict = None,  # iModelManager kwargs
         parse_model: iModel | dict = None,
         imodel: iModel = None,  # deprecated, alias of chat_model
         tools: FuncTool | list[FuncTool] = None,  # ActionManager kwargs
         log_config: LogManagerConfig | dict = None,  # LogManager kwargs
         system_datetime: bool | str = None,
-        system_template: Template | str = None,
+        system_template=None,
         system_template_context: dict = None,
         logs: Pile[Log] = None,
         use_lion_system_message: bool = False,
@@ -163,7 +163,7 @@ class Branch(Element, Communicatable, Relational):
             system_datetime (bool | str, optional):
                 Whether to include timestamps in system messages (True/False)
                 or a string format for datetime.
-            system_template (Template | str, optional):
+            system_template (jinja2.Template | str, optional):
                 Optional Jinja2 template for system messages.
             system_template_context (dict, optional):
                 Context for rendering the system template.
@@ -177,6 +177,8 @@ class Branch(Element, Communicatable, Relational):
         super().__init__(user=user, name=name, **kwargs)
 
         # --- MessageManager ---
+        from lionagi.protocols.messages.manager import MessageManager
+
         self._message_manager = MessageManager(messages=messages)
 
         if any(
@@ -401,7 +403,7 @@ class Branch(Element, Communicatable, Relational):
     # -------------------------------------------------------------------------
     # Conversion / Serialization
     # -------------------------------------------------------------------------
-    def to_df(self, *, progression: Progression = None) -> pd.DataFrame:
+    def to_df(self, *, progression: Progression = None):
         """
         Convert branch messages into a `pandas.DataFrame`.
 
@@ -412,6 +414,8 @@ class Branch(Element, Communicatable, Relational):
         Returns:
             pd.DataFrame: Each row represents a message, with columns defined by MESSAGE_FIELDS.
         """
+        from lionagi.protocols.generic.pile import Pile
+
         if progression is None:
             progression = self.msgs.progression
 
@@ -429,7 +433,7 @@ class Branch(Element, Communicatable, Relational):
     def send(
         self,
         recipient: IDType,
-        category: PackageCategory | None,
+        category: Optional["PackageCategory"],
         item: Any,
         request_source: IDType | None = None,
     ) -> None:
@@ -446,6 +450,8 @@ class Branch(Element, Communicatable, Relational):
             request_source (IDType | None):
                 The ID that prompted or requested this send operation (optional).
         """
+        from lionagi.protocols.mail.package import Package
+
         package = Package(
             category=category,
             item=item,
@@ -833,7 +839,7 @@ class Branch(Element, Communicatable, Relational):
         ] = "return_value",
         max_retries: int = 3,
         request_type: type[BaseModel] = None,
-        operative: Operative = None,
+        operative: "Operative" = None,
         similarity_algo="jaro_winkler",
         similarity_threshold: float = 0.85,
         fuzzy_match: bool = True,
@@ -911,8 +917,8 @@ class Branch(Element, Communicatable, Relational):
         instruction: Instruction | JsonValue = None,
         guidance: JsonValue = None,
         context: JsonValue = None,
-        sender: SenderRecipient = None,
-        recipient: SenderRecipient = None,
+        sender: "SenderRecipient" = None,
+        recipient: "SenderRecipient" = None,
         progression: Progression = None,
         chat_model: iModel = None,
         invoke_actions: bool = True,
@@ -922,7 +928,7 @@ class Branch(Element, Communicatable, Relational):
         parse_model: iModel = None,
         skip_validation: bool = False,
         tools: ToolRef = None,
-        operative: Operative = None,
+        operative: "Operative" = None,
         response_format: type[
             BaseModel
         ] = None,  # alias of operative.request_type
@@ -1063,8 +1069,8 @@ class Branch(Element, Communicatable, Relational):
         guidance: JsonValue = None,
         context: JsonValue = None,
         plain_content: str = None,
-        sender: SenderRecipient = None,
-        recipient: SenderRecipient = None,
+        sender: "SenderRecipient" = None,
+        recipient: "SenderRecipient" = None,
         progression: ID.IDSeq = None,
         response_format: type[BaseModel] = None,
         request_fields: dict | list[str] = None,