fabricatio 0.2.0.dev0__tar.gz → 0.2.0.dev1__tar.gz

{fabricatio-0.2.0.dev0 → fabricatio-0.2.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.0.dev0
+Version: 0.2.0.dev1
 Summary: A LLM multi-agent framework.
 Author-email: Whth <zettainspector@foxmail.com>
 License: MIT License
@@ -51,10 +51,51 @@ Requires-Dist: regex>=2024.11.6
 Requires-Dist: rich>=13.9.4
 Description-Content-Type: text/markdown
 
+# Fabricatio
+
+---
+
+Fabricatio is a powerful framework designed to facilitate the creation and management of tasks, actions, and workflows. It leverages modern Python features and libraries to provide a robust and flexible environment for building applications that require task automation and orchestration.
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Usage](#usage)
+    - [Defining a Task](#defining-a-task)
+    - [Creating an Action](#creating-an-action)
+    - [Assigning a Role](#assigning-a-role)
+    - [Logging](#logging)
+- [Configuration](#configuration)
+    - [LLM Configuration](#llm-configuration)
+    - [Debug Configuration](#debug-configuration)
+- [Examples](#examples)
+    - [Simple Task Example](#simple-task-example)
+    - [Complex Workflow Example](#complex-workflow-example)
+- [Contributing](#contributing)
+- [License](#license)
+
+## Installation
+To install Fabricatio, you can use pip:
+
+```bash
+pip install fabricatio
+```
+
+Alternatively, you can clone the repository and install it manually:
+
+```bash
+git clone https://github.com/your-repo/fabricatio.git
+cd fabricatio
+pip install .
+```
+
+
 ## Usage
 
 ### Defining a Task
 
+A task in Fabricatio is defined using the `Task` class. You can specify the name, goal, and description of the task.
+
 ```python
 from fabricatio.models.task import Task
 
@@ -64,12 +105,14 @@ task = Task(name="say hello", goal="say hello", description="say hello to the wo
 
 ### Creating an Action
 
+Actions are the building blocks of workflows. They perform specific tasks and can be asynchronous.
+
 ```python
 from fabricatio import Action, logger
 from fabricatio.models.task import Task
 
 class Talk(Action):
-    async def _execute(self, task_input: Task[str], **_) -> Any:
+    async def _execute(self, task_input: Task[str], **_) -> str:
         ret = "Hello fabricatio!"
         logger.info("executing talk action")
         return ret
@@ -78,6 +121,8 @@ class Talk(Action):
 
 ### Assigning a Role
 
+Roles in Fabricatio are responsible for executing workflows. You can define a role with a set of actions.
+
 ```python
 from fabricatio.models.role import Role
 from fabricatio.models.action import WorkFlow
@@ -104,19 +149,91 @@ debug_config = DebugConfig(log_level="DEBUG", log_file="fabricatio.log")
 
 Fabricatio uses Pydantic for configuration management. You can define your settings in the `config.py` file.
 
+### LLM Configuration
+
+The Large Language Model (LLM) configuration is managed by the `LLMConfig` class.
+
 ```python
-from fabricatio.config import Settings
+from fabricatio.config import LLMConfig
 
-settings = Settings(llm=LLMConfig(api_endpoint="https://api.example.com"))
+llm_config = LLMConfig(api_endpoint="https://api.example.com")
 ```
 
 
-## Testing
+### Debug Configuration
 
-Fabricatio includes a set of tests to ensure the framework works as expected. You can run the tests using `pytest`.
+The debug configuration is managed by the `DebugConfig` class.
 
-```bash
-pytest
+```python
+from fabricatio.config import DebugConfig
+
+debug_config = DebugConfig(log_level="DEBUG", log_file="fabricatio.log")
+```
+
+
+## Examples
+
+### Simple Task Example
+
+Here is a simple example of a task that prints "Hello fabricatio!".
+
+```python
+import asyncio
+from fabricatio import Action, Role, Task, WorkFlow, logger
+
+task = Task(name="say hello", goal="say hello", description="say hello to the world")
+
+class Talk(Action):
+    async def _execute(self, task_input: Task[str], **_) -> Any:
+        ret = "Hello fabricatio!"
+        logger.info("executing talk action")
+        return ret
+
+class TestWorkflow(WorkFlow):
+    pass
+
+role = Role(name="Test Role", actions=[TestWorkflow()])
+
+async def main() -> None:
+    await role.act(task)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+
+### Complex Workflow Example
+
+Here is a more complex example that demonstrates how to create a workflow with multiple actions.
+
+```python
+import asyncio
+from fabricatio import Action, Role, Task, WorkFlow, logger
+
+task = Task(name="complex task", goal="perform complex operations", description="a task with multiple actions")
+
+class ActionOne(Action):
+    async def _execute(self, task_input: Task[str], **_) -> Any:
+        ret = "Action One executed"
+        logger.info(ret)
+        return ret
+
+class ActionTwo(Action):
+    async def _execute(self, task_input: Task[str], **_) -> Any:
+        ret = "Action Two executed"
+        logger.info(ret)
+        return ret
+
+class ComplexWorkflow(WorkFlow):
+    actions = [ActionOne(), ActionTwo()]
+
+role = Role(name="Complex Role", actions=[ComplexWorkflow()])
+
+async def main() -> None:
+    await role.act(task)
+
+if __name__ == "__main__":
+    asyncio.run(main())
 ```
 
 

fabricatio-0.2.0.dev1/README.md

@@ -0,0 +1,193 @@
+# Fabricatio
+
+---
+
+Fabricatio is a powerful framework designed to facilitate the creation and management of tasks, actions, and workflows. It leverages modern Python features and libraries to provide a robust and flexible environment for building applications that require task automation and orchestration.
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Usage](#usage)
+    - [Defining a Task](#defining-a-task)
+    - [Creating an Action](#creating-an-action)
+    - [Assigning a Role](#assigning-a-role)
+    - [Logging](#logging)
+- [Configuration](#configuration)
+    - [LLM Configuration](#llm-configuration)
+    - [Debug Configuration](#debug-configuration)
+- [Examples](#examples)
+    - [Simple Task Example](#simple-task-example)
+    - [Complex Workflow Example](#complex-workflow-example)
+- [Contributing](#contributing)
+- [License](#license)
+
+## Installation
+To install Fabricatio, you can use pip:
+
+```bash
+pip install fabricatio
+```
+
+Alternatively, you can clone the repository and install it manually:
+
+```bash
+git clone https://github.com/your-repo/fabricatio.git
+cd fabricatio
+pip install .
+```
+
+
+## Usage
+
+### Defining a Task
+
+A task in Fabricatio is defined using the `Task` class. You can specify the name, goal, and description of the task.
+
+```python
+from fabricatio.models.task import Task
+
+task = Task(name="say hello", goal="say hello", description="say hello to the world")
+```
+
+
+### Creating an Action
+
+Actions are the building blocks of workflows. They perform specific tasks and can be asynchronous.
+
+```python
+from fabricatio import Action, logger
+from fabricatio.models.task import Task
+
+class Talk(Action):
+    async def _execute(self, task_input: Task[str], **_) -> str:
+        ret = "Hello fabricatio!"
+        logger.info("executing talk action")
+        return ret
+```
+
+
+### Assigning a Role
+
+Roles in Fabricatio are responsible for executing workflows. You can define a role with a set of actions.
+
+```python
+from fabricatio.models.role import Role
+from fabricatio.models.action import WorkFlow
+
+class TestWorkflow(WorkFlow):
+    pass
+
+role = Role(name="Test Role", actions=[TestWorkflow()])
+```
+
+
+### Logging
+
+Fabricatio uses Loguru for logging. You can configure the log level and file in the `config.py` file.
+
+```python
+from fabricatio.config import DebugConfig
+
+debug_config = DebugConfig(log_level="DEBUG", log_file="fabricatio.log")
+```
+
+
+## Configuration
+
+Fabricatio uses Pydantic for configuration management. You can define your settings in the `config.py` file.
+
+### LLM Configuration
+
+The Large Language Model (LLM) configuration is managed by the `LLMConfig` class.
+
+```python
+from fabricatio.config import LLMConfig
+
+llm_config = LLMConfig(api_endpoint="https://api.example.com")
+```
+
+
+### Debug Configuration
+
+The debug configuration is managed by the `DebugConfig` class.
+
+```python
+from fabricatio.config import DebugConfig
+
+debug_config = DebugConfig(log_level="DEBUG", log_file="fabricatio.log")
+```
+
+
+## Examples
+
+### Simple Task Example
+
+Here is a simple example of a task that prints "Hello fabricatio!".
+
+```python
+import asyncio
+from fabricatio import Action, Role, Task, WorkFlow, logger
+
+task = Task(name="say hello", goal="say hello", description="say hello to the world")
+
+class Talk(Action):
+    async def _execute(self, task_input: Task[str], **_) -> Any:
+        ret = "Hello fabricatio!"
+        logger.info("executing talk action")
+        return ret
+
+class TestWorkflow(WorkFlow):
+    pass
+
+role = Role(name="Test Role", actions=[TestWorkflow()])
+
+async def main() -> None:
+    await role.act(task)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+
+### Complex Workflow Example
+
+Here is a more complex example that demonstrates how to create a workflow with multiple actions.
+
+```python
+import asyncio
+from fabricatio import Action, Role, Task, WorkFlow, logger
+
+task = Task(name="complex task", goal="perform complex operations", description="a task with multiple actions")
+
+class ActionOne(Action):
+    async def _execute(self, task_input: Task[str], **_) -> Any:
+        ret = "Action One executed"
+        logger.info(ret)
+        return ret
+
+class ActionTwo(Action):
+    async def _execute(self, task_input: Task[str], **_) -> Any:
+        ret = "Action Two executed"
+        logger.info(ret)
+        return ret
+
+class ComplexWorkflow(WorkFlow):
+    actions = [ActionOne(), ActionTwo()]
+
+role = Role(name="Complex Role", actions=[ComplexWorkflow()])
+
+async def main() -> None:
+    await role.act(task)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+
+## Contributing
+
+Contributions to Fabricatio are welcome! Please submit a pull request with your changes.
+
+## License
+
+Fabricatio is licensed under the MIT License. See the [LICENSE](LICENSE) file for more information.

{fabricatio-0.2.0.dev0 → fabricatio-0.2.0.dev1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fabricatio"
-version = "0.2.0-dev.0"
+version = "0.2.0-dev.1"
 description = "A LLM multi-agent framework."
 readme = "README.md"
 license = { file = "LICENSE" }

fabricatio-0.2.0.dev1/src/fabricatio/actions/__init__.py

@@ -0,0 +1,5 @@
+"""module for actions."""
+
+from fabricatio.actions.transmission import PublishTask
+
+__all__ = ["PublishTask"]

fabricatio-0.2.0.dev1/src/fabricatio/actions/transmission.py

@@ -0,0 +1,20 @@
+from typing import List
+
+from fabricatio.journal import logger
+from fabricatio.models.action import Action
+from fabricatio.models.events import EventLike
+from fabricatio.models.task import Task
+
+
+class PublishTask(Action):
+    """An action that publishes a task to a list of targets."""
+
+    name: str = "publish_task"
+    """The name of the action."""
+    description: str = "Publish a task to a list of targets."
+
+    async def _execute(self, send_targets: List[EventLike], send_task: Task, **_) -> None:
+        """Execute the action by sending the task to the specified targets."""
+        logger.info(f"Sending task {send_task.name} to {send_targets}")
+        for target in send_targets:
+            await send_task.move_to(target).publish()

fabricatio-0.2.0.dev1/src/fabricatio/fs/__init__.py

@@ -0,0 +1 @@
+"""FileSystem manipulation module for Fabricatio."""

{fabricatio-0.2.0.dev0 → fabricatio-0.2.0.dev1}/src/fabricatio/models/action.py

@@ -41,7 +41,7 @@ class Action(WithBriefing, LLMUsage):
         return cxt
 
 
-class WorkFlow(WithBriefing, LLMUsage):
+class WorkFlow[A: Type[Action] | Action](WithBriefing, LLMUsage):
     """Class that represents a workflow to be executed in a task."""
 
     _context: Queue[Dict[str, Any]] = PrivateAttr(default_factory=lambda: Queue(maxsize=1))
@@ -49,12 +49,14 @@ class WorkFlow(WithBriefing, LLMUsage):
 
     _instances: Tuple[Action, ...] = PrivateAttr(...)
 
-    steps: Tuple[Type[Action], ...] = Field(...)
-    """ The steps to be executed in the workflow."""
+    steps: Tuple[A, ...] = Field(...)
+    """ The steps to be executed in the workflow, actions or action classes."""
     task_input_key: str = Field(default="task_input")
     """ The key of the task input data."""
     task_output_key: str = Field(default="task_output")
     """ The key of the task output data."""
+    extra_init_context: Dict[str, Any] = Field(default_factory=dict, frozen=True)
+    """ The extra context dictionary to be used for workflow initialization."""
 
     def model_post_init(self, __context: Any) -> None:
         """Initialize the workflow by setting fallbacks for each step.
@@ -62,7 +64,11 @@ class WorkFlow(WithBriefing, LLMUsage):
         Args:
             __context: The context to be used for initialization.
         """
-        self._instances = tuple(step() for step in self.steps)
+        temp = []
+        for step in self.steps:
+            temp.append(step if isinstance(step, Action) else step())
+        self._instances = tuple(temp)
+
         for step in self._instances:
             step.fallback_to(self)
 
@@ -73,13 +79,13 @@ class WorkFlow(WithBriefing, LLMUsage):
             task: The task to be served.
         """
         await task.start()
-        await self._context.put({self.task_input_key: task})
+        await self._init_context()
         current_action = None
         try:
             for step in self._instances:
                 logger.debug(f"Executing step: {step.name}")
-                ctx = await self._context.get()
-                modified_ctx = await step.act(ctx)
+                cxt = await self._context.get()
+                modified_ctx = await step.act(cxt)
                 await self._context.put(modified_ctx)
                 current_action = step.name
             logger.info(f"Finished executing workflow: {self.name}")
@@ -88,3 +94,8 @@ class WorkFlow(WithBriefing, LLMUsage):
             logger.error(f"Error during task: {current_action} execution: {e}")  # Log the exception
             logger.error(traceback.format_exc())  # Add this line to log the traceback
             await task.fail()  # Mark the task as failed
+
+    async def _init_context(self) -> None:
+        """Initialize the context dictionary for workflow execution."""
+        logger.debug(f"Initializing context for workflow: {self.name}")
+        await self._context.put({self.task_input_key: None, **dict(self.extra_init_context)})

{fabricatio-0.2.0.dev0 → fabricatio-0.2.0.dev1}/src/fabricatio/models/task.py

@@ -11,7 +11,7 @@ from pydantic import Field, PrivateAttr
 
 from fabricatio.core import env
 from fabricatio.journal import logger
-from fabricatio.models.events import Event
+from fabricatio.models.events import Event, EventLike
 from fabricatio.models.generic import WithBriefing, WithDependency, WithJsonExample
 
 
@@ -69,7 +69,7 @@ class Task[T](WithBriefing, WithJsonExample, WithDependency):
         """Initialize the task with a namespace event."""
         self._namespace.segments.extend(self.namespace)
 
-    def move_to(self, new_namespace: List[str]) -> Self:
+    def move_to(self, new_namespace: EventLike) -> Self:
         """Move the task to a new namespace.
 
         Args:

fabricatio-0.2.0.dev0/README.md

@@ -1,76 +0,0 @@
-## Usage
-
-### Defining a Task
-
-```python
-from fabricatio.models.task import Task
-
-task = Task(name="say hello", goal="say hello", description="say hello to the world")
-```
-
-
-### Creating an Action
-
-```python
-from fabricatio import Action, logger
-from fabricatio.models.task import Task
-
-class Talk(Action):
-    async def _execute(self, task_input: Task[str], **_) -> Any:
-        ret = "Hello fabricatio!"
-        logger.info("executing talk action")
-        return ret
-```
-
-
-### Assigning a Role
-
-```python
-from fabricatio.models.role import Role
-from fabricatio.models.action import WorkFlow
-
-class TestWorkflow(WorkFlow):
-    pass
-
-role = Role(name="Test Role", actions=[TestWorkflow()])
-```
-
-
-### Logging
-
-Fabricatio uses Loguru for logging. You can configure the log level and file in the `config.py` file.
-
-```python
-from fabricatio.config import DebugConfig
-
-debug_config = DebugConfig(log_level="DEBUG", log_file="fabricatio.log")
-```
-
-
-## Configuration
-
-Fabricatio uses Pydantic for configuration management. You can define your settings in the `config.py` file.
-
-```python
-from fabricatio.config import Settings
-
-settings = Settings(llm=LLMConfig(api_endpoint="https://api.example.com"))
-```
-
-
-## Testing
-
-Fabricatio includes a set of tests to ensure the framework works as expected. You can run the tests using `pytest`.
-
-```bash
-pytest
-```
-
-
-## Contributing
-
-Contributions to Fabricatio are welcome! Please submit a pull request with your changes.
-
-## License
-
-Fabricatio is licensed under the MIT License. See the [LICENSE](LICENSE) file for more information.

fabricatio-0.2.0.dev0/src/fabricatio/actions/__init__.py

@@ -1,5 +0,0 @@
-"""module for actions."""
-
-from fabricatio.actions.transmission import SendTask
-
-__all__ = ["SendTask"]

fabricatio-0.2.0.dev0/src/fabricatio/actions/transmission.py

@@ -1,16 +0,0 @@
-from typing import List
-
-from fabricatio.journal import logger
-from fabricatio.models.action import Action
-from fabricatio.models.task import Task
-
-
-class SendTask(Action):
-    """Action that sends a task to a user."""
-
-    name: str = "send_task"
-
-    async def _execute(self, send_targets: List[str], send_task: Task, **_) -> None:
-        logger.info(f"Sending task {send_task.name} to {send_targets}")
-        for target in send_targets:
-            await send_task.publish(target)