lionagi 0.17.0__py3-none-any.whl → 0.17.2__py3-none-any.whl

lionagi/__init__.py

@@ -6,9 +6,8 @@ import logging
 
 from pydantic import BaseModel, Field
 
-from . import _types as types
+# Eager imports for commonly used components
 from . import ln as ln
-from .operations.builder import OperationGraphBuilder as Builder
 from .operations.node import Operation
 from .service.imodel import iModel
 from .session.session import Branch, Session
@@ -17,6 +16,29 @@ from .version import __version__
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.INFO)
 
+# Module-level lazy loading cache
+_lazy_imports = {}
+
+
+def __getattr__(name: str):
+    """Lazy loading for expensive imports."""
+    if name in _lazy_imports:
+        return _lazy_imports[name]
+
+    if name == "types":
+        from . import _types as types
+
+        _lazy_imports["types"] = types
+        return types
+    elif name == "Builder":
+        from .operations.builder import OperationGraphBuilder as Builder
+
+        _lazy_imports["Builder"] = Builder
+        return Builder
+
+    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
+
+
 __all__ = (
     "Session",
     "Branch",

lionagi/_types.py

@@ -1,3 +1,47 @@
-from .fields import *
-from .models import *
-from .protocols.types import *
+# Lazy loading for heavy type imports to improve startup performance
+_lazy_type_imports = {}
+
+
+def __getattr__(name: str):
+    """Lazy loading for type definitions."""
+    if name in _lazy_type_imports:
+        return _lazy_type_imports[name]
+
+    # Import from fields
+    try:
+        from .fields import __all__ as fields_all
+
+        if name in fields_all:
+            from . import fields
+
+            attr = getattr(fields, name)
+            _lazy_type_imports[name] = attr
+            return attr
+    except (ImportError, AttributeError):
+        pass
+
+    # Import from models
+    try:
+        from .models import __all__ as models_all
+
+        if name in models_all:
+            from . import models
+
+            attr = getattr(models, name)
+            _lazy_type_imports[name] = attr
+            return attr
+    except (ImportError, AttributeError):
+        pass
+
+    # Import from protocols.types
+    try:
+        from .protocols import types as protocol_types
+
+        if hasattr(protocol_types, name):
+            attr = getattr(protocol_types, name)
+            _lazy_type_imports[name] = attr
+            return attr
+    except (ImportError, AttributeError):
+        pass
+
+    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")

lionagi/operations/flow.py

@@ -549,3 +549,94 @@ async def flow(
     )
 
     return await executor.execute()
+
+
+def cleanup_flow_results(
+    result: dict[str, Any], keep_only: list[str] = None
+) -> dict[str, Any]:
+    """
+    Clean up flow execution results to reduce memory usage.
+
+    Args:
+        result: Flow execution result dictionary
+        keep_only: List of operation IDs to keep results for (optional)
+
+    Returns:
+        Modified result dictionary with reduced memory footprint
+    """
+    if not isinstance(result, dict) or "operation_results" not in result:
+        return result
+
+    # If keep_only is specified, only keep those results
+    if keep_only is not None:
+        filtered_results = {
+            op_id: res
+            for op_id, res in result["operation_results"].items()
+            if op_id in keep_only
+        }
+        result["operation_results"] = filtered_results
+        # Update completed_operations to match
+        result["completed_operations"] = [
+            op_id
+            for op_id in result.get("completed_operations", [])
+            if op_id in keep_only
+        ]
+    else:
+        # Clear all results to free memory
+        result["operation_results"] = {}
+        result["completed_operations"] = []
+
+    return result
+
+
+async def flow_with_cleanup(
+    session: "Session",
+    graph: "Graph",
+    context: dict[str, Any] | None = None,
+    parallel: bool = True,
+    max_concurrent: int = 5,
+    verbose: bool = False,
+    branch: "Branch" = None,
+    alcall_params: AlcallParams | None = None,
+    cleanup_results: bool = True,
+    keep_only: list[str] = None,
+) -> dict[str, Any]:
+    """
+    Execute flow with automatic cleanup to prevent memory accumulation.
+
+    Args:
+        session: Session instance for branch management
+        graph: Operation graph to execute
+        context: Initial context data
+        parallel: Execute independent operations in parallel
+        max_concurrent: Max concurrent operations (1 if not parallel)
+        verbose: Enable verbose logging
+        branch: Default branch for operations
+        alcall_params: Parameters for async parallel call execution
+        cleanup_results: Whether to clean up operation results after execution
+        keep_only: List of operation IDs to keep results for (if cleanup_results=True)
+
+    Returns:
+        Execution results (potentially with cleaned up memory footprint)
+    """
+    # Execute the flow normally
+    result = await flow(
+        session=session,
+        graph=graph,
+        context=context,
+        parallel=parallel,
+        max_concurrent=max_concurrent,
+        verbose=verbose,
+        branch=branch,
+        alcall_params=alcall_params,
+    )
+
+    # Clean up session memory
+    if hasattr(session, "cleanup_memory"):
+        session.cleanup_memory()
+
+    # Clean up results if requested
+    if cleanup_results:
+        result = cleanup_flow_results(result, keep_only=keep_only)
+
+    return result

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,20 +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
 
     Node.register_adapter(JsonAdapter)
     Node.register_adapter(TomlAdapter)
 
-    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/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/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/session.py

@@ -416,6 +416,48 @@ class Session(Node, Communicatable, Relational):
             alcall_params=alcall_params,
         )
 
