lionagi 0.1.2__py3-none-any.whl → 0.2.1__py3-none-any.whl

lionagi/experimental/work2/tests.py

@@ -1,72 +0,0 @@
-from .schema import Work, WorkStatus
-from ..work.worklog import WorkLog
-from .work_function import WorkFunction
-
-import unittest
-from unittest.mock import AsyncMock, patch
-
-from lionagi.libs import func_call
-
-
-class TestWork(unittest.TestCase):
-    def setUp(self):
-        self.work = Work(form_id="123")
-
-    def test_initial_status(self):
-        """Test the initial status is set to PENDING."""
-        self.assertEqual(self.work.status, WorkStatus.PENDING)
-
-    def test_initial_deliverables(self):
-        """Test the initial deliverables are empty."""
-        self.assertEqual(self.work.deliverables, {})
-
-    def test_initial_dependencies(self):
-        """Test the initial dependencies are empty."""
-        self.assertEqual(self.work.dependencies, [])
-
-
-class TestWorkLog(unittest.TestCase):
-    def setUp(self):
-        self.work_log = WorkLog()
-        self.work = Work(form_id="123")
-        self.work_log.append(self.work)
-
-    def test_append_work(self):
-        """Test appending work adds to logs and pending queue."""
-        self.assertIn("123", self.work_log.logs)
-        self.assertIn("123", self.work_log.pending)
-
-    def test_get_by_status(self):
-        """Test retrieving works by status."""
-        result = self.work_log.get_by_status(WorkStatus.PENDING)
-        self.assertEqual(result, {"123": self.work})
-
-
-class TestWorkFunction(unittest.TestCase):
-    def setUp(self):
-        self.work_function = WorkFunction(function=AsyncMock(return_value="result"))
-        self.work = Work(form_id="123")
-        self.work_log = WorkLog()
-        self.work_log.append(self.work)
-        self.work_function.worklog = self.work_log
-
-    @patch("asyncio.sleep", new_callable=AsyncMock)
-    async def test_execute(self, mocked_sleep):
-        """Test executing work changes its status and handles results."""
-        with patch.object(func_call, "rcall", new_callable=AsyncMock) as mock_rcall:
-            mock_rcall.return_value = "completed"
-            await self.work_function.execute()
-            self.assertEqual(self.work.status, WorkStatus.COMPLETED)
-            self.assertNotIn("123", self.work_function.worklog.pending)
-
-    @patch("asyncio.sleep", new_callable=AsyncMock)
-    async def test_execute_failure(self, mocked_sleep):
-        """Test handling failure during work execution."""
-        with patch.object(func_call, "rcall", side_effect=Exception("Error")):
-            await self.work_function.execute()
-            self.assertEqual(self.work.status, WorkStatus.FAILED)
-            self.assertIn("123", self.work_function.worklog.errored)
-
-
-if __name__ == "__main__":
-    unittest.main()

lionagi/experimental/work2/work_function.py

