fabricatio 0.2.1.dev0__cp313-cp313-win_amd64.whl

fabricatio/toolboxes/__init__.py

@@ -0,0 +1,17 @@
+"""Contains the built-in toolboxes for the Fabricatio package."""
+
+from typing import Set
+
+from fabricatio.models.tool import ToolBox
+from fabricatio.toolboxes.arithmetic import arithmetic_toolbox
+from fabricatio.toolboxes.fs import fs_toolbox
+from fabricatio.toolboxes.task import task_toolbox
+
+basic_toolboxes: Set[ToolBox] = {task_toolbox, arithmetic_toolbox}
+
+__all__ = [
+    "arithmetic_toolbox",
+    "basic_toolboxes",
+    "fs_toolbox",
+    "task_toolbox",
+]

fabricatio/toolboxes/arithmetic.py

@@ -0,0 +1,62 @@
+"""Arithmetic tools for Fabricatio."""
+
+from fabricatio.models.tool import ToolBox
+
+arithmetic_toolbox = ToolBox(name="ArithmeticToolBox", description="A toolbox for arithmetic operations.")
+
+
+@arithmetic_toolbox.collect_tool
+def add(a: float, b: float) -> float:
+    """Add two numbers.
+
+    Args:
+        a (float): The first number.
+        b (float): The second number.
+
+    Returns:
+        float: The sum of the two numbers.
+    """
+    return a + b
+
+
+@arithmetic_toolbox.collect_tool
+def subtract(a: float, b: float) -> float:
+    """Subtract two numbers.
+
+    Args:
+        a (float): The first number.
+        b (float): The second number.
+
+    Returns:
+        float: The result of subtracting b from a.
+    """
+    return a - b
+
+
+@arithmetic_toolbox.collect_tool
+def multiply(a: float, b: float) -> float:
+    """Multiply two numbers.
+
+    Args:
+        a (float): The first number.
+        b (float): The second number.
+
+    Returns:
+        float: The product of the two numbers.
+    """
+    return a * b
+
+
+@arithmetic_toolbox.collect_tool
+def divide(a: float, b: float) -> float:
+    """Divide two numbers.
+
+    Args:
+        a (float): The numerator.
+        b (float): The denominator (must not be zero).
+
+    Returns:
+        float: The result of dividing a by b.
+
+    """
+    return a / b

fabricatio/toolboxes/fs.py

@@ -0,0 +1,15 @@
+"""File system tool box."""
+
+from fabricatio.fs.curd import copy_file, create_directory, delete_directory, delete_file, dump_text, move_file, tree
+from fabricatio.models.tool import ToolBox
+
+fs_toolbox = (
+    ToolBox(name="FsToolBox", description="A toolbox for basic file system operations.")
+    .add_tool(dump_text)
+    .add_tool(copy_file)
+    .add_tool(move_file)
+    .add_tool(delete_file)
+    .add_tool(tree)
+    .add_tool(delete_directory)
+    .add_tool(create_directory)
+)

fabricatio/toolboxes/task.py

@@ -0,0 +1,6 @@
+"""This module contains the toolbox for tasks management."""
+
+from fabricatio.models.task import Task
+from fabricatio.models.tool import ToolBox
+
+task_toolbox = ToolBox(name="TaskToolBox", description="A toolbox for tasks management.").add_tool(Task.simple_task)

fabricatio-0.2.1.dev0.dist-info/METADATA