+    def cleanup_memory(
+        self, clear_branches: bool = True, clear_mail: bool = True
+    ):
+        """
+        Clean up session memory to prevent memory accumulation.
+
+        Args:
+            clear_branches: Whether to clear branch logs and memory
+            clear_mail: Whether to clear mail transfer history
+        """
+        if clear_branches and self.branches:
+            for branch in self.branches:
+                if hasattr(branch, "dump_logs"):
+                    branch.dump_logs(clear=True)
+
+        if clear_mail and self.mail_transfer:
+            # Clear mail transfer history if available
+            if hasattr(self.mail_transfer, "clear"):
+                self.mail_transfer.clear()
+
+    async def acleanup_memory(
+        self, clear_branches: bool = True, clear_mail: bool = True
+    ):
+        """
+        Asynchronously clean up session memory to prevent memory accumulation.
+
+        Args:
+            clear_branches: Whether to clear branch logs and memory
+            clear_mail: Whether to clear mail transfer history
+        """
+        if clear_branches and self.branches:
+            for branch in self.branches:
+                if hasattr(branch, "adump_logs"):
+                    await branch.adump_logs(clear=True)
+
+        if clear_mail and self.mail_transfer:
+            # Clear mail transfer history if available
+            if hasattr(self.mail_transfer, "aclear"):
+                await self.mail_transfer.aclear()
+            elif hasattr(self.mail_transfer, "clear"):
+                self.mail_transfer.clear()
+
 
 __all__ = ["Session"]
 # File: autoos/session/session.py

lionagi/version.py

@@ -1 +1 @@
-__version__ = "0.17.0"
+__version__ = "0.17.2"

