fabricatio 0.2.0.dev14__tar.gz → 0.2.0.dev16__tar.gz

{fabricatio-0.2.0.dev14 → fabricatio-0.2.0.dev16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.0.dev14
+Version: 0.2.0.dev16
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12

{fabricatio-0.2.0.dev14 → fabricatio-0.2.0.dev16}/examples/llm_usages/llm_usage.py

@@ -1,7 +1,10 @@
+"""Example of using the library."""
+
 import asyncio
-from typing import Any
+from typing import Any, Callable
 
 from fabricatio import Action, Role, Task, WorkFlow, logger
+from fabricatio.parser import PythonCapture
 
 task = Task(name="say hello", goal="say hello", description="say hello to the world")
 
@@ -13,9 +16,18 @@ class Talk(Action):
     output_key: str = "task_output"
 
     async def _execute(self, task_input: Task[str], **_) -> Any:
-        ret = "Hello fabricatio!"
+        def _validator(res: str) -> Callable[[float, float], float] | None:
+            code = PythonCapture.capture(res)
+            exec(code, None, locals())
+            if "addup" in locals():
+                return locals().get("addup")
+            return None
+
+        func = await self.aask_validate(
+            "make a python function which can compute addition of two numbers, with good typing, the function name shall be `addup`"
+        )
         logger.info("executing talk action")
-        return ret
+        return func
 
 
 async def main() -> None:
@@ -23,8 +35,6 @@ async def main() -> None:
     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('write a rust clap cli that can download a html page')}")
 
 
 if __name__ == "__main__":

{fabricatio-0.2.0.dev14 → fabricatio-0.2.0.dev16}/examples/minor/hello_fabricatio.py

@@ -1,3 +1,5 @@
+"""Example of a simple hello world program using fabricatio."""
+
 import asyncio
 from typing import Any
 

{fabricatio-0.2.0.dev14 → fabricatio-0.2.0.dev16}/examples/propose_task/propose.py

@@ -1,3 +1,5 @@
+"""Example of proposing a task to a role."""
+
 import asyncio
 from typing import Any
 

{fabricatio-0.2.0.dev14 → fabricatio-0.2.0.dev16}/examples/simple_chat/chat.py

@@ -1,3 +1,5 @@
+"""Simple chat example."""
+
 import asyncio
 from typing import Any
 