@@ -1,89 +0,0 @@
-import asyncio
-from typing import Any, Callable, Dict, List
-from pydantic import Field
-from functools import wraps
-from lionagi import logging as _logging
-from lionagi.libs import func_call
-from lionagi.core.generic import BaseComponent
-
-from .schema import Work, WorkStatus
-from ..work.worklog import WorkLog
-from .worker import Worker
-
-
-class WorkFunction(BaseComponent):
-    """Work function management and execution."""
-
-    function: Callable
-    args: List[Any] = Field(default_factory=list)
-    kwargs: Dict[str, Any] = Field(default_factory=dict)
-    retry_kwargs: Dict[str, Any] = Field(default_factory=dict)
-    worklog: WorkLog = Field(default_factory=WorkLog)
-    instruction: str = Field(
-        default="", description="Instruction for the work function"
-    )
-    refresh_time: float = Field(
-        default=0.5, description="Time to wait before checking for pending work"
-    )
-
-    @property
-    def name(self):
-        """Get the name of the work function."""
-        return self.function.__name__
-
-    async def execute(self):
-        """Execute pending work items."""
-        while self.worklog.pending:
-            work_id = self.worklog.pending.popleft()
-            work = self.worklog.logs[work_id]
-            if work.status == WorkStatus.PENDING:
-                try:
-                    await func_call.rcall(self._execute, work, **work.retry_kwargs)
-                except Exception as e:
-                    work.status = WorkStatus.FAILED
-                    _logging.error(f"Work {work.id_} failed with error: {e}")
-                    self.worklog.errored.append(work.id_)
-            else:
-                _logging.warning(
-                    f"Work {work.id_} is in {work.status} state "
-                    "and cannot be executed."
-                )
-            await asyncio.sleep(self.refresh_time)
-
-    async def _execute(self, work: Work):
-        """Execute a single work item."""
-        work.status = WorkStatus.IN_PROGRESS
-        result = await self.function(*self.args, **self.kwargs)
-        work.deliverables = result
-        work.status = WorkStatus.COMPLETED
-        return result
-
-
-def workfunc(func):
-
-    @wraps(func)
-    async def wrapper(self: Worker, *args, **kwargs):
-        # Retrieve the worker instance ('self')
-        if not hasattr(self, "work_functions"):
-            self.work_functions = {}
-
-        if func.__name__ not in self.work_functions:
-            # Create WorkFunction with the function and its docstring as instruction
-            self.work_functions[func.__name__] = WorkFunction(
-                function=func,
-                instruction=func.__doc__,
-                args=args,
-                kwargs=kwargs,
-                retry_kwargs=kwargs.pop("retry_kwargs", {}),
-            )
-
-        # Retrieve the existing WorkFunction
-        work_function: WorkFunction = self.work_functions[func.__name__]
-        # Update args and kwargs for this call
-        work_function.args = args
-        work_function.kwargs = kwargs
-
-        # Execute the function using WorkFunction's managed execution process
-        return await work_function.execute()
-
-    return wrapper

lionagi/experimental/work2/worker.py

@@ -1,12 +0,0 @@
-from abc import ABC
-from pydantic import Field
-from lionagi.core.generic import BaseComponent
-
-
-class Worker(BaseComponent, ABC):
-    form_templates: dict = Field(
-        default={}, description="The form templates of the worker"
-    )
-    work_functions: dict = Field(
-        default={}, description="The work functions of the worker"
-    )

lionagi/integrations/bridge/llamaindex_/get_index.py

