lionagi 0.3.6__tar.gz → 0.3.8__tar.gz

lionagi-0.3.8/PKG-INFO

@@ -0,0 +1,241 @@
+Metadata-Version: 2.1
+Name: lionagi
+Version: 0.3.8
+Summary: Towards automated general intelligence.
+Author: HaiyangLi
+Author-email: quantocean.li@gmail.com
+Requires-Python: >=3.10,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: aiocache (>=0.12.0,<0.13.0)
+Requires-Dist: ipython (>=8.0.0,<9.0.0)
+Requires-Dist: lion-core (>=0.5.6,<0.6.0)
+Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
+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)
+![Dependencies](https://img.shields.io/badge/dependencies-4-brightgreen)
+![Python Version](https://img.shields.io/badge/python-3.10%2B-blue)
+
+[Documentation](https://ocean-lion.com/Welcome) | [Discord](https://discord.gg/aqSJ2v46vu) | [PyPI](https://pypi.org/project/lionagi/) | [Roadmap](https://trello.com/b/3seomsrI/lionagi)
+
+# LION Framework
+### Language InterOperable Network - The Future of Controlled AI Operations
+
+> Harness the power of next-generation AI while maintaining complete control and reliability.
+
+## Why LION?
+
+The AI revolution is transforming how we work - but with great power comes great responsibility. LION provides the control mechanisms and reliability features needed to safely integrate advanced AI capabilities into enterprise workflows.
+
+LION is designed to be:
+- 🔒 **Controlled**: Built-in safety mechanisms and verification
+- 🎯 **Precise**: Exact control over AI behaviors
+- 🔧 **Flexible**: Build any workflow you need
+- 🚀 **Efficient**: Minimal dependencies, maximum performance
+
+## Quick Start
+
+```python
+from lionagi import Branch, iModel
+
+# Initialize model
+gpt4o = iModel(provider="openai", model="gpt-4o")
+
+# Create a branch with personality
+comedian = Branch(
+    system="you are a sarcastic dragon hunter",
+    imodel=gpt4o
+)
+
+# Chat asynchronously
+response = await branch.chat(
+    "tell me a joke on knight vs dragon"
+)
+```
+
+## Installation
+
+LION maintains minimal dependencies for maximum reliability:
+
+```bash
+pip install lionagi
+```
+
+Dependencies:
+- aiocache
+- lion-core
+- python-dotenv
+- IPython
+
+## 🌟 Example Workflow
+
+Below is an example of what you can build with LION. Note that these are sample implementations - LION provides the building blocks, you create the workflows that fit your needs.
+
+```mermaid
+sequenceDiagram
+    autonumber
+    participant Client
+    participant Orchestrator
+    participant ResearchAgent
+    participant AnalysisAgent
+    participant ValidationAgent
+    participant Tools
+
+    Client->>+Orchestrator: Submit Complex Task
+    Note over Orchestrator: Task Analysis & Planning
+
+    %% Research Phase
+    Orchestrator->>+ResearchAgent: Delegate Research
+    activate ResearchAgent
+    ResearchAgent->>Tools: Access Data Sources
+    Tools-->>ResearchAgent: Raw Data
+    ResearchAgent-->>-Orchestrator: Research Results
+    deactivate ResearchAgent
+
+    %% Analysis Phase
+    Orchestrator->>+AnalysisAgent: Process Data
+    activate AnalysisAgent
+    AnalysisAgent->>Tools: Apply Models
+    Tools-->>AnalysisAgent: Analysis Results
+    AnalysisAgent-->>-Orchestrator: Processed Insights
+    deactivate AnalysisAgent
+
+    %% Validation Phase
+    Orchestrator->>+ValidationAgent: Verify Results
+    activate ValidationAgent
+    ValidationAgent->>Tools: Apply Safety Checks
+    Tools-->>ValidationAgent: Validation Status
+    ValidationAgent-->>-Orchestrator: Verified Results
+    deactivate ValidationAgent
+
+    Orchestrator-->>-Client: Return Validated Output
+```
+
+## 🏗️ System Architecture
+
+Here's how you can structure your LION-powered system. Each component can be customized to your specific needs.
+
+```mermaid
+graph TB
+    subgraph Client Layer
+        CL[Client Application]
+    end
+
+    subgraph Orchestration Layer
+        ORC[Orchestrator]
+        SEC[Security Controls]
+        MON[Monitoring]
+    end
+
+    subgraph Agent Layer
+        subgraph Specialized Agents
+            RA[Research Agent]
+            AA[Analysis Agent]
+            VA[Validation Agent]
+        end
+
+        subgraph Agent Controls
+            AC[Access Control]
+            AM[Action Monitor]
+            VE[Verification]
+        end
+    end
+
+    subgraph Resource Layer
+        subgraph Tool Management
+            TM[Tool Registry]
+            TP[Tool Policies]
+        end
+
+        subgraph Data Sources
+            DS[Data Access]
+            DV[Data Validation]
+        end
+    end
+
+    %% Connections
+    CL --> ORC
+    ORC --> RA & AA & VA
+    RA & AA & VA --> AC
+    AC --> TM
+    TM --> DS
+
+    %% Control Flow
+    ORC --> SEC
+    SEC --> MON
+    MON --> AM
+    AM --> VE
+    VE --> TP
+    TP --> DV
+
+    classDef primary fill:#1e40af,stroke:#1e3a8a,color:#fff
+    classDef secondary fill:#3b82f6,stroke:#2563eb,color:#fff
+    classDef control fill:#7c3aed,stroke:#6d28d9,color:#fff
+```
+
+## 🛠️ Building Blocks
+
+LION provides the essential components you need to build reliable AI workflows:
+
+- **Branch**: Core conversation unit with built-in safety mechanisms
+- **iModel**: Standardized interface to AI models
+- **Tools**: Framework for safe tool integration
+- **Exchange**: Reliable message passing between components
+
+Each component is designed to be:
+- Fully customizable to your needs
+- Safe by default
+- Easy to integrate
+- Highly reliable
+
+## 🎯 Key Use Cases
+
+- **Enterprise Operations**
+  - Complex workflow automation
+  - Data analysis and processing
+  - Decision support systems
+
+- **AI Integration**
+  - Controlled model deployment
+  - Safe tool usage
+  - Reliable agent operations
+
+- **Development**
+  - Rapid prototyping
+  - System integration
+  - Workflow optimization
+
+## 🔒 Built for Reliability
+
+LION isn't just another framework - it's your partner in responsible AI adoption. Build enterprise-grade AI systems with:
+
+- Complete control over AI behaviors
+- Comprehensive audit trails
+- Built-in safety mechanisms
+- Minimal dependencies
+- Maximum reliability
+
+## 🤝 Contributing
+
+Join our [Discord community](https://discord.gg/aqSJ2v46vu) to:
+- Share ideas
+- Report issues
+- Contribute code
+- Learn from others
+
+## 📚 Citation
+
+```bibtex
+@software{Li_LionAGI_2023,
+  author = {Haiyang Li},
+  month = {12},
+  year = {2023},
+  title = {LionAGI: Intelligent Integration Framework},
+  url = {https://github.com/lion-agi/lionagi},
+}
+```
+

lionagi-0.3.8/README.md

@@ -0,0 +1,223 @@
+![PyPI - Version](https://img.shields.io/pypi/v/lionagi?labelColor=233476aa&color=231fc935)
+![PyPI - Downloads](https://img.shields.io/pypi/dm/lionagi?color=blue)
+![Dependencies](https://img.shields.io/badge/dependencies-4-brightgreen)
+![Python Version](https://img.shields.io/badge/python-3.10%2B-blue)
+
+[Documentation](https://ocean-lion.com/Welcome) | [Discord](https://discord.gg/aqSJ2v46vu) | [PyPI](https://pypi.org/project/lionagi/) | [Roadmap](https://trello.com/b/3seomsrI/lionagi)
+
+# LION Framework
+### Language InterOperable Network - The Future of Controlled AI Operations
+
+> Harness the power of next-generation AI while maintaining complete control and reliability.
+
+## Why LION?
+
+The AI revolution is transforming how we work - but with great power comes great responsibility. LION provides the control mechanisms and reliability features needed to safely integrate advanced AI capabilities into enterprise workflows.
+
+LION is designed to be:
+- 🔒 **Controlled**: Built-in safety mechanisms and verification
+- 🎯 **Precise**: Exact control over AI behaviors
+- 🔧 **Flexible**: Build any workflow you need
+- 🚀 **Efficient**: Minimal dependencies, maximum performance
+
+## Quick Start
+
+```python
+from lionagi import Branch, iModel
+
+# Initialize model
+gpt4o = iModel(provider="openai", model="gpt-4o")
+
+# Create a branch with personality
+comedian = Branch(
+    system="you are a sarcastic dragon hunter",
+    imodel=gpt4o
+)
+
+# Chat asynchronously
+response = await branch.chat(
+    "tell me a joke on knight vs dragon"
+)
+```
+
+## Installation
+
+LION maintains minimal dependencies for maximum reliability:
+
+```bash
+pip install lionagi
+```
+
+Dependencies:
+- aiocache
+- lion-core
+- python-dotenv
+- IPython
+
+## 🌟 Example Workflow
+
+Below is an example of what you can build with LION. Note that these are sample implementations - LION provides the building blocks, you create the workflows that fit your needs.
+
+```mermaid
+sequenceDiagram
+    autonumber
+    participant Client
+    participant Orchestrator
+    participant ResearchAgent
+    participant AnalysisAgent
+    participant ValidationAgent
+    participant Tools
+
+    Client->>+Orchestrator: Submit Complex Task
+    Note over Orchestrator: Task Analysis & Planning
+
+    %% Research Phase
+    Orchestrator->>+ResearchAgent: Delegate Research
+    activate ResearchAgent
+    ResearchAgent->>Tools: Access Data Sources
+    Tools-->>ResearchAgent: Raw Data
+    ResearchAgent-->>-Orchestrator: Research Results
+    deactivate ResearchAgent
+
+    %% Analysis Phase
+    Orchestrator->>+AnalysisAgent: Process Data
+    activate AnalysisAgent
+    AnalysisAgent->>Tools: Apply Models
+    Tools-->>AnalysisAgent: Analysis Results
+    AnalysisAgent-->>-Orchestrator: Processed Insights
+    deactivate AnalysisAgent
+
+    %% Validation Phase
+    Orchestrator->>+ValidationAgent: Verify Results
+    activate ValidationAgent
+    ValidationAgent->>Tools: Apply Safety Checks
+    Tools-->>ValidationAgent: Validation Status
+    ValidationAgent-->>-Orchestrator: Verified Results
+    deactivate ValidationAgent
+
+    Orchestrator-->>-Client: Return Validated Output
+```
+
+## 🏗️ System Architecture
+
+Here's how you can structure your LION-powered system. Each component can be customized to your specific needs.
+
+```mermaid
+graph TB
+    subgraph Client Layer
+        CL[Client Application]
+    end
+
+    subgraph Orchestration Layer
+        ORC[Orchestrator]
+        SEC[Security Controls]
+        MON[Monitoring]
+    end
+
+    subgraph Agent Layer
+        subgraph Specialized Agents
+            RA[Research Agent]
+            AA[Analysis Agent]
+            VA[Validation Agent]
+        end
+
+        subgraph Agent Controls
+            AC[Access Control]
+            AM[Action Monitor]
+            VE[Verification]
+        end
+    end
+
+    subgraph Resource Layer
+        subgraph Tool Management
+            TM[Tool Registry]
+            TP[Tool Policies]
+        end
+
+        subgraph Data Sources
+            DS[Data Access]
+            DV[Data Validation]
+        end
+    end
+
+    %% Connections
+    CL --> ORC
+    ORC --> RA & AA & VA
+    RA & AA & VA --> AC
+    AC --> TM
+    TM --> DS
+
+    %% Control Flow
+    ORC --> SEC
+    SEC --> MON
+    MON --> AM
+    AM --> VE
+    VE --> TP
+    TP --> DV
+
+    classDef primary fill:#1e40af,stroke:#1e3a8a,color:#fff
+    classDef secondary fill:#3b82f6,stroke:#2563eb,color:#fff
+    classDef control fill:#7c3aed,stroke:#6d28d9,color:#fff
+```
+
+## 🛠️ Building Blocks
+
+LION provides the essential components you need to build reliable AI workflows:
+
+- **Branch**: Core conversation unit with built-in safety mechanisms
+- **iModel**: Standardized interface to AI models
+- **Tools**: Framework for safe tool integration
+- **Exchange**: Reliable message passing between components
+
+Each component is designed to be:
+- Fully customizable to your needs
+- Safe by default
+- Easy to integrate
+- Highly reliable
+
+## 🎯 Key Use Cases
+
+- **Enterprise Operations**
+  - Complex workflow automation
+  - Data analysis and processing
+  - Decision support systems
+
+- **AI Integration**
+  - Controlled model deployment
+  - Safe tool usage
+  - Reliable agent operations
+
+- **Development**
+  - Rapid prototyping
+  - System integration
+  - Workflow optimization
+
+## 🔒 Built for Reliability
+
+LION isn't just another framework - it's your partner in responsible AI adoption. Build enterprise-grade AI systems with:
+
+- Complete control over AI behaviors
+- Comprehensive audit trails
+- Built-in safety mechanisms
+- Minimal dependencies
+- Maximum reliability
+
+## 🤝 Contributing
+
+Join our [Discord community](https://discord.gg/aqSJ2v46vu) to:
+- Share ideas
+- Report issues
+- Contribute code
+- Learn from others
+
+## 📚 Citation
+
+```bibtex
+@software{Li_LionAGI_2023,
+  author = {Haiyang Li},
+  month = {12},
+  year = {2023},
+  title = {LionAGI: Intelligent Integration Framework},
+  url = {https://github.com/lion-agi/lionagi},
+}
+```

{lionagi-0.3.6 → lionagi-0.3.8}/lionagi/core/collections/abc/component.py

@@ -1,11 +1,11 @@
 """Component class, base building block in LionAGI."""
 
 import contextlib
-from abc import ABC
-from collections.abc import Sequence
 from functools import singledispatchmethod
-from typing import Any, Type, TypeAlias, TypeVar, Union
+from typing import Any, TypeAlias, TypeVar, Union
 
+import lionfuncs as ln
+from lionabc import Observable
 from pandas import DataFrame, Series
 from pydantic import AliasChoices, BaseModel, Field, ValidationError
 
@@ -22,7 +22,13 @@ T = TypeVar("T")
 _init_class = {}
 
 
-class Element(BaseModel, ABC):
+def change_dict_key(dict_: dict, old_key: str, new_key: str) -> None:
+    """Change a key in a dictionary."""
+    if old_key in dict_:
+        dict_[new_key] = dict_.pop(old_key)
+
+
+class Element(BaseModel, Observable):
     """Base class for elements within the LionAGI system.
 
     Attributes:
@@ -31,15 +37,14 @@ class Element(BaseModel, ABC):
     """
 
     ln_id: str = Field(
-        default_factory=SysUtil.create_id,
+        default_factory=SysUtil.id,
         title="ID",
-        description="A 32-char unique hash identifier.",
         frozen=True,
         validation_alias=AliasChoices("node_id", "ID", "id"),
     )
 
     timestamp: str = Field(
-        default_factory=lambda: SysUtil.get_timestamp(sep=None)[:-6],
+        default_factory=lambda: ln.time(type_="iso"),
         title="Creation Timestamp",
         description="The UTC timestamp of creation",
         frozen=True,
@@ -57,7 +62,7 @@ class Element(BaseModel, ABC):
         return True
 
 
-class Component(Element, ABC):
+class Component(Element):
     """
     Represents a distinguishable, temporal entity in LionAGI.
 
@@ -195,17 +200,15 @@ class Component(Element, ABC):
         """Create a Component instance from a LlamaIndex object."""
         dict_ = obj.to_dict()
 
-        SysUtil.change_dict_key(dict_, "text", "content")
+        change_dict_key(dict_, "text", "content")
         metadata = dict_.pop("metadata", {})
 
         for field in llama_meta_fields:
             metadata[field] = dict_.pop(field, None)
 
-        SysUtil.change_dict_key(metadata, "class_name", "llama_index_class")
-        SysUtil.change_dict_key(metadata, "id_", "llama_index_id")
-        SysUtil.change_dict_key(
-            metadata, "relationships", "llama_index_relationships"
-        )
+        change_dict_key(metadata, "class_name", "llama_index_class")
+        change_dict_key(metadata, "id_", "llama_index_id")
+        change_dict_key(metadata, "relationships", "llama_index_relationships")
 
         dict_["metadata"] = metadata
         return cls.from_obj(dict_)
@@ -244,7 +247,7 @@ class Component(Element, ABC):
     @classmethod
     def _process_langchain_dict(cls, dict_: dict) -> dict:
         """Process a dictionary containing Langchain-specific data."""
-        SysUtil.change_dict_key(dict_, "page_content", "content")
+        change_dict_key(dict_, "page_content", "content")
 
         metadata = dict_.pop("metadata", {})
         metadata.update(dict_.pop("kwargs", {}))
@@ -264,9 +267,9 @@ class Component(Element, ABC):
             if field in dict_:
                 metadata[field] = dict_.pop(field)
 
-        SysUtil.change_dict_key(metadata, "lc", "langchain")
-        SysUtil.change_dict_key(metadata, "type", "lc_type")
-        SysUtil.change_dict_key(metadata, "id", "lc_id")
+        change_dict_key(metadata, "lc", "langchain")
+        change_dict_key(metadata, "type", "lc_type")
+        change_dict_key(metadata, "id", "lc_id")
 
         extra_fields = {
             k: v for k, v in metadata.items() if k not in lc_meta_fields
@@ -298,9 +301,9 @@ class Component(Element, ABC):
         dict_["metadata"] = meta_
 
         if "ln_id" not in dict_:
-            dict_["ln_id"] = meta_.pop("ln_id", SysUtil.create_id())
+            dict_["ln_id"] = meta_.pop("ln_id", SysUtil.id())
         if "timestamp" not in dict_:
-            dict_["timestamp"] = SysUtil.get_timestamp(sep=None)[:-6]
+            dict_["timestamp"] = ln.time(type_="iso")
         if "metadata" not in dict_:
             dict_["metadata"] = {}
         if "extra_fields" not in dict_:
@@ -453,13 +456,13 @@ class Component(Element, ABC):
             ninsert(
                 self.metadata,
                 ["last_updated", name],
-                SysUtil.get_timestamp(sep=None)[:-6],
+                ln.time(type_="iso")[:-6],
             )
         elif isinstance(a, tuple) and isinstance(a[0], int):
             nset(
                 self.metadata,
                 ["last_updated", name],
-                SysUtil.get_timestamp(sep=None)[:-6],
+                ln.time(type_="iso")[:-6],
             )
 
     def _meta_pop(self, indices, default=...):
@@ -614,10 +617,4 @@ LionIDable: TypeAlias = Union[str, Element]
 
 def get_lion_id(item: LionIDable) -> str:
     """Get the Lion ID of an item."""
-    if isinstance(item, Sequence) and len(item) == 1:
-        item = item[0]
-    if isinstance(item, str) and len(item) == 32:
-        return item
-    if getattr(item, "ln_id", None) is not None:
-        return item.ln_id
-    raise LionTypeError("Item must be a single LionIDable object.")
+    return SysUtil.get_id(item)

{lionagi-0.3.6 → lionagi-0.3.8}/lionagi/core/collections/abc/concepts.py

@@ -227,12 +227,6 @@ class Sendable(BaseModel, ABC):
             return value
 
         a = get_lion_id(value)
-        if not isinstance(a, str) or len(a) != 32:
-            raise LionTypeError(
-                "Invalid sender or recipient value. "
-                "Expected a valid node id or one of "
-                "'system' or 'user'."
-            )
         return a
 
 

{lionagi-0.3.6 → lionagi-0.3.8}/lionagi/core/collections/flow.py

@@ -1,7 +1,6 @@
 import contextlib
 from collections import deque
 from collections.abc import Mapping
-from typing import Tuple
 
 from pydantic import Field
 

{lionagi-0.3.6 → lionagi-0.3.8}/lionagi/core/collections/model.py

@@ -1,6 +1,7 @@
 import asyncio
 import os
 
+import lionfuncs as ln
 import numpy as np
 from dotenv import load_dotenv
 
@@ -91,8 +92,8 @@ class iModel:
             service (BaseService, optional): An instance of BaseService.
             **kwargs: Additional parameters for the model.
         """
-        self.ln_id: str = SysUtil.create_id()
-        self.timestamp: str = SysUtil.get_timestamp(sep=None)[:-6]
+        self.ln_id: str = SysUtil.id()
+        self.timestamp: str = ln.time(type_="iso")
         self.endpoint = endpoint
         self.allowed_parameters = allowed_parameters
         if isinstance(provider, type):

{lionagi-0.3.6 → lionagi-0.3.8}/lionagi/core/collections/pile.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import asyncio
 from collections.abc import AsyncIterator, Callable, Iterable
 from functools import wraps
-from typing import Any, Generic, Type, TypeVar
+from typing import Any, Generic, TypeVar
 
 from pydantic import Field, field_validator
 

{lionagi-0.3.6 → lionagi-0.3.8}/lionagi/core/collections/progression.py

@@ -1,9 +1,8 @@
 import contextlib
 
+import lionfuncs as ln
 from pydantic import Field, field_validator
 
-from lionagi.libs import SysUtil
-
 from .abc import Element, ItemNotFoundError, LionIDable, Ordering, get_lion_id
 from .util import _validate_order
 
@@ -90,7 +89,7 @@ class Progression(Element, Ordering):
         """Remove the next occurrence of an item from the progression."""
         if item in self:
             item = self._validate_order(item)
-            l_ = SysUtil.create_copy(self.order)
+            l_ = ln.copy(self.order)
 
             with contextlib.suppress(Exception):
                 for i in item:
@@ -143,7 +142,7 @@ class Progression(Element, Ordering):
     def __radd__(self, other):
         if not isinstance(other, Progression):
             _copy = self.copy()
-            l_ = SysUtil.create_copy(_copy.order)
+            l_ = ln.copy(_copy.order)
             l_.insert(0, get_lion_id(other))
             _copy.order = l_
             return _copy
@@ -190,7 +189,7 @@ class Progression(Element, Ordering):
 
     def __list__(self):
         """Return a list representation of the progression."""
-        return SysUtil.create_copy(self.order)
+        return ln.copy(self.order)
 
     def __reversed__(self):
         """Return a reversed progression."""

lionagi-0.3.8/lionagi/core/director/operations/select.py

@@ -0,0 +1,3 @@
+from lionagi.operations.select import select
+
+__all__ = ["select"]