fabricatio 0.2.0.dev14__cp312-cp312-win_amd64.whl → 0.2.0.dev18__cp312-cp312-win_amd64.whl

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/_rust_instances.py

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

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/actions/transmission.py

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

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/decorators.py

@@ -1,16 +1,25 @@
+"""Decorators for Fabricatio."""
+
 from functools import wraps
+from inspect import signature
 from shutil import which
-from typing import Callable
+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: str) -> Callable[[Callable[P, R]], Callable[P, R]]:
+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 (str): Installation instructions for 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.
@@ -23,13 +32,41 @@ def depend_on_external_cmd[**P, R](bin_name: str, install_tip: str) -> Callable[
         @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 function: {func.__name__}, please install it first.\n{install_tip}"
-                )
-                logger.critical(err)
+                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/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/fs/readers.py

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

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/models/advanced.py

@@ -0,0 +1,119 @@
+"""A module for advanced models and functionalities."""
+
+from types import CodeType
+from typing import List, Optional, Tuple, Unpack
+
+import orjson
+from fabricatio._rust_instances import template_manager
+from fabricatio.config import configs
+from fabricatio.models.generic import WithBriefing
+from fabricatio.models.kwargs_types import LLMKwargs
+from fabricatio.models.task import Task
+from fabricatio.models.tool import Tool, ToolExecutor
+from fabricatio.models.usages import LLMUsage, ToolBoxUsage
+from fabricatio.parser import JsonCapture, PythonCapture
+from loguru import logger
+from pydantic import 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,
+        **kwargs: Unpack[LLMKwargs],
+    ) -> 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.
+            **kwargs: The keyword arguments for the LLM (Large Language Model) usage.
+
+        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,
+            **kwargs,
+        )
+
+
+class HandleTask(WithBriefing, ToolBoxUsage):
+    """A class that handles a task based on a task object."""
+
+    async def draft_tool_usage_code(
+        self,
+        task: Task,
+        tools: List[Tool],
+        **kwargs: Unpack[LLMKwargs],
+    ) -> Tuple[CodeType, List[str]]:
+        """Asynchronously drafts the tool usage code for a task based on a given task object and tools."""
+        logger.info(f"Drafting tool usage code for task: {task.briefing}")
+
+        if not tools:
+            err = f"{self.name}: Tools must be provided to draft the tool usage code."
+            logger.error(err)
+            raise ValueError(err)
+
+        def _validator(response: str) -> Tuple[CodeType, List[str]] | None:
+            if (source := PythonCapture.convert_with(response, lambda resp: compile(resp, "<string>", "exec"))) and (
+                to_extract := JsonCapture.convert_with(response, orjson.loads)
+            ):
+                return source, to_extract
+            return None
+
+        return await self.aask_validate(
+            question=template_manager.render_template(
+                "draft_tool_usage_code",
+                {
+                    "tool_module_name": configs.toolbox.tool_module_name,
+                    "task": task.briefing,
+                    "tools": [tool.briefing for tool in tools],
+                },
+            ),
+            validator=_validator,
+            system_message=f"# your personal briefing: \n{self.briefing}",
+            **kwargs,
+        )
+
+    async def handle_fin_grind(
+        self,
+        task: Task,
+        **kwargs: Unpack[LLMKwargs],
+    ) -> Optional[Tuple]:
+        """Asynchronously handles a task based on a given task object and parameters."""
+        logger.info(f"Handling task: {task.briefing}")
+
+        tools = await self.gather_tools(task)
+        logger.info(f"{self.name} have gathered {len(tools)} tools gathered")
+
+        if tools:
+            executor = ToolExecutor(execute_sequence=tools)
+            code, to_extract = await self.draft_tool_usage_code(task, tools, **kwargs)
+            cxt = await executor.execute(code)
+            if to_extract:
+                return tuple(cxt.get(k) for k in to_extract)
+
+        return None

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