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

lionagi/experimental/tool/manual.py

@@ -0,0 +1,66 @@
+import re
+from typing import Dict, Union, Callable, Any
+
+
+class BaseManual:
+    def __init__(self, template_str: str):
+        self.template_str = template_str
+
+    def _evaluate_condition(self, match, context):
+        condition, text = match.groups()
+        # Future implementations might parse and evaluate the condition more thoroughly
+        return text if condition in context and context[condition] else ""
+
+    def _render_conditionals(self, context: Dict[str, Union[str, int, float]]) -> str:
+        conditional_pattern = re.compile(r"\{if (.*?)\}(.*?)\{endif\}", re.DOTALL)
+        return conditional_pattern.sub(
+            lambda match: self._evaluate_condition(match, context), self.template_str
+        )
+
+    def _replace_callable(self, match, context):
+        key = match.group(1)
+        if key in context:
+            value = context[key]
+            return str(value() if callable(value) else value)
+        return match.group(0)  # Unmatched placeholders remain unchanged.
+
+    def _render_placeholders(
+        self,
+        rendered_template: str,
+        context: Dict[str, Union[str, int, float, Callable]],
+    ) -> str:
+        return re.sub(
+            r"\{(\w+)\}",
+            lambda match: self._replace_callable(match, context),
+            rendered_template,
+        )
+
+    def generate(self, context: Dict[str, Union[str, int, float, Callable]]) -> str:
+        """
+        Generates output by first processing conditionals, then rendering placeholders,
+        including executing callable objects for dynamic data generation.
+        """
+        template_with_conditionals = self._render_conditionals(context)
+        final_output = self._render_placeholders(template_with_conditionals, context)
+        return final_output
+
+
+# from experiments.executor.executor import SafeEvaluator
+
+# class DecisionTreeManual:
+#     def __init__(self, root):
+#         self.root = root
+#         self.evaluator = SafeEvaluator()
+
+#     def evaluate(self, context):
+#         return self._traverse_tree(self.root, context)
+
+#     def _traverse_tree(self, node, context):
+#         if isinstance(node, CompositeActionNode) or isinstance(node, ActionNode):
+#             return node.execute(context)
+#         elif isinstance(node, DecisionNode):
+#             condition_result = self.evaluator.evaluate(node.condition, context)
+#             next_node = node.true_branch if condition_result else node.false_branch
+#             return self._traverse_tree(next_node, context)
+#         else:
+#             raise ValueError("Invalid node type.")

lionagi/experimental/tool/schema.py

@@ -0,0 +1,59 @@
+from typing import Any
+from pydantic import field_serializer
+from functools import singledispatchmethod
+from lionagi import logging as _logging
+from lionagi.libs import func_call, AsyncUtil
+from lionagi.core.generic.node import Node
+from .function_calling import FunctionCalling
+
+
+class Tool(Node):
+
+    func: Any
+    schema_: dict | None = None
+    manual: Any | None = None
+    parser: Any | None = None
+    pre_processor: Any | None = None
+    post_processor: Any | None = None
+
+    @property
+    def name(self):
+        return self.schema_["function"]["name"]
+
+    @field_serializer("func")
+    def serialize_func(self, func):
+        return func.__name__
+
+    @singledispatchmethod
+    async def invoke(self, values: Any) -> Any:
+        raise TypeError(f"Unsupported type {type(values)}")
+
+    @invoke.register
+    async def _(self, kwargs: dict):
+
+        out = None
+
+        if self.pre_processor:
+            kwargs = await func_call.unified_call(self.pre_processor, kwargs)
+        try:
+            out = await func_call.unified_call(self.func, **kwargs)
+
+        except Exception as e:
+            _logging.error(f"Error invoking function {self.func_name}: {e}")
+            return None
+
+        if self.post_processor:
+            return await func_call.unified_call(self.post_processor, out)
+
+        return out
+
+    @invoke.register
+    async def _(self, function_calls: FunctionCalling):
+        return await self.invoke(function_calls.kwargs)
+
+    @invoke.register
+    async def _(self, values: list):
+        return await func_call.alcall(self.invoke, values)
+
+
+TOOL_TYPE = bool | Tool | str | list[Tool | str | dict] | dict