@@ -1,294 +0,0 @@
-# TODO: Refactor this code to use the new llama_index API
-
-# class BaseIndex:
-
-#     @staticmethod
-#     def _get_index(
-#         input_=None,
-#         # default to OpenAI
-#         llm=None,
-#         llm_provider=None,
-#         llm_kwargs={},
-#         service_context=None,
-#         service_context_kwargs={},
-#         index_type=None,
-#         index_kwargs={},
-#         rerank_=False,
-#         reranker_type=None,
-#         reranker=None,
-#         rerank_kwargs={},
-#         get_engine=False,
-#         engine_kwargs={},
-#         from_storage=False,
-#         storage_context=None,
-#         strorage_context_kwargs={},
-#         index_id=None,
-#         load_index_from_storage_kwargs={},
-#     ):
-#         """
-#         Creates and returns an index or query engine based on the provided parameters.
-
-#         Args:
-#             chunks: The input data to be indexed or queried.
-#             llm: An instance of a language model for indexing or querying.
-#             llm_provider: A function to provide an instance of a language model.
-#             llm_kwargs: Keyword arguments for configuring the language model.
-#             service_context: An instance of a service context.
-#             service_context_kwargs: Keyword arguments for configuring the service context.
-#             index_type: The type of index to create.
-#             index_kwargs: Keyword arguments for configuring the index.
-#             rerank_: Boolean flag indicating whether reranking should be applied.
-#             reranker_type: The type of reranker to use.
-#             reranker: An instance of a reranker.
-#             rerank_kwargs: Keyword arguments for configuring the reranker.
-#             get_engine: Boolean flag indicating whether to return a query engine.
-#             engine_kwargs: Keyword arguments for configuring the query engine.
-
-#         Returns:
-#             Index or Query Engine: Depending on the 'get_engine' flag, returns an index or query engine.
-
-#         Raises:
-#             Various exceptions if there are errors in creating the index or query engine.
-#         """
-
-#         if from_storage:
-#             from llama_index import StorageContext, load_index_from_storage
-
-#             storage_context = StorageContext.from_defaults(**strorage_context_kwargs)
-
-#             if index_id:
-#                 index = load_index_from_storage(
-#                     storage_context=storage_context,
-#                     index_id=index_id,
-#                     **load_index_from_storage_kwargs,
-#                 )
-#             else:
-#                 raise ValueError("Index ID is required for loading from storage.")
-
-#             if rerank_:
-#                 if not reranker:
-#                     if not reranker_type:
-#                         from llama_index.postprocessor import LLMRerank
-
-#                         reranker_type = LLMRerank
-#                     reranker = reranker_type(
-#                         service_context=service_context, **rerank_kwargs
-#                     )
-#                 engine_kwargs.update({"node_postprocessors": [reranker]})
-
-#             if get_engine:
-#                 return (index, index.as_query_engine(**engine_kwargs))
-#             return index
-
-#         if not llm:
-#             if llm_provider:
-#                 llm = llm_provider(**llm_kwargs)
-#             else:
-#                 from llama_index.llms import OpenAI
-
-#                 llm = OpenAI(**llm_kwargs)
-
-#         if not service_context:
-#             from llama_index import ServiceContext
-
-#             service_context = ServiceContext.from_defaults(
-#                 llm=llm, **service_context_kwargs
-#             )
-
-#         if not index_type:
-#             from llama_index import VectorStoreIndex
-
-#             index_type = VectorStoreIndex
-
-#         index = index_type(input_, service_context=service_context, **index_kwargs)
-
-#         if index_id:
-#             index.index_id = index_id
-
-#         if rerank_:
-#             if not reranker:
-#                 if not reranker_type:
-#                     from llama_index.postprocessor import LLMRerank
-
-#                     reranker_type = LLMRerank
-#                 reranker = reranker_type(
-#                     service_context=service_context, **rerank_kwargs
-#                 )
-#             engine_kwargs.update({"node_postprocessors": [reranker]})
-
-#         if get_engine:
-#             return (index, index.as_query_engine(**engine_kwargs))
-#         return index
-
-
-# class LlamaIndex:
-
-#     @staticmethod
-#     def kg_index(
-#         input_=None,
-#         # default to OpenAI
-#         llm=None,
-#         llm_provider=None,
-#         llm_kwargs={"temperature": 0.1, "model": "gpt-4-1106-preview"},
-#         service_context=None,
-#         service_context_kwargs={},
-#         index_kwargs={"include_embeddings": True},
-#         rerank_=False,
-#         reranker_type=None,
-#         reranker=None,
-#         rerank_kwargs={"choice_batch_size": 5, "top_n": 3},
-#         get_engine=False,
-#         engine_kwargs={"similarity_top_k": 3, "response_mode": "tree_summarize"},
-#         kg_triplet_extract_fn=None,
-#         from_storage=False,
-#         storage_context=None,
-#         strorage_context_kwargs={},
-#         index_id=None,
-#         load_index_from_storage_kwargs={},
-#     ):
-#         """
-#         Creates and returns a KnowledgeGraphIndex based on the provided parameters.
-
-#         Args:
-#             chunks: The input data to be indexed.
-#             llm: An instance of a language model for indexing.
-#             llm_provider: A function to provide an instance of a language model.
-#             llm_kwargs: Keyword arguments for configuring the language model.
-#             service_context: An instance of a service context.
-#             service_context_kwargs: Keyword arguments for configuring the service context.
-#             index_kwargs: Keyword arguments for configuring the index.
-#             rerank_: Boolean flag indicating whether reranking should be applied.
-#             reranker_type: The type of reranker to use.
-#             reranker: An instance of a reranker.
-#             rerank_kwargs: Keyword arguments for configuring the reranker.
-#             get_engine: Boolean flag indicating whether to return a query engine.
-#             engine_kwargs: Keyword arguments for configuring the query engine.
-#             kg_triplet_extract_fn: Optional function for extracting KG triplets.
-
-#         Returns:
-#             KnowledgeGraphIndex or Query Engine: Depending on the 'get_engine' flag,
-#             returns a KnowledgeGraphIndex or query engine.
-
-#         Raises:
-#             Various exceptions if there are errors in creating the index or query engine.
-#         """
-#         from llama_index import KnowledgeGraphIndex
-
-#         index_type_ = ""
-#         if not from_storage:
-#             from llama_index.graph_stores import SimpleGraphStore
-#             from llama_index.storage.storage_context import StorageContext
-
-#             graph_store = SimpleGraphStore()
-#             if storage_context is None:
-#                 storage_context = StorageContext.from_defaults(
-#                     graph_store=graph_store, **strorage_context_kwargs
-#                 )
-#             index_kwargs.update({"storage_context": storage_context})
-#             index_type_ = KnowledgeGraphIndex.from_documents
-
-#         elif from_storage:
-#             index_type_ = KnowledgeGraphIndex
-
-#         if kg_triplet_extract_fn:
-#             index_kwargs.update({"kg_triplet_extract_fn": kg_triplet_extract_fn})
-
-#         if storage_context is None:
-#             from llama_index.graph_stores import SimpleGraphStore
-#             from llama_index.storage.storage_context import StorageContext
-
-#             storage_context = StorageContext.from_defaults(
-#                 graph_store=SimpleGraphStore(), **strorage_context_kwargs
-#             )
-
-#         return BaseIndex._get_index(
-#             input_=input_,
-#             llm=llm,
-#             llm_provider=llm_provider,
-#             llm_kwargs=llm_kwargs,
-#             service_context=service_context,
-#             service_context_kwargs=service_context_kwargs,
-#             index_type=index_type_,
-#             index_kwargs=index_kwargs,
-#             rerank_=rerank_,
-#             reranker_type=reranker_type,
-#             reranker=reranker,
-#             rerank_kwargs=rerank_kwargs,
-#             get_engine=get_engine,
-#             engine_kwargs=engine_kwargs,
-#             from_storage=from_storage,
-#             storage_context=storage_context,
-#             strorage_context_kwargs=strorage_context_kwargs,
-#             index_id=index_id,
-#             load_index_from_storage_kwargs=load_index_from_storage_kwargs,
-#         )
-
-#     @staticmethod
-#     def vector_index(
-#         input_=None,
-#         # default to OpenAI
-#         llm=None,
-#         llm_provider=None,
-#         llm_kwargs={"temperature": 0.1, "model": "gpt-4-1106-preview"},
-#         service_context=None,
-#         service_context_kwargs={},
-#         index_kwargs={"include_embeddings": True},
-#         # default to LLMRerank
-#         rerank_=False,
-#         reranker_type=None,
-#         reranker=None,
-#         rerank_kwargs={"choice_batch_size": 5, "top_n": 3},
-#         get_engine=False,
-#         engine_kwargs={"similarity_top_k": 3, "response_mode": "tree_summarize"},
-#         from_storage=False,
-#         storage_context=None,
-#         strorage_context_kwargs={},
-#         index_id=None,
-#         load_index_from_storage_kwargs={},
-#     ):
-#         """
-#         Creates and returns a vector index or query engine based on the provided parameters.
-
-#         Args:
-#             chunks: The input data to be indexed or queried.
-#             llm: An instance of a language model for indexing or querying.
-#             llm_provider: A function to provide an instance of a language model.
-#             llm_kwargs: Keyword arguments for configuring the language model.
-#             service_context: An instance of a service context.
-#             service_context_kwargs: Keyword arguments for configuring the service context.
-#             index_kwargs: Keyword arguments for configuring the index.
-#             rerank_: Boolean flag indicating whether reranking should be applied.
-#             reranker_type: The type of reranker to use.
-#             reranker: An instance of a reranker.
-#             rerank_kwargs: Keyword arguments for configuring the reranker.
-#             get_engine: Boolean flag indicating whether to return a query engine.
-#             engine_kwargs: Keyword arguments for configuring the query engine.
-
-#         Returns:
-#             Vector Index or Query Engine: Depending on the 'get_engine' flag,
-#             returns a vector index or query engine.
-
-#         Raises:
-#             Various exceptions if there are errors in creating the index or query engine.
-#         """
-
-#         return BaseIndex._get_index(
-#             input_=input_,
-#             llm=llm,
-#             llm_provider=llm_provider,
-#             llm_kwargs=llm_kwargs,
-#             service_context=service_context,
-#             service_context_kwargs=service_context_kwargs,
-#             index_kwargs=index_kwargs,
-#             rerank_=rerank_,
-#             reranker_type=reranker_type,
-#             reranker=reranker,
-#             rerank_kwargs=rerank_kwargs,
-#             get_engine=get_engine,
-#             engine_kwargs=engine_kwargs,
-#             from_storage=from_storage,
-#             storage_context=storage_context,
-#             strorage_context_kwargs=strorage_context_kwargs,
-#             index_id=index_id,
-#             load_index_from_storage_kwargs=load_index_from_storage_kwargs,
-#         )

