fabricatio 0.2.0.dev0__tar.gz → 0.2.0.dev2__tar.gz

{fabricatio-0.2.0.dev0 → fabricatio-0.2.0.dev2}/.github/workflows/build-package.yaml

@@ -46,7 +46,10 @@ jobs:
               echo "VERSION_CHANGED=false" >> $GITHUB_OUTPUT
           fi
         shell: bash
-
+      - name: Packing templates
+        if: ${{ steps.check_version_change.outputs.VERSION_CHANGED == 'true' }}
+        run: |
+          tar -czf templates.tar.gz templates
 
       - name: Create Release and upload assets
         if: ${{ steps.check_version_change.outputs.VERSION_CHANGED == 'true' }}
@@ -57,6 +60,7 @@ jobs:
           name: ${{ steps.get_version.outputs.CURRENT_VERSION }}
           files: |
             dist/*
+            templates.tar.gz
         env:
           GITHUB_TOKEN: ${{ secrets.PAT }}
 

fabricatio-0.2.0.dev2/.github/workflows/tests.yaml

@@ -0,0 +1,32 @@
+name: Tests
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  test:
+    runs-on: windows-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Install the latest version of uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          version: "latest"
+
+      - name: Install deps
+        run: |
+          uv sync
+
+      - name: Build
+        run: |
+          pytest tests
+
+
+

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.0.dev0
+Version: 0.2.0.dev2
 Summary: A LLM multi-agent framework.
 Author-email: Whth <zettainspector@foxmail.com>
 License: MIT License
@@ -43,18 +43,61 @@ Requires-Dist: litellm>=1.60.0
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: magika>=0.5.1
 Requires-Dist: orjson>=3.10.15
+Requires-Dist: pybars3>=0.9.7
 Requires-Dist: pydantic-settings>=2.7.1
 Requires-Dist: pydantic>=2.10.6
 Requires-Dist: pymitter>=1.0.0
 Requires-Dist: questionary>=2.1.0
 Requires-Dist: regex>=2024.11.6
 Requires-Dist: rich>=13.9.4
+Requires-Dist: typer>=0.15.1
 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 +107,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 +123,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 +151,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.dev2/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.dev2}/examples/minor/hello_fabricatio.py

@@ -6,10 +6,10 @@ 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):
-    """Action that says hello to the world."""
+class Hello(Action):
+    """Action that says hello."""
 
-    name: str = "talk"
+    name: str = "hello"
     output_key: str = "task_output"
 
     async def _execute(self, task_input: Task[str], **_) -> Any:
@@ -20,7 +20,7 @@ class Talk(Action):
 
 async def main() -> None:
     """Main function."""
-    Role(name="talker", description="talker role", registry={task.pending_label: WorkFlow(name="talk", steps=(Talk,))})
+    Role(name="talker", description="talker role", registry={task.pending_label: WorkFlow(name="talk", steps=(Hello,))})
 
     logger.success(f"Result: {await task.delegate()}")
 

fabricatio-0.2.0.dev2/examples/simple_chat/chat.py

@@ -0,0 +1,31 @@
+import asyncio
+from typing import Any
+
+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):
+    """Action that says hello to the world."""
+
+    name: str = "talk"
+    output_key: str = "task_output"
+
+    async def _execute(self, task_input: Task[str], **_) -> Any:
+        ret = "Hello fabricatio!"
+        logger.info("executing talk action")
+        return ret
+
+
+async def main() -> None:
+    """Main function."""
+    role = Role(
+        name="talker", description="talker role", registry={task.pending_label: WorkFlow(name="talk", steps=(Talk,))}
+    )
+    logger.info(Task.json_example())
+    logger.info(f"proposed task: {await role.propose('say hello to Jhon')}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

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

@@ -1,6 +1,6 @@
 [project]
 name = "fabricatio"
-version = "0.2.0-dev.0"
+version = "0.2.0-dev.2"
 description = "A LLM multi-agent framework."
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -21,6 +21,9 @@ keywords = [
     "multi-agent",
     "llm",
 ]
+
+
+
 requires-python = ">=3.12"
 dependencies = [
     "aiohttp>=3.11.11",
@@ -33,15 +36,18 @@ dependencies = [
     "loguru>=0.7.3",
     "magika>=0.5.1",
     "orjson>=3.10.15",
+    "pybars3>=0.9.7",
     "pydantic>=2.10.6",
     "pydantic-settings>=2.7.1",
     "pymitter>=1.0.0",
     "questionary>=2.1.0",
     "regex>=2024.11.6",
     "rich>=13.9.4",
+    "typer>=0.15.1",
 ]
 
-
+[project.scripts]
+templates = "fabricatio.bin.template_download:download_and_extract"
 
 [build-system]
 requires = ["hatchling"]
@@ -60,15 +66,17 @@ dev = [
     "pytest-xdist>=3.6.1",
     "ruff>=0.9.4",
     "uv>=0.5.29",
-]
-cli = [
-    "typer>=0.15.1",
+    "viztracer>=1.0.2",
 ]
 rag = [
     "faiss-cpu>=1.10.0",
     "pymilvus>=2.5.4",
 ]
 
+full = [
+    { group = "rag" },
+]
+
 
 [tool.ruff]
 include = ["pyproject.toml", "src/fabricatio/*.py", "examples/*.py"]
@@ -129,15 +137,15 @@ testpaths = [
 code2prompt = { git = "https://github.com/mufeedvh/code2prompt" }
 
 [[tool.uv.index]]
-url = "https://mirrors.bfsu.edu.cn/pypi/web/simple"
-default = true
+url = "https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple"
 
 [[tool.uv.index]]
-url = "https://mirrors.aliyun.com/pypi/simple/"
+url = "https://mirrors.huaweicloud.com/repository/pypi/simple"
 
 [[tool.uv.index]]
-url = "https://mirrors.huaweicloud.com/repository/pypi/simple"
+url = "https://mirrors.aliyun.com/pypi/simple/"
 
 [[tool.uv.index]]
-url = "https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple"
+url = "https://mirrors.bfsu.edu.cn/pypi/web/simple"
+default = true
 

{fabricatio-0.2.0.dev0 → fabricatio-0.2.0.dev2}/src/fabricatio/__init__.py

@@ -1,24 +1,32 @@
 """Fabricatio is a Python library for building llm app using event-based agent structure."""
 
 from fabricatio.core import env
+from fabricatio.fs import magika
 from fabricatio.journal import logger
 from fabricatio.models.action import Action, WorkFlow
 from fabricatio.models.events import Event
 from fabricatio.models.role import Role
 from fabricatio.models.task import Task
 from fabricatio.models.tool import ToolBox
-from fabricatio.models.utils import Messages
-from fabricatio.parser import Capture
+from fabricatio.models.utils import Message, Messages
+from fabricatio.parser import Capture, CodeBlockCapture, JsonCapture, PythonCapture
+from fabricatio.templates import templates_manager
 
 __all__ = [
     "Action",
     "Capture",
+    "CodeBlockCapture",
     "Event",
+    "JsonCapture",
+    "Message",
     "Messages",
+    "PythonCapture",
     "Role",
     "Task",
     "ToolBox",
     "WorkFlow",
     "env",
     "logger",
+    "magika",
+    "templates_manager",
 ]

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

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

fabricatio-0.2.0.dev2/src/fabricatio/actions/communication.py

@@ -0,0 +1,13 @@
+from fabricatio.models.action import Action
+from fabricatio.models.task import Task
+
+
+class Talk(Action):
+    """Action that says hello to the world."""
+
+    name: str = "talk"
+    output_key: str = "talk_response"
+
+    async def _execute(self, task_input: Task[str], **_) -> str:
+        """Execute the action."""
+        return await self.aask(task_input.briefing, system_message=task_input.generate_prompt())

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

@@ -0,0 +1,32 @@
+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."
+    """The description of the action."""
+
+    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()
+
+
+class CycleTask(Action):
+    """An action that cycles a task through a list of targets."""
+
+    name: str = "cycle_task"
+    """The name of the action."""
+    description: str = "Cycle a task through a list of targets"
+
+    async def _execute(self, task_input: Task, **_) -> None:
+        """Execute the action by cycling the task through the specified targets."""