lionagi/experimental/tool/tool_manager.py

@@ -0,0 +1,138 @@
+import asyncio
+from functools import singledispatchmethod
+from collections import deque
+from typing import Tuple, Any, TypeVar, Callable
+from lionagi.libs import func_call, convert, ParseUtil
+from lionagi import logging as _logging
+from .schema import Tool, TOOL_TYPE
+from .util import func_to_tool, parse_tool_response
+from .function_calling import FunctionCalling
+
+T = TypeVar("T", bound=Tool)
+
+
+class ToolManager:
+
+    def __init__(
+        self,
+        tool_registry: dict = {},
+        function_calling_tasks: dict[str : deque[FunctionCalling]] = {},
+    ):
+        self.registry = tool_registry
+        self.function_calling_tasks = function_calling_tasks
+
+    @singledispatchmethod
+    def register_tools(self, tools: Any):
+        raise TypeError(f"Unsupported type {type(tools)}")
+
+    @register_tools.register(Tool)
+    def _(self, tools):
+        name = tools.schema_["function"]["name"]
+        if self._has_name(name):
+            err_msg = f"Function {name} is already registered."
+            _logging.error(err_msg)
+            raise ValueError(err_msg)
+        else:
+            self.registry[name] = tools
+            self.function_calling_tasks[name] = deque()
+            return True
+
+    @register_tools.register(Callable)
+    def _(self, tools):
+        tool = func_to_tool(tools)[0]
+        return self.register_tools(tool)
+
+    @register_tools.register(list)
+    def _(self, tools):
+        return func_call.lcall(tools, self.register_tools)
+
+    @singledispatchmethod
+    def register_function_calling(self, func_params: Any):
+        raise TypeError(f"Unsupported type {type(func_params)}")
+
+    @register_function_calling.register(tuple)
+    def _(self, func_params):
+        func = self.registry[func_params[0]].func
+        kwargs = func_params[1]
+        _function_calling = FunctionCalling(func=func, kwargs=kwargs)
+        self.function_calling_tasks[func.__name__].append(_function_calling)
+        return True
+
+    @register_function_calling.register(dict)
+    def _(self, response):
+        tuple_ = parse_tool_response(response)
+        return self.register_function_calling(tuple_)
+
+    @register_function_calling.register(list)
+    def _(self, func_params):
+        return func_call.lcall(func_params, self.register_function_calling)
+
+    async def invoke(self, func_params: Tuple[str, dict[str, Any]]) -> Any:
+        name, kwargs = func_params
+        if not self._has_name(name):
+            raise ValueError(f"Function {name} is not registered.")
+        tool = self.registry[name]
+        func = tool.func
+        parser = tool.parser
+        try:
+            out = await func_call.unified_call(func, **kwargs)
+            return parser(out) if parser else out
+
+        except Exception as e:
+            raise ValueError(
+                f"Error when invoking function {name} with arguments {kwargs} with error message {e}"
+            ) from e
+
+    @property
+    def _schema_list(self) -> list[dict[str, Any]]:
+        return [tool.schema_ for tool in self.registry.values()]
+
+    def get_tool_schema(self, tools: TOOL_TYPE, **kwargs):
+        if isinstance(tools, bool):
+            tool_kwarg = {"tools": self._schema_list}
+            return tool_kwarg | kwargs
+
+        else:
+            if not isinstance(tools, list):
+                tools = [tools]
+            tool_kwarg = {"tools": self._get_tool_schema(tools)}
+            return tool_kwarg | kwargs
+
+    def _has_name(self, name: str) -> bool:
+        return name in self.registry
+
+    @singledispatchmethod
+    def _get_tool_schema(self, tool: Any) -> dict:
+        raise TypeError(f"Unsupported type {type(tool)}")
+
+    @_get_tool_schema.register(dict)
+    def _(self, tool):
+        """
+        assuming that the tool is a schema
+        """
+        return tool
+
+    @_get_tool_schema.register(Tool)
+    def _(self, tool):
+        if self._has_name(tool.name):
+            return self.registry[tool.name].schema_
+        else:
+            err_msg = f"Function {tool.name} is not registered."
+            _logging.error(err_msg)
+            raise ValueError(err_msg)
+
+    @_get_tool_schema.register(str)
+    def _(self, tool):
+        """
+        assuming that the tool is a name
+        """
+        if self._has_name(tool):
+            return self.registry[tool].schema_
+        else:
+            err_msg = f"Function {tool} is not registered."
+            _logging.error(err_msg)
+            raise ValueError(err_msg)
+
+    @_get_tool_schema.register(list)
+    def _(self, tools):
+        return func_call.lcall(tools, self._get_tool_schema)