lionagi/tests/test_core/generic/test_component.py

@@ -1,89 +0,0 @@
-import unittest
-from pydantic import BaseModel
-from pandas import Series
-import pandas as pd
-from lionagi.core.generic.component import BaseNode
-
-class TestBaseNode(unittest.TestCase):
-
-    def test_basic_properties(self):
-        node = BaseNode(content="Hello World")
-        self.assertIsInstance(node.id_, str)
-        self.assertEqual(len(node.id_), 32)
-        self.assertEqual(node.content, "Hello World")
-        self.assertEqual(node.metadata, {})
-
-    def test_serialization_json(self):
-        node = BaseNode(content="Hello World")
-        self.assertIn('id_', node.to_json_str())
-
-    def test_serialization_dict(self):
-        node = BaseNode(content="Hello World")
-        result = node.to_dict()
-        self.assertIn('id_', result)
-        self.assertEqual(result['content'], "Hello World")
-
-    def test_serialization_xml(self):
-        node = BaseNode(content="Hello World")
-        xml_str = node.to_xml()
-        self.assertIn('<BaseNode>', xml_str)
-        self.assertIn('</BaseNode>', xml_str)
-
-    def test_conversion_to_pandas_series(self):
-        node = BaseNode(content="Hello World")
-        series = node.to_pd_series()
-        self.assertIsInstance(series, Series)
-        self.assertEqual(series['content'], "Hello World")
-
-    def test_field_management(self):
-        node = BaseNode(content="Hello World")
-        node._add_field("new_field", annotation=str, default="default value")
-        self.assertIn('new_field', node._field_annotations)
-        self.assertEqual(getattr(node, 'new_field', None), "default value")
-
-    def test_creation_from_dict(self):
-        data = {"a": 1, "b": 2}
-        node = BaseNode.from_obj(data)
-        self.assertIn('a', node.to_dict())
-
-    def test_creation_from_json_str(self):
-        json_str = '{"a": 1, "b": 2}'
-        node = BaseNode.from_obj(json_str)
-        self.assertIn('a', node.to_dict())
-
-    def test_creation_from_fuzzy_json_str(self):
-        json_str = '{"name": "John", "age": 30, "city": ["New York", "DC", "LA"]'
-        node = BaseNode.from_obj(json_str, fuzzy_parse=True)
-        self.assertIn('name', node.to_dict())
-
-    def test_creation_from_pandas_series(self):
-        series = pd.Series({"a": 1, "b": 2})
-        node = BaseNode.from_obj(series)
-        self.assertIn('a', node.to_dict())
-
-    def test_creation_from_pandas_dataframe(self):
-        df = pd.DataFrame({"a": [1, 2], "b": [3, 4]}, index=["row1", "row2"])
-        nodes = BaseNode.from_obj(df)
-        self.assertIsInstance(nodes, list)
-        self.assertEqual(len(nodes), 2)
-
-    def test_creation_from_pydantic_model(self):
-        class CustomModel(BaseModel):
-            a: int
-            b: str
-
-        custom_model = CustomModel(a=1, b="hello")
-        node = BaseNode.from_obj(custom_model)
-        self.assertIn('a', node.to_dict())
-
-    def test_metadata_manipulation(self):
-        node = BaseNode()
-        node.meta_insert("key", "value")
-        self.assertEqual(node.metadata['key'], "value")
-        node.meta_change_key("key", "new_key")
-        self.assertIn("new_key", node.metadata)
-        node.meta_merge({"additional_key": "additional_value"})
-        self.assertIn("additional_key", node.metadata)
-
-if __name__ == '__main__':
-    unittest.main()