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

lionagi/experimental/work2/tests.py

@@ -0,0 +1,72 @@
+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

@@ -0,0 +1,89 @@
+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

@@ -0,0 +1,12 @@
+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/autogen_/autogen_.py

@@ -0,0 +1,124 @@
+from typing import Dict, Union
+
+
+def get_ipython_user_proxy():
+
+    try:
+        from lionagi.libs import SysUtil
+
+        SysUtil.check_import("autogen", pip_name="pyautogen")
+
+        import autogen
+        from IPython import get_ipython
+    except Exception as e:
+        raise ImportError(f"Please install autogen and IPython. {e}")
+
+    class IPythonUserProxyAgent(autogen.UserProxyAgent):
+
+        def __init__(self, name: str, **kwargs):
+            super().__init__(name, **kwargs)
+            self._ipython = get_ipython()
+
+        def generate_init_message(self, *args, **kwargs) -> Union[str, Dict]:
+            return (
+                super().generate_init_message(*args, **kwargs)
+                + """If you suggest code, the code will be executed in IPython."""
+            )
+
+        def run_code(self, code, **kwargs):
+            result = self._ipython.run_cell("%%capture --no-display cap\n" + code)
+            log = self._ipython.ev("cap.stdout")
+            log += self._ipython.ev("cap.stderr")
+            if result.result is not None:
+                log += str(result.result)
+            exitcode = 0 if result.success else 1
+            if result.error_before_exec is not None:
+                log += f"\n{result.error_before_exec}"
+                exitcode = 1
+            if result.error_in_exec is not None:
+                log += f"\n{result.error_in_exec}"
+                exitcode = 1
+            return exitcode, log, None
+
+    return IPythonUserProxyAgent
+
+
+def get_autogen_coder(
+    llm_config=None,
+    code_execution_config=None,
+    kernal="python",
+    config_list=None,
+    max_consecutive_auto_reply=15,
+    temperature=0,
+    cache_seed=42,
+    env_="local",
+    assistant_instruction=None,
+):
+    assistant = ""
+    try:
+        from lionagi.libs import SysUtil
+
+        SysUtil.check_import("autogen", pip_name="pyautogen")
+
+        import autogen
+        from autogen.agentchat.contrib.gpt_assistant_agent import GPTAssistantAgent
+    except Exception as e:
+        raise ImportError(f"Please install autogen. {e}")
+
+    if env_ == "local":
+        assistant = autogen.AssistantAgent(
+            name="assistant",
+            llm_config=llm_config
+            or {
+                "cache_seed": cache_seed,
+                "config_list": config_list,
+                "temperature": temperature,
+            },
+        )
+
+    elif env_ == "oai_assistant":
+        assistant = GPTAssistantAgent(
+            name="Coder Assistant",
+            llm_config={
+                "tools": [{"type": "code_interpreter"}],
+                "config_list": config_list,
+            },
+            instructions=assistant_instruction,
+        )
+
+    if kernal == "python":
+        user_proxy = autogen.UserProxyAgent(
+            name="user_proxy",
+            human_input_mode="NEVER",
+            max_consecutive_auto_reply=max_consecutive_auto_reply,
+            is_termination_msg=lambda x: x.get("content", "")
+            .rstrip()
+            .endswith("TERMINATE"),
+            code_execution_config=code_execution_config
+            or {
+                "work_dir": "coding",
+                "use_docker": False,
+            },
+        )
+        return user_proxy, assistant
+
+    elif kernal == "ipython":
+        user_proxy = get_ipython_user_proxy(
+            "ipython_user_proxy",
+            human_input_mode="NEVER",
+            max_consecutive_auto_reply=max_consecutive_auto_reply,
+            is_termination_msg=lambda x: x.get("content", "")
+            .rstrip()
+            .endswith("TERMINATE")
+            or x.get("content", "").rstrip().endswith('"TERMINATE".'),
+        )
+        return user_proxy, assistant
+
+    # # Sample Usage Pattern
+    # context = "def my_function():\n    pass\n"
+    # task1 = "I need help with the following code:\n"
+    # task2 = "Please write a function that returns the sum of two numbers."
+
+    # user_proxy, assistant = get_autogen_coder()
+    # user_proxy.initiate_chat(assistant, message=task1+context)
+    # user_proxy.send(recipient=assistant, message=task2)

lionagi/integrations/bridge/llamaindex_/get_index.py

@@ -0,0 +1,294 @@
+# 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,
+#         )