lionagi/experimental/tool/util.py

@@ -0,0 +1,16 @@
+from typing import Tuple
+from lionagi.libs import convert
+
+
+def parse_tool_response(response: dict) -> Tuple[str, dict]:
+    try:
+        func = response["action"][7:]
+        args = convert.to_dict(response["arguments"])
+        return func, args
+    except Exception:
+        try:
+            func = response["recipient_name"].split(".")[-1]
+            args = response["parameters"]
+            return func, args
+        except:
+            raise ValueError("response is not a valid function call")

lionagi/experimental/work/_logger.py

@@ -0,0 +1,25 @@
+from collections import deque
+from typing import Dict
+from pydantic import BaseModel, Field
+from .schema import Work, WorkStatus
+
+
+class WorkLog(BaseModel):
+    """Model to store and manage work logs."""
+
+    logs: Dict[str, Work] = Field(default={}, description="Logs of work items")
+    pending: deque = Field(
+        default_factory=deque, description="Priority queue of pending work items"
+    )
+    errored: deque = Field(
+        default_factory=deque, description="Queue of errored work items"
+    )
+
+    def append(self, work: Work):
+        """Append a work item to the logs and pending queue."""
+        self.logs[str(work.form_id)] = work
+        self.pending.append(str(work.form_id))
+
+    def get_by_status(self, status: WorkStatus) -> Dict[str, Work]:
+        """Get work items by their status."""
+        return {wid: work for wid, work in self.logs.items() if work.status == status}

lionagi/experimental/work/schema.py

@@ -0,0 +1,30 @@
+from enum import Enum
+from typing import Any, Dict, List
+from pydantic import Field
+from lionagi.core.generic import BaseComponent
+
+
+class WorkStatus(str, Enum):
+    """Enum to represent different statuses of work."""
+
+    PENDING = "PENDING"
+    IN_PROGRESS = "IN_PROGRESS"
+    COMPLETED = "COMPLETED"
+    FAILED = "FAILED"
+    CANCELLED = "CANCELLED"
+
+
+class Work(BaseComponent):
+    """Base component for handling individual units of work."""
+
+    form_id: str = Field(..., description="ID of the form for this work")
+    priority: int = Field(default=0, description="Priority of the work")
+    status: WorkStatus = Field(
+        default=WorkStatus.PENDING, description="Current status of the work"
+    )
+    deliverables: Dict[str, Any] | list = Field(
+        default={}, description="Deliverables produced by the work"
+    )
+    dependencies: List["Work"] = Field(
+        default_factory=list, description="List of work items this work depends on"
+    )

lionagi/experimental/work/tests.py

@@ -0,0 +1,72 @@
+from .schema import Work, WorkStatus
+from ._logger 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/work/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 ._logger 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/work/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)