{lionagi-0.17.0.dist-info → lionagi-0.17.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lionagi
-Version: 0.17.0
+Version: 0.17.2
 Summary: An Intelligence Operating System.
 Author-email: HaiyangLi <quantocean.li@gmail.com>
 License:            Apache License

{lionagi-0.17.0.dist-info → lionagi-0.17.2.dist-info}/RECORD

@@ -1,12 +1,12 @@
-lionagi/__init__.py,sha256=HZmhhYeplh06qAJQ7cW8JUlJsqG_Q4JKJ3GGFW_ZQnw,682
+lionagi/__init__.py,sha256=KDyBBo2Ahdk44akAbUG7ZZATdZhVvl8WHEr6HXMC6vA,1196
 lionagi/_class_registry.py,sha256=pfUO1DjFZIqr3OwnNMkFqL_fiEBrrf8-swkGmP_KDLE,3112
 lionagi/_errors.py,sha256=ia_VWhPSyr5FIJLSdPpl04SrNOLI2skN40VC8ePmzeQ,3748
-lionagi/_types.py,sha256=j8XwSGeGrYwfmSJ8o-80bsfoalLWJgQH41ZkVevc4wk,75
+lionagi/_types.py,sha256=COWRrmstmABGKKn-h_cKiAREGsMp_Ik49OdR4lSS3P8,1263
 lionagi/config.py,sha256=D13nnjpgJKz_LlQrzaKKVefm4hqesz_dP9ROjWmGuLE,3811
 lionagi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lionagi/settings.py,sha256=HDuKCEJCpc4HudKodBnhoQUGuTGhRHdlIFhbtf3VBtY,1633
 lionagi/utils.py,sha256=pfAibR84sx-aPxGNPrdlHqUAf2OXoCBGRCMseMrzhi4,18046
-lionagi/version.py,sha256=XpM3lncCzPBIwMSvDN7i10pke_c6KdJtVLZYbCiaTRw,23
+lionagi/version.py,sha256=I5u6uLh7NsbyGkKLvVteW175Afe6HJt5UsjBZ28EGks,23
 lionagi/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lionagi/adapters/_utils.py,sha256=sniMG1LDDkwJNzUF2K32jv7rA6Y1QcohgyNclYsptzI,453
 lionagi/adapters/async_postgres_adapter.py,sha256=2XlxYNPow78dFHIQs8W1oJ2zkVD5Udn3aynMBF9Nf3k,3498
@@ -71,7 +71,7 @@ lionagi/models/schema_model.py,sha256=ghRIM8aBNaToAknwNlhQKpuKXcwzyCw5pDE31bVKxs
 lionagi/operations/__init__.py,sha256=DU9sIhtw1vPBVllZ1Fbum8GE3qC9yfyQtt6_8vyv_cA,444
 lionagi/operations/_visualize_graph.py,sha256=F0KadgRthP-6-R-FPgvlwiiaiWH3ueO-rjSd1bzRUbE,8594
 lionagi/operations/builder.py,sha256=c6OIBwIX2-V4oH7wRBQf4SEs38L9lHdSX1ODb7ETLuI,14722
-lionagi/operations/flow.py,sha256=StGPmpPLe_ZFVwWmc9RiUpH7i1gkhN4q7A94ax0_b1E,22298
+lionagi/operations/flow.py,sha256=7mjyKCXN1GYNDxNMqjALr9j6vsgm8TC2Z4ZNpzzfUMU,25141
 lionagi/operations/manager.py,sha256=YZr3VjPAZVVFd_bIjF1aoQqzzKZHNA1kcqefNi5QFFM,683
 lionagi/operations/node.py,sha256=zntelS3kO6q4H6vpS2lpw3iNUTLR3a6I3dp07fdSGJs,3465
 lionagi/operations/types.py,sha256=zBhTQ4od4yXo84_Osbed7Zqhnp-PA90mrjGsQSSCuzw,644
@@ -126,7 +126,7 @@ lionagi/protocols/generic/progression.py,sha256=HCV_EnQCFvjg6D7eF4ygGrZNQPEOtu75
 lionagi/protocols/graph/__init__.py,sha256=UPu3OmUpjSgX2aBuBJUdG2fppGlfqAH96hU0qIMBMp0,253
 lionagi/protocols/graph/edge.py,sha256=YxSGj4w_fG7khm-zpKduuK5fJzhJDx23JhU1dZp29d8,5241
 lionagi/protocols/graph/graph.py,sha256=l-12vTRblpWS_M4Ae-NTZThdeioaQvmhCS83mjB2fe8,11159
-lionagi/protocols/graph/node.py,sha256=TuPNHSlkSpqp7nxUV2gj-SkCZVkY4ZocnB79ONlkY6o,4467
+lionagi/protocols/graph/node.py,sha256=AtMw-Z88aW0YjOlN1g6cxmRrSSC3qyGV1MYqBg5hUrY,5305
 lionagi/protocols/mail/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFCJM,112
 lionagi/protocols/mail/exchange.py,sha256=P1PcrFylIBeiQa8kox9H1qyJ4kjhUlbLiTUT8rs1OXg,7041
 lionagi/protocols/mail/mail.py,sha256=RB5CUft_4J85H9nM9g6aRXomTaqKwF5xVjJacPAhoa8,1356
@@ -152,15 +152,15 @@ lionagi/protocols/messages/templates/tool_schemas.jinja2,sha256=ozIaSDCRjIAhLyA8
 lionagi/protocols/operatives/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFCJM,112
 lionagi/protocols/operatives/operative.py,sha256=Y_prGR7aPQtO3ws91W_KkjJTVnb5lYkfwMKaEIN2FVU,13331
 lionagi/protocols/operatives/step.py,sha256=uF92QO2KZiY3YR1cxhrbD844VFidOKfmeQn2Fv637iY,9280
-lionagi/service/__init__.py,sha256=C_TPk1roVYz6uVLK1JVxrK3tPtYqN6W0D7FzI-s6CWY,556
+lionagi/service/__init__.py,sha256=qcscXOKVQtDDQ7YV-_D9jcIABDkGaxAEsCKsBBtf4XE,992
 lionagi/service/imodel.py,sha256=ya406sf42-KRrKN4TJJLtI6wsKeM5hAhWr7Hubg7W0E,16371
 lionagi/service/manager.py,sha256=tN3p0kM7pg_CEs6wXK62_B_h49Q3nrU-9qniFhw2ABE,1164
 lionagi/service/rate_limited_processor.py,sha256=h2_F71aVeBrgZ0a7ARS8-8NDaAHvfWrLykI5QcNuYbk,6099
 lionagi/service/resilience.py,sha256=91RPFtQY4QyNga_nuSNLsbzNE26pXJMTAfLaQqVdvmg,18714
 lionagi/service/token_calculator.py,sha256=piTidArzUkIMCtOLC_HBLoZNYZcENQywgeKM31bxezM,6457
-lionagi/service/types.py,sha256=9zX08BhdmPE9FE1YTyvsy14hdDGRYzyyVBmoBURzQvI,1096
+lionagi/service/types.py,sha256=KxUM3m6LMPqIO3l1nNdaSJ8vt46ozOKWFZyI4LXBTRk,1532
 lionagi/service/connections/__init__.py,sha256=yHQZ7OJpCftd6CStYR8inbxjJydYdmv9kCvbUBhJ2zU,362
-lionagi/service/connections/api_calling.py,sha256=fY-fzwSJvQKpUT27TF0MTfE5TxroYKkL4SHWYrmYznI,9958
+lionagi/service/connections/api_calling.py,sha256=n_FA_Q8R7s0KsgsUE-obyVPB73UbOxTD2c_qpi9ngso,10110
 lionagi/service/connections/endpoint.py,sha256=0r4-8NPyAvLNey09BBsUr5KGJCXchBmVZm2pCe3Nbq4,15165
 lionagi/service/connections/endpoint_config.py,sha256=6sA06uCzriT6p0kFxhDCFH8N6V6MVp8ytlOw5ctBhDI,5169
 lionagi/service/connections/header_factory.py,sha256=IYeTQQk7r8FXcdhmW7orCxHjNO-Nb1EOXhgNK7CAp-I,1821
@@ -189,13 +189,13 @@ lionagi/service/third_party/pplx_models.py,sha256=-EhyJgOWR6rzSv3zczUtk80X6c19p1
 lionagi/session/__init__.py,sha256=kDypY6L3kGPnatAw7YNQAykgg-9MlIBnlhHExaXvt-c,202
 lionagi/session/branch.py,sha256=Gz9QOhZ2e6UJtTTkqY4P1Oa0UnjXHwIJTP7YCpcbA9o,65064
 lionagi/session/prompts.py,sha256=GPr0jibyAAqS3awDzGC8SoCL6aWJLLCCbXY0JUuxOC0,3170
-lionagi/session/session.py,sha256=BVouy9xiqVfD6AucTVs80vSvs7nIKsgGjgvIFgMsO0Q,12970
+lionagi/session/session.py,sha256=mPUUm-NG9UtUdn98UqIGRkxcZoFswrob70tVb_QZSf8,14536
 lionagi/tools/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFCJM,112
 lionagi/tools/base.py,sha256=hEGnE4MD0CM4UqnF0xsDRKB0aM-pyrTFHl8utHhyJLU,1897
 lionagi/tools/types.py,sha256=XtJLY0m-Yi_ZLWhm0KycayvqMCZd--HxfQ0x9vFUYDE,230
 lionagi/tools/file/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFCJM,112
 lionagi/tools/file/reader.py,sha256=2YKgU3VKo76zfL_buDAUQJoPLC56f6WJ4_mdJjlMDIM,9509
-lionagi-0.17.0.dist-info/METADATA,sha256=x9SSUvfLlKC40Tta8exQJnp7T5ajT9dX-FjFCW3iBvc,22674
-lionagi-0.17.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-lionagi-0.17.0.dist-info/licenses/LICENSE,sha256=VXFWsdoN5AAknBCgFqQNgPWYx7OPp-PFEP961zGdOjc,11288
-lionagi-0.17.0.dist-info/RECORD,,
+lionagi-0.17.2.dist-info/METADATA,sha256=AXGNj_mj3gEEDpn7gAtSO5t7W1dkhW_8LVbfSxfbP7A,22674
+lionagi-0.17.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+lionagi-0.17.2.dist-info/licenses/LICENSE,sha256=VXFWsdoN5AAknBCgFqQNgPWYx7OPp-PFEP961zGdOjc,11288
+lionagi-0.17.2.dist-info/RECORD,,