fabricatio 0.2.0.dev13__cp312-cp312-manylinux_2_34_x86_64.whl → 0.2.0.dev15__cp312-cp312-manylinux_2_34_x86_64.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/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,17 @@ 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 Settings(BaseSettings):
     """Application settings class.
 
@@ -144,7 +155,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 +178,22 @@ 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)
+
     @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,23 @@
 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 +30,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,12 +6,14 @@ 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.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
 
 
-class Action(ProposeTask):
+class Action(ProposeTask, ToolBoxUsage):
     """Class that represents an action to be executed in a workflow."""
 
     personality: str = Field(default="")
@@ -50,7 +52,7 @@ class Action(ProposeTask):
         return f"# The action you are going to perform: \n{super().briefing}"
 
 
-class WorkFlow[A: Type[Action] | Action](WithBriefing, LLMUsage):
+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))
@@ -121,7 +123,12 @@ class WorkFlow[A: Type[Action] | Action](WithBriefing, LLMUsage):
         logger.debug(f"Initializing context for workflow: {self.name}")
         await self._context.put({self.task_input_key: None, **dict(self.extra_init_context)})
 
-    def fallback_to_self(self) -> Self:
+    def steps_fallback_to_self(self) -> Self:
         """Set the fallback for each step to the workflow itself."""
         self.hold_to(self._instances)
         return self
+
+    def steps_supply_tools_from_self(self) -> Self:
+        """Supply the tools from the workflow to each step."""
+        self.provide_tools_to(self._instances)
+        return self

fabricatio/models/advanced.py

@@ -0,0 +1,93 @@
+"""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.
+        """
+        assert prompt, "Prompt must be provided."
+
+        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