{fabricatio-0.2.0.dev14 → fabricatio-0.2.0.dev16}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fabricatio"
-version = "0.2.0-dev.14"
+version = "0.2.0-dev.16"
 description = "A LLM multi-agent framework."
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -82,7 +82,7 @@ full = [
 
 
 [tool.ruff]
-include = ["pyproject.toml", "python/fabricatio/*.py", "examples/*.py"]
+include = ["pyproject.toml", "python/fabricatio/*.py","python/fabricatio/*.pyi", "examples/*.py"]
 line-length = 120
 target-version = "py312"
 [tool.ruff.format]
@@ -117,11 +117,10 @@ select = [
     "RUF", # Ruff-specific rules
 ]
 ignore = [
-    "S101",
     "ANN401",
     "ANN003",
-    "D100",
     "PYI063",
+    "PYI021",
     "ASYNC109"
 ]
 [tool.ruff.lint.pydocstyle]

{fabricatio-0.2.0.dev14 → fabricatio-0.2.0.dev16}/python/fabricatio/_rust.pyi

@@ -1,13 +1,13 @@
 from pathlib import Path
-from typing import Dict, List, Any
-
+from typing import Any, Dict, List, Optional
 
 class TemplateManager:
-    def __init__(self, template_dirs: List[Path]) -> None:
-        """
-        Initialize the template manager.
+    def __init__(self, template_dirs: List[Path], suffix: Optional[str] = None) -> None:
+        """Initialize the template manager.
+
         Args:
             template_dirs (List[Path]): A list of paths to directories containing templates.
+            suffix (str, optional): The suffix of template files. None means 'hbs' suffix .
         """
 
     @property
@@ -19,8 +19,8 @@ class TemplateManager:
         """Get a list of template names."""
 
     def get_template(self, name: str) -> str:
-        """
-        Get a template by name.
+        """Get a template by name.
+
         Args:
             name (str): The name of the template to retrieve.
 
@@ -29,8 +29,8 @@ class TemplateManager:
         """
 
     def get_template_source(self, name: str) -> str:
-        """
-        Get the source path of a template by name.
+        """Get the source path of a template by name.
+
         Args:
             name (str): The name of the template to retrieve.
 
@@ -42,8 +42,8 @@ class TemplateManager:
         """Discover templates in the specified directories."""
 
     def render_template(self, name: str, data: Dict[str, Any]) -> str:
-        """
-        Render a template with the given name and data.
+        """Render a template with the given name and data.
+
         Args:
             name (str): The name of the template to render.
             data (Dict[str, Any]): The data to pass to the template.

fabricatio-0.2.0.dev16/python/fabricatio/_rust_instances.py

@@ -0,0 +1,4 @@
+from fabricatio._rust import TemplateManager
+from fabricatio.config import configs
+
+template_manager = TemplateManager(template_dirs=configs.templates.template_dir, suffix=configs.templates.template_suffix)

{fabricatio-0.2.0.dev14 → fabricatio-0.2.0.dev16}/python/fabricatio/actions/communication.py

@@ -1,3 +1,5 @@
+"""Actions that involve communication with the user."""
+
 from fabricatio.models.action import Action
 from fabricatio.models.task import Task
 

{fabricatio-0.2.0.dev14 → fabricatio-0.2.0.dev16}/python/fabricatio/actions/transmission.py

@@ -1,3 +1,5 @@
+"""Actions for transmitting tasks to targets."""
+
 from typing import List
 
 from fabricatio.journal import logger

{fabricatio-0.2.0.dev14 → fabricatio-0.2.0.dev16}/python/fabricatio/config.py

@@ -116,17 +116,17 @@ class DebugConfig(BaseModel):
     """The log file of the application."""
 
 
-class Code2PromptConfig(BaseModel):
-    """Code2Prompt configuration class."""
+class TemplateConfig(BaseModel):
+    """Template configuration class."""
 
     model_config = ConfigDict(use_attribute_docstrings=True)
     template_dir: List[DirectoryPath] = Field(
         default_factory=lambda: [DirectoryPath(r".\templates"), DirectoryPath(rf"{ROAMING_DIR}\templates")]
     )
-    """The directory containing the templates for code2prompt."""
+    """The directory containing the templates."""
 
-    template_suffix: str = Field(default=".hbs", frozen=True)
-    """The suffix of the template files for code2prompt."""
+    template_suffix: str = Field(default="hbs", frozen=True)
+    """The suffix of the templates."""
 
 
 class MagikaConfig(BaseModel):
@@ -137,6 +137,26 @@ class MagikaConfig(BaseModel):
     """The directory containing the models for magika."""
 
 
+class GeneralConfig(BaseModel):
+    """Global configuration class."""
+
+    model_config = ConfigDict(use_attribute_docstrings=True)
+    workspace: DirectoryPath = Field(default=DirectoryPath(r"."))
+    """The workspace directory for the application."""
+
+    confirm_on_fs_ops: bool = Field(default=True)
+    """Whether to confirm on file system operations."""
+
+
+class ToolBoxConfig(BaseModel):
+    """Toolbox configuration class."""
+
+    model_config = ConfigDict(use_attribute_docstrings=True)
+
+    tool_module_name: str = Field(default="Toolbox")
+    """The name of the module containing the toolbox."""
+
+
 class Settings(BaseSettings):
     """Application settings class.
 
@@ -144,7 +164,7 @@ class Settings(BaseSettings):
         llm (LLMConfig): LLM Configuration
         debug (DebugConfig): Debug Configuration
         pymitter (PymitterConfig): Pymitter Configuration
-        code2prompt (Code2PromptConfig): Code2Prompt Configuration
+        templates (TemplateConfig): Template Configuration
         magika (MagikaConfig): Magika Configuration
     """
 
@@ -167,20 +187,26 @@ class Settings(BaseSettings):
     pymitter: PymitterConfig = Field(default_factory=PymitterConfig)
     """Pymitter Configuration"""
 
-    code2prompt: Code2PromptConfig = Field(default_factory=Code2PromptConfig)
-    """Code2Prompt Configuration"""
+    templates: TemplateConfig = Field(default_factory=TemplateConfig)
+    """Template Configuration"""
 
     magika: MagikaConfig = Field(default_factory=MagikaConfig)
     """Magika Configuration"""
 
+    general: GeneralConfig = Field(default_factory=GeneralConfig)
+    """General Configuration"""
+
+    toolbox: ToolBoxConfig = Field(default_factory=ToolBoxConfig)
+    """Toolbox Configuration"""
+
     @classmethod
     def settings_customise_sources(
-            cls,
-            settings_cls: type[BaseSettings],
-            init_settings: PydanticBaseSettingsSource,
-            env_settings: PydanticBaseSettingsSource,
-            dotenv_settings: PydanticBaseSettingsSource,
-            file_secret_settings: PydanticBaseSettingsSource,
+        cls,
+        settings_cls: type[BaseSettings],
+        init_settings: PydanticBaseSettingsSource,
+        env_settings: PydanticBaseSettingsSource,
+        dotenv_settings: PydanticBaseSettingsSource,
+        file_secret_settings: PydanticBaseSettingsSource,
     ) -> tuple[PydanticBaseSettingsSource, ...]:
         """Customize settings sources.
 

fabricatio-0.2.0.dev16/python/fabricatio/decorators.py

@@ -0,0 +1,72 @@
+"""Decorators for Fabricatio."""
+
+from functools import wraps
+from inspect import signature
+from shutil import which
+from typing import Callable, Optional
+
+from questionary import confirm
+
+from fabricatio.config import configs
+from fabricatio.journal import logger
+
+
+def depend_on_external_cmd[**P, R](
+    bin_name: str, install_tip: Optional[str], homepage: Optional[str] = None
+) -> Callable[[Callable[P, R]], Callable[P, R]]:
+    """Decorator to check for the presence of an external command.
+
+    Args:
+        bin_name (str): The name of the required binary.
+        install_tip (Optional[str]): Installation instructions for the required binary.
+        homepage (Optional[str]): The homepage of the required binary.
+
+    Returns:
+        Callable[[Callable[P, R]], Callable[P, R]]: A decorator that wraps the function to check for the binary.
+
+    Raises:
+        RuntimeError: If the required binary is not found.
+    """
+
+    def _decorator(func: Callable[P, R]) -> Callable[P, R]:
+        @wraps(func)
+        def _wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+            if which(bin_name) is None:
+                err = f"`{bin_name}` is required to run {func.__name__}{signature(func)}, please install it the to `PATH` first."
+                if install_tip is not None:
+                    err += f"\nInstall tip: {install_tip}"
+                if homepage is not None:
+                    err += f"\nHomepage: {homepage}"
+                logger.error(err)
+                raise RuntimeError(err)
+            return func(*args, **kwargs)
+
+        return _wrapper
+
+    return _decorator
+
+
+def confirm_to_execute[**P, R](func: Callable[P, R]) -> Callable[P, Optional[R]] | Callable[P, R]:
+    """Decorator to confirm before executing a function.
+
+    Args:
+        func (Callable): The function to be executed
+
+    Returns:
+        Callable: A decorator that wraps the function to confirm before execution.
+    """
+    if not configs.general.confirm_on_fs_ops:
+        # Skip confirmation if the configuration is set to False
+        return func
+
+    @wraps(func)
+    def _wrapper(*args: P.args, **kwargs: P.kwargs) -> Optional[R]:
+        if confirm(
+            f"Are you sure to execute function: {func.__name__}{signature(func)} \n📦 Args:{args}\n🔑 Kwargs:{kwargs}\n",
+            instruction="Please input [Yes/No] to proceed (default: Yes):",
+        ).ask():
+            return func(*args, **kwargs)
+        logger.warning(f"Function: {func.__name__}{signature(func)} canceled by user.")
+        return None
+
+    return _wrapper

fabricatio-0.2.0.dev16/python/fabricatio/fs/curd.py

@@ -0,0 +1,110 @@
+"""File system create, update, read, delete operations."""
+
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Union
+
+from fabricatio.decorators import depend_on_external_cmd
+from fabricatio.journal import logger
+
+
+def copy_file(src: Union[str, Path], dst: Union[str, Path]) -> None:
+    """Copy a file from source to destination.
+
+    Args:
+        src: Source file path
+        dst: Destination file path
+
+    Raises:
+        FileNotFoundError: If source file doesn't exist
+        shutil.SameFileError: If source and destination are the same
+    """
+    try:
+        shutil.copy(src, dst)
+        logger.info(f"Copied file from {src} to {dst}")
+    except OSError as e:
+        logger.error(f"Failed to copy file from {src} to {dst}: {e!s}")
+        raise
+
+
+def move_file(src: Union[str, Path], dst: Union[str, Path]) -> None:
+    """Move a file from source to destination.
+
+    Args:
+        src: Source file path
+        dst: Destination file path
+
+    Raises:
+        FileNotFoundError: If source file doesn't exist
+        shutil.SameFileError: If source and destination are the same
+    """
+    try:
+        shutil.move(src, dst)
+        logger.info(f"Moved file from {src} to {dst}")
+    except OSError as e:
+        logger.error(f"Failed to move file from {src} to {dst}: {e!s}")
+        raise
+
+
+def delete_file(file_path: Union[str, Path]) -> None:
+    """Delete a file.
+
+    Args:
+        file_path: Path to the file to be deleted
+
+    Raises:
+        FileNotFoundError: If file doesn't exist
+        PermissionError: If no permission to delete the file
+    """
+    try:
+        Path(file_path).unlink()
+        logger.info(f"Deleted file: {file_path}")
+    except OSError as e:
+        logger.error(f"Failed to delete file {file_path}: {e!s}")
+        raise
+
+
+def create_directory(dir_path: Union[str, Path], parents: bool = True, exist_ok: bool = True) -> None:
+    """Create a directory.
+
+    Args:
+        dir_path: Path to the directory to create
+        parents: Create parent directories if they don't exist
+        exist_ok: Don't raise error if directory already exists
+    """
+    try:
+        Path(dir_path).mkdir(parents=parents, exist_ok=exist_ok)
+        logger.info(f"Created directory: {dir_path}")
+    except OSError as e:
+        logger.error(f"Failed to create directory {dir_path}: {e!s}")
+        raise
+
+
+@depend_on_external_cmd(
+    "erd",
+    "Please install `erd` using `cargo install erdtree` or `scoop install erdtree`.",
+    "https://github.com/solidiquis/erdtree",
+)
+def tree(dir_path: Union[str, Path]) -> str:
+    """Generate a tree representation of the directory structure. Requires `erd` to be installed."""
+    dir_path = Path(dir_path)
+    return subprocess.check_output(("erd", dir_path.as_posix()), encoding="utf-8")  # noqa: S603
+
+
+def delete_directory(dir_path: Union[str, Path]) -> None:
+    """Delete a directory and its contents.
+
+    Args:
+        dir_path: Path to the directory to delete
+
+    Raises:
+        FileNotFoundError: If directory doesn't exist
+        OSError: If directory is not empty and can't be removed
+    """
+    try:
+        shutil.rmtree(dir_path)
+        logger.info(f"Deleted directory: {dir_path}")
+    except OSError as e:
+        logger.error(f"Failed to delete directory {dir_path}: {e!s}")
+        raise

{fabricatio-0.2.0.dev14 → fabricatio-0.2.0.dev16}/python/fabricatio/fs/readers.py

@@ -1,3 +1,5 @@
+"""Filesystem readers for Fabricatio."""
+
 from magika import Magika
 
 from fabricatio.config import configs

{fabricatio-0.2.0.dev14 → fabricatio-0.2.0.dev16}/python/fabricatio/models/action.py

@@ -6,9 +6,10 @@ from asyncio import Queue
 from typing import Any, Dict, Self, Tuple, Type, Unpack
 
 from fabricatio.journal import logger
-from fabricatio.models.generic import LLMUsage, WithBriefing
-from fabricatio.models.task import ProposeTask, Task
-from fabricatio.models.tool import ToolBoxUsage
+from fabricatio.models.advanced import ProposeTask
+from fabricatio.models.generic import WithBriefing
+from fabricatio.models.task import Task
+from fabricatio.models.usages import ToolBoxUsage
 from pydantic import Field, PrivateAttr
 
 
@@ -51,7 +52,7 @@ class Action(ProposeTask, ToolBoxUsage):
         return f"# The action you are going to perform: \n{super().briefing}"
 
 
-class WorkFlow[A: Type[Action] | Action](WithBriefing, LLMUsage, ToolBoxUsage):
+class WorkFlow[A: Type[Action] | Action](WithBriefing, ToolBoxUsage):
     """Class that represents a workflow to be executed in a task."""
 
     _context: Queue[Dict[str, Any]] = PrivateAttr(default_factory=lambda: Queue(maxsize=1))

fabricatio-0.2.0.dev16/python/fabricatio/models/advanced.py

@@ -0,0 +1,96 @@
+"""A module for advanced models and functionalities."""
+
+from typing import List
+
+from fabricatio._rust_instances import template_manager
+from fabricatio.models.generic import WithBriefing
+from fabricatio.models.task import Task
+from fabricatio.models.usages import LLMUsage, ToolBoxUsage
+from fabricatio.parser import JsonCapture
+from loguru import logger
+from pydantic import NonNegativeFloat, PositiveInt, ValidationError
+
+
+class ProposeTask(LLMUsage, WithBriefing):
+    """A class that proposes a task based on a prompt."""
+
+    async def propose(
+        self,
+        prompt: str,
+        max_validations: PositiveInt = 2,
+        model: str | None = None,
+        temperature: NonNegativeFloat | None = None,
+        stop: str | List[str] | None = None,
+        top_p: NonNegativeFloat | None = None,
+        max_tokens: PositiveInt | None = None,
+        stream: bool | None = None,
+        timeout: PositiveInt | None = None,
+        max_retries: PositiveInt | None = None,
+    ) -> Task:
+        """Asynchronously proposes a task based on a given prompt and parameters.
+
+        Parameters:
+            prompt: The prompt text for proposing a task, which is a string that must be provided.
+            max_validations: The maximum number of validations allowed, default is 2.
+            model: The model to be used, default is None.
+            temperature: The sampling temperature, default is None.
+            stop: The stop sequence(s) for generation, default is None.
+            top_p: The nucleus sampling parameter, default is None.
+            max_tokens: The maximum number of tokens to be generated, default is None.
+            stream: Whether to stream the output, default is None.
+            timeout: The timeout for the operation, default is None.
+            max_retries: The maximum number of retries for the operation, default is None.
+
+        Returns:
+            A Task object based on the proposal result.
+        """
+        if not prompt:
+            err = f"{self.name}: Prompt must be provided."
+            logger.error(err)
+            raise ValueError(err)
+
+        def _validate_json(response: str) -> None | Task:
+            try:
+                cap = JsonCapture.capture(response)
+                logger.debug(f"Response: \n{response}")
+                logger.info(f"Captured JSON: \n{cap}")
+                return Task.model_validate_json(cap)
+            except ValidationError as e:
+                logger.error(f"Failed to parse task from JSON: {e}")
+                return None
+
+        template_data = {"prompt": prompt, "json_example": Task.json_example()}
+        return await self.aask_validate(
+            question=template_manager.render_template("propose_task", template_data),
+            validator=_validate_json,
+            system_message=f"# your personal briefing: \n{self.briefing}",
+            max_validations=max_validations,
+            model=model,
+            temperature=temperature,
+            stop=stop,
+            top_p=top_p,
+            max_tokens=max_tokens,
+            stream=stream,
+            timeout=timeout,
+            max_retries=max_retries,
+        )
+
+
+class HandleTask(WithBriefing, ToolBoxUsage):
+    """A class that handles a task based on a task object."""
+
+    async def handle[T](
+        self,
+        task: Task[T],
+        max_validations: PositiveInt = 2,
+        model: str | None = None,
+        temperature: NonNegativeFloat | None = None,
+        stop: str | List[str] | None = None,
+        top_p: NonNegativeFloat | None = None,
+        max_tokens: PositiveInt | None = None,
+        stream: bool | None = None,
+        timeout: PositiveInt | None = None,
+        max_retries: PositiveInt | None = None,
+    ) -> T:
+        """Asynchronously handles a task based on a given task object and parameters."""
+        # TODO: Implement the handle method

{fabricatio-0.2.0.dev14 → fabricatio-0.2.0.dev16}/python/fabricatio/models/events.py

@@ -47,8 +47,10 @@ class Event(BaseModel):
 
     def push(self, segment: str) -> Self:
         """Push a segment to the event."""
-        assert segment, "The segment must not be empty."
-        assert configs.pymitter.delimiter not in segment, "The segment must not contain the delimiter."
+        if not segment:
+            raise ValueError("The segment must not be empty.")
+        if configs.pymitter.delimiter in segment:
+            raise ValueError("The segment must not contain the delimiter.")
 
         self.segments.append(segment)
         return self