@@ -0,0 +1,420 @@
+Metadata-Version: 2.4
+Name: fabricatio
+Version: 0.2.1.dev0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Framework :: AsyncIO
+Classifier: Framework :: Pydantic :: 2
+Classifier: Typing :: Typed
+Requires-Dist: appdirs>=1.4.4
+Requires-Dist: asyncio>=3.4.3
+Requires-Dist: asyncstdlib>=3.13.0
+Requires-Dist: code2prompt
+Requires-Dist: gitpython>=3.1.44
+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: pydantic>=2.10.6
+Requires-Dist: pydantic-settings>=2.7.1
+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: faiss-cpu>=1.10.0 ; extra == 'rag'
+Requires-Dist: pymilvus>=2.5.4 ; extra == 'rag'
+Requires-Dist: fabricatio[rag] ; extra == 'full'
+Provides-Extra: rag
+Provides-Extra: full
+License-File: LICENSE
+Summary: A LLM multi-agent framework.
+Keywords: ai,agents,multi-agent,llm,pyo3
+Author-email: Whth <zettainspector@foxmail.com>
+Requires-Python: >=3.12, <3.13
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Homepage, https://github.com/Whth/fabricatio
+Project-URL: Repository, https://github.com/Whth/fabricatio
+Project-URL: Issues, https://github.com/Whth/fabricatio/issues
+
+
+# Fabricatio
+
+![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)
+![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)
+![Build Status](https://img.shields.io/badge/build-passing-brightgreen)
+
+Fabricatio is a Python library designed for building LLM (Large Language Model) applications using an event-based agent structure. It integrates Rust for performance-critical tasks, utilizes Handlebars for templating, and employs PyO3 for Python bindings.
+
+## Features
+
+- **Event-Based Architecture**: Utilizes an EventEmitter pattern for robust task management.
+- **LLM Integration**: Supports interactions with large language models for intelligent task processing.
+- **Templating Engine**: Uses Handlebars for dynamic content generation.
+- **Toolboxes**: Provides predefined toolboxes for common operations like file manipulation and arithmetic.
+- **Async Support**: Fully asynchronous for efficient execution.
+- **Extensible**: Easy to extend with custom actions, workflows, and tools.
+
+## Installation
+
+### Using UV (Recommended)
+
+To install Fabricatio using `uv` (a package manager for Python):
+
+```bash
+# Install uv if not already installed
+pip install uv
+
+# Clone the repository
+git clone https://github.com/Whth/fabricatio.git
+cd fabricatio
+
+# Install the package in development mode with uv
+uv --with-editable . maturin develop --uv -r
+```
+
+### Building Distribution
+
+For production builds:
+
+```bash
+# Build distribution packages
+make bdist
+```
+
+This will generate distribution files in the `dist` directory.
+
+## Usage
+
+### Basic Example
+
+Below are some basic examples demonstrating how to use Fabricatio for different purposes.
+
+#### Simple Hello World Program
+
+```python
+import asyncio
+from fabricatio import Action, Role, Task, logger
+
+
+class Hello(Action):
+    """Action that says hello."""
+
+    name: str = "hello"
+    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=(Hello,))}
+    )
+
+    task = Task(name="say hello", goal="say hello", description="say hello to the world")
+    result = await task.delegate()
+    logger.success(f"Result: {result}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+#### Writing and Dumping Code
+
+```python
+import asyncio
+from fabricatio import Action, Event, PythonCapture, Role, Task, ToolBox, WorkFlow, fs_toolbox, logger
+
+
+class WriteCode(Action):
+    """Action that writes code based on a prompt."""
+
+    name: str = "write code"
+    output_key: str = "source_code"
+
+    async def _execute(self, task_input: Task[str], **_) -> str:
+        return await self.aask_validate(
+            task_input.briefing,
+            validator=PythonCapture.capture,
+        )
+
+
+class DumpCode(Action):
+    """Action that dumps code to the file system."""
+
+    name: str = "dump code"
+    description: str = "Dump code to file system"
+    toolboxes: set[ToolBox] = {fs_toolbox}
+    output_key: str = "task_output"
+
+    async def _execute(self, task_input: Task, source_code: str, **_) -> Any:
+        path = await self.handle_fin_grind(task_input, {"source_code": source_code})
+        return path[0] if path else None
+
+
+async def main() -> None:
+    """Main function."""
+    role = Role(
+        name="Coder",
+        description="A python coder who can write and document code",
+        registry={
+            Event.instantiate_from("coding.*").push("pending"): WorkFlow(
+                name="write code", steps=(WriteCode, DumpCode)
+            ),
+        },
+    )
+
+    prompt = "write a Python CLI app which prints 'hello world' n times with detailed Google-style docstring. Write the source code to `cli.py`."
+
+    proposed_task = await role.propose(prompt)
+    path = await proposed_task.move_to("coding").delegate()
+    logger.success(f"Code Path: {path}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+#### Proposing Tasks
+
+```python
+import asyncio
+from typing import Any
+
+from fabricatio import Action, Role, Task, WorkFlow, logger
+
+
+class WriteDocumentation(Action):
+    """Action that generates documentation for the code in markdown format."""
+
+    name: str = "write documentation"
+    description: str = "Write detailed documentation for the provided code."
+    output_key: str = "task_output"
+
+    async def _execute(self, task_input: Task[str], **_) -> str:
+        return await self.aask(task_input.briefing)
+
+
+async def main() -> None:
+    """Main function."""
+    role = Role(
+        name="Documenter",
+        description="Role responsible for writing documentation.",
+        registry={
+            "doc.*": WorkFlow(name="write documentation", steps=(WriteDocumentation,))
+        }
+    )
+
+    prompt = "write a Rust clap CLI that downloads an HTML page"
+    proposed_task = await role.propose(prompt)
+    documentation = await proposed_task.move_to("doc").delegate()
+    logger.success(f"Documentation:\n{documentation}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+#### Complex Workflow Handling
+
+```python
+import asyncio
+from fabricatio import Action, Event, Role, Task, WorkFlow, logger
+
+
+class WriteCode(Action):
+    """Action that writes code based on a prompt."""
+
+    name: str = "write code"
+    output_key: str = "source_code"
+
+    async def _execute(self, task_input: Task[str], **_) -> str:
+        return await self.aask_validate(
+            task_input.briefing,
+            validator=PythonCapture.capture,
+        )
+
+
+class WriteDocumentation(Action):
+    """Action that generates documentation for the code in markdown format."""
+
+    name: str = "write documentation"
+    description: str = "Write detailed documentation for the provided code."
+    output_key: str = "task_output"
+
+    async def _execute(self, task_input: Task[str], **_) -> str:
+        return await self.aask(task_input.briefing)
+
+
+async def main() -> None:
+    """Main function."""
+    role = Role(
+        name="Developer",
+        description="A developer who can write code and documentation.",
+        registry={
+            Event.instantiate_from("coding.*").push("pending"): WorkFlow(
+                name="write code", steps=(WriteCode,)
+            ),
+            Event.instantiate_from("doc.*").push("pending"): WorkFlow(
+                name="write documentation", steps=(WriteDocumentation,)
+            ),
+        }
+    )
+
+    # Propose a coding task
+    code_task_prompt = "write a Python CLI app which adds numbers from a file."
+    proposed_task = await role.propose(code_task_prompt)
+    code = await proposed_task.move_to("coding").delegate()
+    logger.success(f"Code:\n{code}")
+
+    # Propose a documentation task
+    doc_task_prompt = f"{code}\n\nwrite Readme.md file for the above code."
+    proposed_doc_task = await role.propose(doc_task_prompt)
+    documentation = await proposed_doc_task.move_to("doc").delegate()
+    logger.success(f"Documentation:\n{documentation}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+### Advanced Examples
+
+#### Template Management and Rendering
+
+```python
+from fabricatio._rust_instances import template_manager
+
+template_name = "claude-xml.hbs"
+data = {
+    "absolute_code_path": "/path/to/project",
+    "source_tree": "source tree content",
+    "files": [{"path": "file1.py", "code": "print('Hello')"}],
+}
+
+rendered_template = template_manager.render_template(template_name, data)
+print(rendered_template)
+```
+
+#### Handling Security Vulnerabilities
+
+```python
+from fabricatio.models.usages import ToolBoxUsage
+from fabricatio.models.task import Task
+
+toolbox_usage = ToolBoxUsage()
+
+async def handle_security_vulnerabilities():
+    task = Task(
+        name="Security Check",
+        goal=["Identify security vulnerabilities"],
+        description="Perform a thorough security review on the project.",
+        dependencies=["./src/main.py"]
+    )
+    
+    vulnerabilities = await toolbox_usage.gather_tools_fine_grind(task)
+    for vulnerability in vulnerabilities:
+        print(f"Found vulnerability: {vulnerability.name}")
+```
+
+#### Managing CTF Challenges
+
+```python
+import asyncio
+
+from fabricatio.models.usages import ToolBoxUsage
+from fabricatio.models.task import Task
+
+toolbox_usage = ToolBoxUsage()
+
+async def solve_ctf_challenge(challenge_name: str, challenge_description: str, files: list[str]):
+    task = Task(
+        name=challenge_name,
+        goal=[f"Solve {challenge_name} challenge"],
+        description=challenge_description,
+        dependencies=files
+    )
+    
+    solution = await toolbox_usage.gather_tools_fine_grind(task)
+    print(f"Challenge Solved: {solution}")
+
+if __name__ == "__main__":
+    asyncio.run(solve_ctf_challenge("Binary Exploitation", "CTF Binary Exploitation Challenge", ["./challenges/binary_exploit"]))
+```
+
+### Configuration
+
+The configuration for Fabricatio is managed via environment variables or TOML files. The default configuration file (`config.toml`) can be overridden by specifying a custom path.
+
+Example `config.toml`:
+
+```toml
+[llm]
+api_endpoint = "https://api.openai.com"
+api_key = "your_openai_api_key"
+timeout = 300
+max_retries = 3
+model = "gpt-3.5-turbo"
+temperature = 1.0
+stop_sign = ["\n\n\n", "User:"]
+top_p = 0.35
+generation_count = 1
+stream = false
+max_tokens = 8192
+```
+
+### Development Setup
+
+To set up a development environment for Fabricatio:
+
+1. **Clone the Repository**:
+   ```bash
+   git clone https://github.com/Whth/fabricatio.git
+   cd fabricatio
+   ```
+
+2. **Install Dependencies**:
+   ```bash
+   uv --with-editable . maturin develop --uv -r
+   ```
+
+3. **Run Tests**:
+   ```bash
+   make test
+   ```
+
+4. **Build Documentation**:
+   ```bash
+   make docs
+   ```
+
+### Contributing
+
+Contributions are welcome! Please follow these guidelines when contributing:
+
+1. Fork the repository.
+2. Create your feature branch (`git checkout -b feature/new-feature`).
+3. Commit your changes (`git commit -am 'Add new feature'`).
+4. Push to the branch (`git push origin feature/new-feature`).
+5. Create a new Pull Request.
+
+### License
+
+Fabricatio is licensed under the MIT License. See [LICENSE](LICENSE) for more details.
+
+### Acknowledgments
+
+Special thanks to the contributors and maintainers of:
+- [PyO3](https://github.com/PyO3/pyo3)
+- [Maturin](https://github.com/PyO3/maturin)
+- [Handlebars.rs](https://github.com/sunng87/handlebars-rust)
+
+

fabricatio-0.2.1.dev0.dist-info/RECORD

@@ -0,0 +1,35 @@
+fabricatio-0.2.1.dev0.dist-info/METADATA,sha256=-2x-7rkT5tiOu36bnmfWG-8JHewUxqssqjuT1O0PokQ,12378
+fabricatio-0.2.1.dev0.dist-info/WHEEL,sha256=XsgF4V7TnSmJTnuU62xP5hrnZJ48WDEWrpRztgXGPlM,96
+fabricatio-0.2.1.dev0.dist-info/licenses/LICENSE,sha256=do7J7EiCGbq0QPbMAL_FqLYufXpHnCnXBOuqVPwSV8Y,1088
+fabricatio/actions/communication.py,sha256=NZxIIncKgJSDyBrqNebUtH_haqtxHa8ld2TZxT3CMdU,429
+fabricatio/actions/transmission.py,sha256=xpvKqbXqgpi1BWy-vUUvmd8NZ1GhRNfsYUBp-l2jLyk,862
+fabricatio/actions/__init__.py,sha256=eFmFVPQvtNgFynIXBVr3eP-vWQDWCPng60YY5LXvZgg,115
+fabricatio/config.py,sha256=TVge_fujKzvEZhOZYiYOMXdVn0YZ9SL5L1_mDzyeFUg,10260
+fabricatio/core.py,sha256=yQK2ZrbPYDJOaNDp0Bky3muTkB-ZaQ1ld_Qfflm2dY0,5938
+fabricatio/decorators.py,sha256=cJHsxxbnMhc4SzPl4454CPLuDP3H0qbTrzV_U2rLPrs,6372
+fabricatio/fs/curd.py,sha256=faMstgGUiQ4k2AW3OXfvvWWTldTtKXco7QINYaMjmyA,3981
+fabricatio/fs/readers.py,sha256=eDL9QhKEd6xfJBZaiwraObpGJWWpUd9NVYHoIvWgVqY,551
+fabricatio/fs/__init__.py,sha256=lWcKYg0v3mv2LnnSegOQaTtlVDODU0vtw_s6iKU5IqQ,122
+fabricatio/journal.py,sha256=siqimKF0M_QaaOCMxtjr_BJVNyUIAQWILzE9Q4T6-7c,781
+fabricatio/models/action.py,sha256=1V3upL79e3ekyGXA4bSY70N60yeL0aWak7ZPBVsFE3A,5652
+fabricatio/models/advanced.py,sha256=xAt0rgxzpw-gw-1LwRhvIbYKoNI8kzzcYPvcL7Q1z1U,5027
+fabricatio/models/events.py,sha256=mrihNEFgQ5o7qFWja1z_qX8dnaTLwPBoJdVlzxQV5oM,2719
+fabricatio/models/generic.py,sha256=HRslLNvP6v6wWag0tGda1FtAbjbjn096583u_IrixWs,4823
+fabricatio/models/kwargs_types.py,sha256=lSZAxOnhFdQwRkm-NrbJVMSyBbfdeuVNx807LvJpEOo,901
+fabricatio/models/role.py,sha256=RPdOcjmM6KNyH310Vx4524JQG94P5sXl_3doSrRpiKQ,1802
+fabricatio/models/task.py,sha256=hogTBx74IAKfKDWghhWFR7i-LVQAn7L9PQM5tyOA5Rk,9257
+fabricatio/models/tool.py,sha256=wgNXtobDSWZTVmIrSSaS5oyxhSUYWXhS0S2o9acE2ls,6800
+fabricatio/models/usages.py,sha256=XYTJjxDVFE2Ek6QBcrk1iNz5OjUPtwIArWuG4LkeLw8,23121
+fabricatio/models/utils.py,sha256=i_kpcQpct04mQFk1nbcVGV-pl1YThWu4Qk3wbewzKkc,2535
+fabricatio/parser.py,sha256=uLabsvF07wRKW1PoTGuGEENCx3P4mhmuO8JkmOEkKko,3522
+fabricatio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fabricatio/toolboxes/arithmetic.py,sha256=WLqhY-Pikv11Y_0SGajwZx3WhsLNpHKf9drzAqOf_nY,1369
+fabricatio/toolboxes/fs.py,sha256=YkNgon5-bvCiPVEND9971W-6wj8btKNL6nGry2otn9I,498
+fabricatio/toolboxes/task.py,sha256=kU4a501awIDV7GwNDuSlK3_Ym-5OhCp5sS-insTmUmQ,269
+fabricatio/toolboxes/__init__.py,sha256=b13KmASO8q5fBLwew964fn9oH86ER5g-S1PgA4fZ_xs,482
+fabricatio/_rust.pyi,sha256=clhcURuiB9zlFo4m3VyoWQ8Xs4tvg6KNHXpF-ok9h4o,1703
+fabricatio/_rust_instances.py,sha256=dl0-yZ4UvT5g20tQgnPJpmqtkjFGXNG_YK4eLfi_ugQ,279
+fabricatio/__init__.py,sha256=opIrN8lGyT-h2If4Qez0bRuWBa3uIT9GsM9CZy7_XJ0,1100
+fabricatio/_rust.cp313-win_amd64.pyd,sha256=WzVDtyvJmqEVlGm2Gf4Izw55jGc8tsJQsRewAPJSfds,1266688
+fabricatio-0.2.1.dev0.data/scripts/tdown.exe,sha256=TttjO5FVoyqEtFzWjNDixFzNKFUEWwBMvnr6JzdUxnE,3423744
+fabricatio-0.2.1.dev0.dist-info/RECORD,,

fabricatio-0.2.1.dev0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.8.2)
+Root-Is-Purelib: false
+Tag: cp313-cp313-win_amd64

fabricatio-0.2.1.dev0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Whth Yotta
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.