lionagi 0.2.6__tar.gz → 0.2.8__tar.gz

lionagi-0.2.8/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.1
+Name: lionagi
+Version: 0.2.8
+Summary: Towards automated general intelligence.
+Author: HaiyangLi
+Author-email: quantocean.li@gmail.com
+Requires-Python: >=3.12,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: aiocache (>=0.12.3,<0.13.0)
+Requires-Dist: ipython (>=8.27.0,<9.0.0)
+Requires-Dist: lion-openai (>=0.1.4,<0.2.0)
+Requires-Dist: lionfuncs (==1.0.1)
+Requires-Dist: pandas (>=2.2.3,<3.0.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)
+
+
+[PyPI](https://pypi.org/project/lionagi/) | [Documentation](https://ocean-lion.com/Welcome) | [Discord](https://discord.gg/aqSJ2v46vu) | [Roadmap](https://trello.com/b/3seomsrI/lionagi)
+
+
+# Language InterOperable Network - LION
+### an AGentic Intelligence Operating System
+
+```
+pip install lionagi==0.2.7
+```
+
+**Powerful Intelligent Workflow Automation**
+
+lionagi is an intelligent agentic workflow automation framework. It introduces advanced ML models into any existing workflows and data infrastructure.
+
+
+### Why Automating Workflows?
+
+Intelligent AI models such as [Large Language Model (LLM)](https://en.wikipedia.org/wiki/Large_language_model), introduced new possibilities of human-computer interaction. LLMs is drawing a lot of attention worldwide due to its “one model fits all”, and incredible performance. One way of using LLM is to use as search engine, however, this usage is complicated by the fact that LLMs [hallucinate](https://arxiv.org/abs/2311.05232).
+
+What goes inside of a LLM is more akin to a [black-box](https://pauldeepakraj-r.medium.com/demystifying-the-black-box-a-deep-dive-into-llm-interpretability-971524966fdf), lacking interpretability, meaning we don’t know how it reaches certain answer or conclusion, thus we cannot fully trust/rely the output from such a system. Another approach of using LLM is to treat them as [intelligent agent](https://arxiv.org/html/2401.03428v1), that are equipped with various tools and data sources. A workflow conducted by such an intelligent agent have clear steps, and we can specify, observe, evaluate and optimize the logic for each decision that the `agent` made to perform actions. This approach, though we still cannot pinpoint how LLM output what it outputs, but the flow itself is **explainable**.
+
+
+
+### Community
+
+We encourage contributions to LionAGI and invite you to enrich its features and capabilities. Engage with us and other community members [Join Our Discord](https://discord.gg/aqSJ2v46vu)
+
+### Citation
+
+When referencing LionAGI in your projects or research, please cite:
+
+```bibtex
+@software{Li_LionAGI_2023,
+  author = {Haiyang Li},
+  month = {12},
+  year = {2023},
+  title = {LionAGI: Towards Automated General Intelligence},
+  url = {https://github.com/lion-agi/lionagi},
+}
+```
+
+
+### Requirements
+Python 3.10 or higher. 
+
+

{lionagi-0.2.6 → lionagi-0.2.8}/README.md

@@ -8,7 +8,7 @@
 ### an AGentic Intelligence Operating System
 
 ```
-pip install lionagi==0.2.5
+pip install lionagi==0.2.7
 ```
 
 **Powerful Intelligent Workflow Automation**

{lionagi-0.2.6 → lionagi-0.2.8}/lionagi/__init__.py

@@ -1,38 +1,24 @@
-"""
-Copyright 2024 HaiyangLi
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-"""
-
 import logging
-from .version import __version__
+
 from dotenv import load_dotenv
 
-from lionagi.libs.ln_convert import to_list, to_dict, to_df, to_readable_dict
-from lionagi.libs.ln_func_call import alcall, bcall, lcall, CallDecorator as cd, tcall
-from lionagi.core.collections.abc import Field
-from lionagi.core.collections import progression, flow, pile, iModel
-from lionagi.core.generic import Node, Graph, Tree, Edge
+import lionagi.core.director.direct as direct
 from lionagi.core.action import func_to_tool
+from lionagi.core.collections import flow, iModel, pile, progression
+from lionagi.core.collections.abc import Field
+from lionagi.core.generic import Edge, Graph, Node, Tree
 from lionagi.core.report import Form, Report
 from lionagi.core.session.branch import Branch
 from lionagi.core.session.session import Session
-from lionagi.core.work.worker import work, Worker, worklink
-from lionagi.integrations.provider.services import Services
+from lionagi.core.work.worker import Worker, work, worklink
 from lionagi.integrations.chunker.chunk import chunk
 from lionagi.integrations.loader.load import load
-import lionagi.core.director.direct as direct
+from lionagi.integrations.provider.services import Services
+from lionagi.libs.ln_convert import to_df, to_dict, to_list, to_readable_dict
+from lionagi.libs.ln_func_call import CallDecorator as cd
+from lionagi.libs.ln_func_call import alcall, bcall, lcall, tcall
 
+from .version import __version__
 
 __all__ = [
     "Field",

lionagi-0.2.8/lionagi/core/action/README.md

@@ -0,0 +1,20 @@
+# Action Folder
+
+The `action` folder contains various modules designed to facilitate dynamic function invocation and tool management within the system. Each module provides specific functionalities, which are briefly described below:
+
+## Modules
+
+### function_calling.py
+This module defines the `FunctionCalling` class, which supports dynamic invocation of functions based on different input types such as tuples, dictionaries, `ActionRequest` objects, or JSON strings. It enables seamless function calls by creating instances based on the provided input format and invoking the corresponding functions asynchronously.
+
+### tool_manager.py
+The `ToolManager` class is defined in this module. It manages tools in the system, allowing for the registration, invocation, and retrieval of tool schemas. Tools can be registered individually or in batches and invoked using various input formats including function names, JSON strings, or specialized objects like `FunctionCalling`.
+
+### tool.py
+This module contains the `Tool` class, representing a tool with capabilities for pre-processing, post-processing, and parsing function results. It allows for the definition of callable functions, optional pre-processors, post-processors, and parsers to handle function results. The `Tool` class ensures flexible and reusable tool definitions within the system.
+
+## Usage Guide
+
+- **function_calling.py**: Use this module when you need to dynamically invoke functions based on varying input formats. It simplifies function calls by creating a standardized interface for different types of function descriptions.
+- **tool_manager.py**: Utilize the `ToolManager` class to manage your system's tools. It provides methods for registering tools, invoking them, and retrieving their schemas, making it a central point for tool management.
+- **tool.py**: Define individual tools using the `Tool` class, specifying any necessary pre-processing or post-processing steps. This module is essential for creating robust and flexible tools that can be easily integrated into the system.

{lionagi-0.2.6 → lionagi-0.2.8}/lionagi/core/action/__init__.py

@@ -1,8 +1,7 @@
 from .function_calling import FunctionCalling
+from .node import ActionNode, DirectiveSelection
 from .tool import Tool
 from .tool_manager import ToolManager, func_to_tool
-from .node import ActionNode, DirectiveSelection
-
 
 __all__ = [
     "FunctionCalling",

{lionagi-0.2.6 → lionagi-0.2.8}/lionagi/core/action/function_calling.py

@@ -1,35 +1,10 @@
-"""
-Copyright 2024 HaiyangLi
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-"""
-
-"""
-This module defines the FunctionCalling class, which facilitates dynamic
-invocation of functions based on various input types. It supports initializing
-function calls from tuples, dictionaries, ActionRequest objects, or JSON strings.
-
-Note:
-    Function Calling object is the only way for AI system to call functions.
-"""
-
 from functools import singledispatchmethod
 from typing import Any, Callable, Dict
 
-from lionagi.libs import ParseUtil
-from lionagi.libs.ln_func_call import call_handler
 from lionagi.core.collections.abc import Actionable
 from lionagi.core.message.action_request import ActionRequest
+from lionagi.libs import ParseUtil
+from lionagi.libs.ln_func_call import call_handler
 
 
 class FunctionCalling(Actionable):

{lionagi-0.2.6 → lionagi-0.2.8}/lionagi/core/action/node.py

@@ -1,23 +1,8 @@
-"""
-Copyright 2024 HaiyangLi
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-"""
-
 from pydantic import Field
 
 from lionagi.core.collections.abc import Actionable
 from lionagi.core.generic.node import Node
+
 from .tool import Tool
 
 

{lionagi-0.2.6 → lionagi-0.2.8}/lionagi/core/action/tool.py

@@ -1,24 +1,11 @@
-"""
-Copyright 2024 HaiyangLi
+from typing import Any, Callable, Dict, List, Union
 
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-"""
-
-from typing import Callable, Union, List, Dict, Any
 from pydantic import Field, field_serializer
-from lionagi.libs.ln_func_call import call_handler
+
 from lionagi.core.collections.abc import Actionable
 from lionagi.core.generic.node import Node
+from lionagi.libs.ln_func_call import call_handler
+
 from .function_calling import FunctionCalling
 
 

{lionagi-0.2.6 → lionagi-0.2.8}/lionagi/core/action/tool_manager.py

@@ -1,35 +1,12 @@
-"""
-Copyright 2024 HaiyangLi
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-"""
-
-"""
-This module contains the ToolManager class, which manages tools in the system.
-It allows registering, invoking, and retrieving schemas of tools. Tools can be
-registered individually or in batches, and invoked using function names, JSON
-strings, or specialized objects.
-"""
-
 import inspect
 from functools import singledispatchmethod
-from typing import Any, Callable, List, Union, Tuple
-from lionagi.libs import ParseUtil
-from lionagi.libs.ln_convert import to_list, to_dict
-from lionagi.libs.ln_func_call import lcall
-from lionagi.core.collections.abc import Actionable
+from typing import Any, Callable, List, Tuple, Union
+
+from lionfuncs import function_to_schema, lcall, to_dict, to_list
+
 from lionagi.core.action.function_calling import FunctionCalling
-from lionagi.core.action.tool import Tool, TOOL_TYPE
+from lionagi.core.action.tool import TOOL_TYPE, Tool
+from lionagi.core.collections.abc import Actionable
 
 
 class ToolManager(Actionable):
@@ -336,7 +313,7 @@ def func_to_tool(
         for idx in range(len(funcs)):
             f_ = lambda _f: Tool(
                 function=_f,
-                schema_=ParseUtil._func_to_schema(_f, style=docstring_style),
+                schema_=function_to_schema(_f, style=docstring_style),
                 parser=parsers[idx] if len(parsers) > 1 else parsers[0],
                 **kwargs,
             )
@@ -348,7 +325,7 @@ def func_to_tool(
             funcs,
             lambda _f: Tool(
                 function=_f,
-                schema_=ParseUtil._func_to_schema(_f, style=docstring_style),
+                schema_=function_to_schema(_f, style=docstring_style),
                 **kwargs,
             ),
         )

lionagi-0.2.8/lionagi/core/agent/README.md

@@ -0,0 +1 @@
+agent as worker with structured executor

{lionagi-0.2.6 → lionagi-0.2.8}/lionagi/core/agent/base_agent.py

@@ -1,34 +1,10 @@
-"""
-Copyright 2024 HaiyangLi
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-"""
-
-"""
-This module contains the BaseAgent class, which serves as a base class for agents.
-"""
-
-from pydantic import Field
 from typing import Any, Callable
 
-from lionagi.libs import func_call, AsyncUtil
-
-
-from lionagi.core.mail.start_mail import StartMail
+from lionagi.core.executor.base_executor import BaseExecutor
 from lionagi.core.generic.node import Node
 from lionagi.core.mail.mail_manager import MailManager
-from lionagi.core.executor.base_executor import BaseExecutor
-from lionagi.core.executor.graph_executor import GraphExecutor
+from lionagi.core.mail.start_mail import StartMail
+from lionagi.libs import AsyncUtil, func_call
 
 
 class BaseAgent(Node):

lionagi-0.2.8/lionagi/core/agent/eval/README.md

@@ -0,0 +1 @@
+TODO

lionagi-0.2.8/lionagi/core/collections/README.md

@@ -0,0 +1,23 @@
+# LionAGI Core Collections
+
+The `lionagi.core.collections` module provides essential data structures and abstractions for managing collections, sequences, and flows of items within the LionAGI system. These components form the foundation for efficient storage, access, and manipulation of data in AI-driven applications.
+
+## Pile
+
+`Pile` is a versatile container for managing collections of `Element` objects. It offers ordered and type-validated storage, flexible key access, item retrieval and assignment, inclusion and exclusion operations, homogeneity checks, iteration, and arithmetic operations. `Pile` also supports insertion, appending, and conversion to DataFrame for easy data analysis.
+
+## Progression
+
+`Progression` represents a sequence of items with a specific order. It provides methods for managing and manipulating the order of items, including inclusion and exclusion, item retrieval and removal, appending, extending, copying, and clearing. `Progression` supports arithmetic operations for adding and subtracting items or progressions, and offers length and iteration capabilities.
+
+## Flow
+
+`Flow` represents a flow of categorical sequences, allowing for the organization and management of multiple `Progression` sequences within a single structure. It provides sequence storage, a registry for sequence lookup by name, a default sequence concept, sequence retrieval and appending, registration, item removal, and iteration over sequences. `Flow` makes it convenient to work with related sequences and perform operations across multiple sequences.
+
+## Exchange
+
+`Exchange` is designed to handle incoming and outgoing flows of items. It uses a `Pile` to store pending items and maintains separate collections for pending incoming and outgoing items. `Exchange` provides methods for including and excluding items based on their direction (incoming or outgoing), facilitating efficient item exchange processing.
+
+These core collections work together to provide a robust and flexible framework for managing data within the LionAGI system. They offer powerful capabilities for storing, accessing, and manipulating collections, sequences, and flows of items, enabling developers to build efficient and organized AI-driven applications.
+
+For detailed usage examples and advanced features, please refer to the individual component documentation and upcoming tutorials.

{lionagi-0.2.6 → lionagi-0.2.8}/lionagi/core/collections/__init__.py

@@ -1,9 +1,8 @@
+from .exchange import Exchange
+from .flow import Flow, flow
 from .model import iModel
 from .pile import Pile, pile
 from .progression import Progression, progression
-from .flow import Flow, flow
-from .exchange import Exchange
-
 
 __all__ = [
     "iModel",

{lionagi-0.2.6 → lionagi-0.2.8}/lionagi/core/collections/_logger.py

@@ -1,19 +1,3 @@
-"""
-Copyright 2024 HaiyangLi
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-"""
-
 import atexit
 import contextlib
 import logging
@@ -24,7 +8,6 @@ from typing import Any, Dict, List
 
 from lionagi.libs import SysUtil, convert, nested
 
-
 # TODO: there should be a global data logger, under setting
 
 

lionagi-0.2.8/lionagi/core/collections/abc/README.md

@@ -0,0 +1,63 @@
+# Core Components and Abstractions
+
+The `lionagi.core.collections.abc` module provides essential building blocks and abstractions for constructing the LionAGI system. These components establish a solid foundation for managing data, relationships, and behaviors within the system's architecture. ^1
+
+## Component
+
+The `Component` class, located in `lionagi.core.collections.abc`, serves as a fundamental building block within the LionAGI system architecture. As a subclass of both `Element` and `ABC` (Abstract Base Class), it encapsulates the essential attributes and behaviors required for individual components to function within the larger system.
+
+### Key Attributes
+- **ln_id**: A unique 32-character identifier assigned to each component instance.
+- **timestamp**: The UTC timestamp indicating when the component was created.
+- **metadata**: A container for additional metadata associated with the component.
+- **extra_fields**: Customizable fields that can be added to each component as needed.
+- **content**: The primary data or functionality encapsulated by the component.
+
+### Key Methods
+- **Type Conversion**
+  - **from_obj()**: Accepts input in various formats, including dict, string, llamaindex, langchain, pydantic, pd.DataFrame, and pd.Series.
+  - **to**: Provides methods for converting the component to different representations, such as to_dict(), to_xml(), to_pd_series(), to_langchain_doc(), and to_llama_index_node().
+- **repr**: Returns a string representation of the component in `pd.Series` format.
+
+## Concepts
+
+The `concepts.py` file, located in `lionagi.core.collections.abc`, defines a set of abstract base classes that are essential for managing the fundamental behaviors and relationships within the LionAGI system. These classes establish a structured framework for handling collections, sequencing, conditions, actions, and other core concepts.
+
+### Key Classes
+1. **Record**: Manages a collection of unique items, offering a standardized interface for item retrieval, addition, and iteration.
+2. **Ordering**: Ensures a specific order is maintained when sequencing items.
+3. **Condition**: Represents conditions that can be evaluated asynchronously to determine their applicability to a given context.
+4. **Actionable**: Encapsulates actions that can be invoked asynchronously with arguments.
+5. **Progressable**: Manages processes that can progress forward asynchronously.
+6. **Relatable**: Establishes relationships between items based on provided arguments.
+7. **Sendable**: Defines message-like objects with sender and recipient fields, including validation.
+8. **Executable**: Represents objects that can be executed asynchronously.
+9. **Directive**: Encapsulates higher-level directives for directing operations asynchronously.
+
+These abstract classes form a consistent and extensible foundation for building complex, interactive components within the LionAGI system, promoting efficient and organized development practices.
+
+## Exceptions
+
+The `exceptions.py` file, found in `lionagi.core.collections.abc`, defines a comprehensive set of custom exceptions designed to handle various error conditions that may arise within the LionAGI system. These exceptions provide clear and specific error messages, facilitating easier debugging and error management. ^2
+
+### Key Exception Classes
+1. **LionAGIError**: The base class for all exceptions in the LionAGI system, providing a customizable generic error message.
+2. **LionValueError**: Raised for errors related to input values, ensuring that incorrect values are properly reported.
+3. **LionTypeError**: Raised for type mismatches or type checking errors, helping to enforce correct data types throughout the system.
+4. **LionItemError**: A base class for exceptions related to LionAGI items, including specific error messages for item-related issues.
+5. **ItemNotFoundError**: Raised when a specified item cannot be found within the system, indicating missing or incorrect item references.
+6. **ItemInvalidError**: Raised when an invalid item is used in an operation, ensuring operations are performed on valid items only.
+7. **FieldError**: Raised for errors in field validation, highlighting issues with specific data fields.
+8. **LionOperationError**: A base class for exceptions related to operational failures, providing a framework for more specific operational errors.
+9. **ConcurrencyError**: Raised for errors due to concurrency issues, ensuring that concurrent operations are properly managed.
+10. **RelationError**: Raised for errors in relation operations, indicating issues with node relationships.
+11. **ActionError**: Raised for errors in action operations, signaling problems with executing specified actions.
+12. **ResourceLimitExceededError**: Raised when a resource limit is exceeded, helping to manage and enforce system resource constraints.
+13. **TimeoutError**: Raised when an operation times out, ensuring that long-running operations are properly handled.
+14. **ServiceError**: Raised for errors in endpoint configuration, indicating issues with service availability or configuration.
+
+These exceptions contribute to a robust error handling mechanism within the LionAGI system, ensuring that errors are clearly reported and managed, ultimately aiding in maintaining the system's stability and reliability.
+
+^1: [Design Patterns: Elements of Reusable Object-Oriented Software](https://en.wikipedia.org/wiki/Design_Patterns)
+
+^2: [Python Exceptions: An Introduction](https://realpython.com/python-exceptions/)

{lionagi-0.2.6 → lionagi-0.2.8}/lionagi/core/collections/abc/__init__.py

@@ -1,31 +1,31 @@
 """abc: Abstract Base Classes for lionagi."""
 
 from pydantic import Field
-from .exceptions import (
-    LionTypeError,
-    LionValueError,
-    ItemNotFoundError,
-    FieldError,
-    LionOperationError,
-    RelationError,
-    ActionError,
-    ModelLimitExceededError,
-)
-from .component import Element, Component, LionIDable, get_lion_id
+
+from .component import Component, Element, LionIDable, get_lion_id
 from .concepts import (
-    Record,
-    Ordering,
-    Condition,
     Actionable,
-    Relatable,
+    Condition,
+    Directive,
+    Executable,
+    Ordering,
     Progressable,
+    Record,
+    Relatable,
     Sendable,
-    Executable,
-    Directive,
+)
+from .exceptions import (
+    ActionError,
+    FieldError,
+    ItemNotFoundError,
+    LionOperationError,
+    LionTypeError,
+    LionValueError,
+    ModelLimitExceededError,
+    RelationError,
 )
 from .util import SYSTEM_FIELDS
 
-
 __all__ = [
     "Element",
     "Record",

{lionagi-0.2.6 → lionagi-0.2.8}/lionagi/core/collections/abc/component.py

@@ -1,37 +1,21 @@
-"""
-Copyright 2024 HaiyangLi
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-"""
-
 """Component class, base building block in LionAGI."""
 
-from abc import ABC
 import contextlib
+from abc import ABC
 from collections.abc import Sequence
 from functools import singledispatchmethod
-from typing import Any, TypeVar, Type, TypeAlias, Union
+from typing import Any, Type, TypeAlias, TypeVar, Union
 
 from pandas import DataFrame, Series
-from pydantic import BaseModel, Field, ValidationError, AliasChoices
+from pydantic import AliasChoices, BaseModel, Field, ValidationError
 
 from lionagi.libs import ParseUtil, SysUtil
 from lionagi.libs.ln_convert import strip_lower, to_dict, to_str
 from lionagi.libs.ln_func_call import lcall
-from lionagi.libs.ln_nested import nget, nset, ninsert, flatten, unflatten
+from lionagi.libs.ln_nested import flatten, nget, ninsert, nset, unflatten
 
 from .exceptions import FieldError, LionTypeError, LionValueError
-from .util import base_lion_fields, llama_meta_fields, lc_meta_fields
+from .util import base_lion_fields, lc_meta_fields, llama_meta_fields
 
 T = TypeVar("T")
 

{lionagi-0.2.6 → lionagi-0.2.8}/lionagi/core/collections/abc/concepts.py

@@ -1,26 +1,10 @@
-"""
-Copyright 2024 HaiyangLi
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-"""
-
 """This module defines abstract base classes for LionAGI."""
 
 from abc import ABC, abstractmethod
 from collections.abc import Generator
 from typing import Any, Iterator, TypeVar
 
-from pydantic import Field, BaseModel, field_validator
+from pydantic import BaseModel, Field, field_validator
 
 from .component import LionIDable, get_lion_id
 from .exceptions import LionTypeError

{lionagi-0.2.6 → lionagi-0.2.8}/lionagi/core/collections/abc/exceptions.py

@@ -1,19 +1,3 @@
-"""
-Copyright 2024 HaiyangLi
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-"""
-
 # import logging
 
 # # Configure logging

{lionagi-0.2.6 → lionagi-0.2.8}/lionagi/core/collections/exchange.py

@@ -1,20 +1,5 @@
-"""
-Copyright 2024 HaiyangLi
+from typing import Generic, TypeVar
 
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-"""
-
-from typing import TypeVar, Generic
 from .abc import Element, Field, Sendable
 from .pile import Pile, pile
 from .progression import Progression, progression