fabricatio 0.2.3.dev2__tar.gz → 0.2.4.dev0__tar.gz

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

@@ -40,6 +40,16 @@ jobs:
           fi
         shell: bash
 
+      - name: check if is prerelease
+        id: check_prerelease
+        run: |
+          if [[ "${{ steps.get_version.outputs.CURRENT_VERSION }}" == *"-"* ]]; then
+            echo "IS_PRERELEASE=true" >> $GITHUB_OUTPUT
+          else
+            echo "IS_PRERELEASE=false" >> $GITHUB_OUTPUT
+          fi
+        shell: bash
+
       - name: Install the latest version of uv
         uses: astral-sh/setup-uv@v5
         with:
@@ -69,6 +79,8 @@ jobs:
           files: |
             dist/*
             templates.tar.gz
+          prerelease: ${{ steps.check_prerelease.outputs.IS_PRERELEASE }}
+          generate_release_notes: true
         env:
           GITHUB_TOKEN: ${{ secrets.PAT }}
 

{fabricatio-0.2.3.dev2 → fabricatio-0.2.4.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.3.dev2
+Version: 0.2.4.dev0
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12
@@ -11,7 +11,6 @@ Classifier: Typing :: Typed
 Requires-Dist: appdirs>=1.4.4
 Requires-Dist: asyncio>=3.4.3
 Requires-Dist: asyncstdlib>=3.13.0
-Requires-Dist: gitpython>=3.1.44
 Requires-Dist: litellm>=1.60.0
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: magika>=0.5.1
@@ -37,13 +36,14 @@ 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)
 
+## Overview
+
 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
@@ -73,6 +73,7 @@ cd fabricatio
 uv --with-editable . maturin develop --uv -r
 ```
 
+
 ### Building Distribution
 
 For production builds:
@@ -82,24 +83,21 @@ For production builds:
 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
-
+from fabricatio import Action, Role, Task, logger, WorkFlow
+from typing import Any
 
 class Hello(Action):
-    """Action that says hello."""
-
     name: str = "hello"
     output_key: str = "task_output"
 
@@ -108,24 +106,24 @@ class Hello(Action):
         logger.info("executing talk action")
         return ret
 
-
 async def main() -> None:
-    """Main function."""
     role = Role(
-        name="talker", 
-        description="talker 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")
+    task = Task(name="say hello", goals="say hello", description="say hello to the world")
     result = await task.delegate()
     logger.success(f"Result: {result}")
 
-
 if __name__ == "__main__":
     asyncio.run(main())
 ```
 
+
+### Advanced Examples
+
 #### Writing and Dumping Code
 
 ```python
@@ -134,21 +132,14 @@ from fabricatio import Action, Event, PythonCapture, Role, Task, ToolBox, WorkFl
 
 
 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,
-        )
+        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}
@@ -160,20 +151,18 @@ class DumpCode(Action):
 
 
 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)
+    proposed_task = await role.propose_task(prompt)
     path = await proposed_task.move_to("coding").delegate()
     logger.success(f"Code Path: {path}")
 
@@ -182,112 +171,8 @@ 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
+### Template Management and Rendering
 
 ```python
 from fabricatio._rust_instances import template_manager
@@ -303,7 +188,8 @@ rendered_template = template_manager.render_template(template_name, data)
 print(rendered_template)
 ```
 
-#### Handling Security Vulnerabilities
+
+### Handling Security Vulnerabilities
 
 ```python
 from fabricatio.models.usages import ToolBoxUsage
@@ -314,17 +200,18 @@ toolbox_usage = ToolBoxUsage()
 async def handle_security_vulnerabilities():
     task = Task(
         name="Security Check",
-        goal=["Identify security vulnerabilities"],
+        goals=["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
+
+### Managing CTF Challenges
 
 ```python
 import asyncio
@@ -337,19 +224,21 @@ 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"],
+        goals=[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"]))
+    asyncio.run(
+        solve_ctf_challenge("Binary Exploitation", "CTF Binary Exploitation Challenge", ["./challenges/binary_exploit"]))
 ```
 
-### Configuration
+
+## 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.
 
@@ -370,7 +259,8 @@ stream = false
 max_tokens = 8192
 ```
 
-### Development Setup
+
+## Development Setup
 
 To set up a development environment for Fabricatio:
 
@@ -380,22 +270,26 @@ To set up a development environment for Fabricatio:
    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
+
+## Contributing
 
 Contributions are welcome! Please follow these guidelines when contributing:
 
@@ -405,15 +299,13 @@ Contributions are welcome! Please follow these guidelines when contributing:
 4. Push to the branch (`git push origin feature/new-feature`).
 5. Create a new Pull Request.
 
-### License
+## License
 
 Fabricatio is licensed under the MIT License. See [LICENSE](LICENSE) for more details.
 
-### Acknowledgments
+## 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)
-
-