fabricatio 0.2.0.dev19__cp312-cp312-win_amd64.whl → 0.2.1__cp312-cp312-win_amd64.whl

fabricatio/_rust.pyi

@@ -1,5 +1,5 @@
 from pathlib import Path
-from typing import Dict, List, Optional
+from typing import Any, Dict, List, Optional
 
 class TemplateManager:
     """TemplateManager class for managing handlebars templates."""
@@ -31,12 +31,12 @@ class TemplateManager:
     def discover_templates(self) -> None:
         """Discover templates in the specified directories."""
 
-    def render_template(self, name: str, data: Dict[str, str]) -> str:
+    def render_template(self, name: str, data: Dict[str, Any]) -> str:
         """Render a template with the given name and data.
 
         Args:
             name (str): The name of the template to render.
-            data (Dict[str, str]): The data to pass to the template.
+            data (Dict[str, Any]): The data to pass to the template.
 
         Returns:
             str: The rendered template.

fabricatio/actions/communication.py

@@ -4,12 +4,12 @@ from fabricatio.models.action import Action
 from fabricatio.models.task import Task
 
 
-class Talk(Action):
-    """Action that says hello to the world."""
+class Examining(Action):
+    """Action that examines the input data."""
 
     name: str = "talk"
-    output_key: str = "talk_response"
+    output_key: str = "examine_pass"
 
-    async def _execute(self, task_input: Task[str], **_) -> str:
-        """Execute the action."""
-        return await self.aask(task_input.briefing, system_message=task_input.dependencies_prompt())
+    async def _execute(self, exam_target: Task[str], to_examine: str, **_) -> bool:
+        """Examine the input data."""
+        # TODO

fabricatio/actions/transmission.py

@@ -21,14 +21,3 @@ class PublishTask(Action):
         logger.info(f"Sending task {send_task.name} to {send_targets}")
         for target in send_targets:
             await send_task.move_to(target).publish()
-
-
-class CycleTask(Action):
-    """An action that cycles a task through a list of targets."""
-
-    name: str = "cycle_task"
-    """The name of the action."""
-    description: str = "Cycle a task through a list of targets"
-
-    async def _execute(self, task_input: Task, **_) -> None:
-        """Execute the action by cycling the task through the specified targets."""

fabricatio/config.py

@@ -89,7 +89,7 @@ class PymitterConfig(BaseModel):
     """
 
     model_config = ConfigDict(use_attribute_docstrings=True)
-    delimiter: str = Field(default=".", frozen=True)
+    delimiter: str = Field(default="::", frozen=True)
     """The delimiter used to separate the event name into segments."""
 
     new_listener_event: bool = Field(default=False, frozen=True)
@@ -115,6 +115,15 @@ class DebugConfig(BaseModel):
     log_file: FilePath = Field(default=rf"{ROAMING_DIR}\fabricatio.log")
     """The log file of the application."""
 
+    rotation: int = Field(default=1)
+    """The rotation of the log file. in weeks."""
+
+    retention: int = Field(default=2)
+    """The retention of the log file. in weeks."""
+
+    streaming_visible: bool = Field(default=False)
+    """Whether to print the llm output when streaming."""
+
 
 class TemplateConfig(BaseModel):
     """Template configuration class."""
@@ -145,6 +154,9 @@ class TemplateConfig(BaseModel):
     dependencies_template: str = Field(default="dependencies")
     """The name of the dependencies template which will be used to manage dependencies."""
 
+    task_briefing_template: str = Field(default="task_briefing")
+    """The name of the task briefing template which will be used to brief a task."""
+
 
 class MagikaConfig(BaseModel):
     """Magika configuration class."""
@@ -161,8 +173,8 @@ class GeneralConfig(BaseModel):
     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."""
+    confirm_on_ops: bool = Field(default=True)
+    """Whether to confirm on operations."""
 
 
 class ToolBoxConfig(BaseModel):
@@ -173,6 +185,9 @@ class ToolBoxConfig(BaseModel):
     tool_module_name: str = Field(default="Toolbox")
     """The name of the module containing the toolbox."""
 
+    data_module_name: str = Field(default="Data")
+    """The name of the module containing the data."""
+
 
 class Settings(BaseSettings):
     """Application settings class.

fabricatio/decorators.py

@@ -1,9 +1,11 @@
 """Decorators for Fabricatio."""
 
+from asyncio import iscoroutinefunction
 from functools import wraps
 from inspect import signature
 from shutil import which
-from typing import Callable, Optional
+from types import ModuleType
+from typing import Callable, List, Optional
 
 from questionary import confirm
 
@@ -46,6 +48,25 @@ def depend_on_external_cmd[**P, R](
     return _decorator
 
 
+def logging_execution_info[**P, R](func: Callable[P, R]) -> Callable[P, R]:
+    """Decorator to log the execution of a function.
+
+    Args:
+        func (Callable): The function to be executed
+
+    Returns:
+        Callable: A decorator that wraps the function to log the execution.
+    """
+
+    @wraps(func)
+    def _wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+        logger.info(f"Executing function: {func.__name__}{signature(func)}")
+        logger.debug(f"{func.__name__}{signature(func)}\nArgs: {args}\nKwargs: {kwargs}")
+        return func(*args, **kwargs)
+
+    return _wrapper
+
+
 def confirm_to_execute[**P, R](func: Callable[P, R]) -> Callable[P, Optional[R]] | Callable[P, R]:
     """Decorator to confirm before executing a function.
 
@@ -55,18 +76,104 @@ def confirm_to_execute[**P, R](func: Callable[P, R]) -> Callable[P, Optional[R]]
     Returns:
         Callable: A decorator that wraps the function to confirm before execution.
     """
-    if not configs.general.confirm_on_fs_ops:
+    if not configs.general.confirm_on_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
+    if iscoroutinefunction(func):
+
+        @wraps(func)
+        async def _wrapper(*args: P.args, **kwargs: P.kwargs) -> Optional[R]:
+            if await 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_async():
+                return await func(*args, **kwargs)
+            logger.warning(f"Function: {func.__name__}{signature(func)} canceled by user.")
+            return None
+
+    else:
+
+        @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
+
+
+def use_temp_module[**P, R](modules: ModuleType | List[ModuleType]) -> Callable[[Callable[P, R]], Callable[P, R]]:
+    """Temporarily inject modules into sys.modules during function execution.
+
+    This decorator allows you to temporarily inject one or more modules into sys.modules
+    while the decorated function executes. After execution, it restores the original
+    state of sys.modules.
+
+    Args:
+        modules (ModuleType | List[ModuleType]): A single module or list of modules to
+            temporarily inject into sys.modules.
+
+    Returns:
+        Callable[[Callable[P, R]], Callable[P, R]]: A decorator that handles temporary
+            module injection.
+
+    Examples:
+        ```python
+        from types import ModuleSpec, ModuleType, module_from_spec
+
+        # Create a temporary module
+        temp_module = module_from_spec(ModuleSpec("temp_math", None))
+        temp_module.pi = 3.14
+
+        # Use the decorator to temporarily inject the module
+        @use_temp_module(temp_module)
+        def calculate_area(radius: float) -> float:
+            from temp_math import pi
+            return pi * radius ** 2
+
+        # The temp_module is only available inside the function
+        result = calculate_area(5.0)  # Uses temp_module.pi
+        ```
+
+        Multiple modules can also be injected:
+        ```python
+        module1 = module_from_spec(ModuleSpec("mod1", None))
+        module2 = module_from_spec(ModuleSpec("mod2", None))
+
+        @use_temp_module([module1, module2])
+        def process_data():
+            import mod1, mod2
+            # Work with temporary modules
+            ...
+        ```
+    """
+    module_list = [modules] if isinstance(modules, ModuleType) else modules
+
+    def _decorator(func: Callable[P, R]) -> Callable[P, R]:
+        @wraps(func)
+        def _wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+            import sys
+
+            # Store original modules if they exist
+            for module in module_list:
+                if module.__name__ in sys.modules:
+                    raise RuntimeError(
+                        f"Module '{module.__name__}' is already present in sys.modules and cannot be overridden."
+                    )
+                sys.modules[module.__name__] = module
+
+            try:
+                return func(*args, **kwargs)
+            finally:
+                # Restore original state
+                for module in module_list:
+                    del sys.modules[module.__name__]
+
+        return _wrapper
+
+    return _decorator

fabricatio/fs/curd.py

@@ -5,11 +5,25 @@ import subprocess
 from pathlib import Path
 from typing import Union
 
-from fabricatio.decorators import confirm_to_execute, depend_on_external_cmd
+from fabricatio.decorators import depend_on_external_cmd, logging_execution_info
 from fabricatio.journal import logger
 
 
-@confirm_to_execute
+@logging_execution_info
+def dump_text(path: Union[str, Path], text: str) -> None:
+    """Dump text to a file. you need to make sure the file's parent directory exists.
+
+    Args:
+        path(str, Path): Path to the file
+        text(str): Text to write to the file
+
+    Returns:
+        None
+    """
+    Path(path).write_text(text, encoding="utf-8", errors="ignore")
+
+
+@logging_execution_info
 def copy_file(src: Union[str, Path], dst: Union[str, Path]) -> None:
     """Copy a file from source to destination.
 
@@ -29,7 +43,7 @@ def copy_file(src: Union[str, Path], dst: Union[str, Path]) -> None:
         raise
 
 
-@confirm_to_execute
+@logging_execution_info
 def move_file(src: Union[str, Path], dst: Union[str, Path]) -> None:
     """Move a file from source to destination.
 
@@ -49,7 +63,7 @@ def move_file(src: Union[str, Path], dst: Union[str, Path]) -> None:
         raise
 
 
-@confirm_to_execute
+@logging_execution_info
 def delete_file(file_path: Union[str, Path]) -> None:
     """Delete a file.
 
@@ -68,7 +82,7 @@ def delete_file(file_path: Union[str, Path]) -> None:
         raise
 
 
-@confirm_to_execute
+@logging_execution_info
 def create_directory(dir_path: Union[str, Path], parents: bool = True, exist_ok: bool = True) -> None:
     """Create a directory.
 
@@ -85,7 +99,7 @@ def create_directory(dir_path: Union[str, Path], parents: bool = True, exist_ok:
         raise
 
 
-@confirm_to_execute
+@logging_execution_info
 @depend_on_external_cmd(
     "erd",
     "Please install `erd` using `cargo install erdtree` or `scoop install erdtree`.",
@@ -97,7 +111,7 @@ def tree(dir_path: Union[str, Path]) -> str:
     return subprocess.check_output(("erd", dir_path.as_posix()), encoding="utf-8")  # noqa: S603
 
 
-@confirm_to_execute
+@logging_execution_info
 def delete_directory(dir_path: Union[str, Path]) -> None:
     """Delete a directory and its contents.
 

fabricatio/journal.py

@@ -3,17 +3,22 @@
 import sys
 
 from loguru import logger
-from rich import traceback
+from rich import pretty, traceback
 
 from fabricatio.config import configs
 
+pretty.install()
 traceback.install()
 logger.remove()
 logger.add(
-    configs.debug.log_file, level=configs.debug.log_level, rotation="1 weeks", retention="1 month", compression="zip"
+    configs.debug.log_file,
+    level=configs.debug.log_level,
+    rotation=f"{configs.debug.rotation} weeks",
+    retention=f"{configs.debug.retention} weeks",
 )
 logger.add(sys.stderr, level=configs.debug.log_level)
 
+
 if __name__ == "__main__":
     logger.debug("This is a trace message.")
     logger.info("This is an information message.")

fabricatio/models/action.py

@@ -52,7 +52,7 @@ class Action(HandleTask, ProposeTask):
         return f"# The action you are going to perform: \n{super().briefing}"
 
 
-class WorkFlow[A: Union[Type[Action], Action]](WithBriefing, ToolBoxUsage):
+class WorkFlow(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))
@@ -61,7 +61,7 @@ class WorkFlow[A: Union[Type[Action], Action]](WithBriefing, ToolBoxUsage):
     _instances: Tuple[Action, ...] = PrivateAttr(...)
     """ The instances of the workflow steps."""
 
-    steps: Tuple[A, ...] = Field(...)
+    steps: Tuple[Union[Type[Action], Action], ...] = Field(...)
     """ The steps to be executed in the workflow, actions or action classes."""
     task_input_key: str = Field(default="task_input")
     """ The key of the task input data."""
@@ -111,7 +111,13 @@ class WorkFlow[A: Union[Type[Action], Action]](WithBriefing, ToolBoxUsage):
                 await self._context.put(modified_ctx)
                 current_action = step.name
             logger.info(f"Finished executing workflow: {self.name}")
-            await task.finish((await self._context.get()).get(self.task_output_key, None))
+            final_ctx = await self._context.get()
+            if self.task_output_key not in final_ctx:
+                logger.warning(
+                    f"Task output key: {self.task_output_key} not found in the context, None will be returned. You can check if `Action.output_key` is set the same as `WorkFlow.task_output_key`."
+                )
+
+            await task.finish(final_ctx.get(self.task_output_key, None))
         except RuntimeError as e:
             logger.error(f"Error during task: {current_action} execution: {e}")  # Log the exception
             logger.error(traceback.format_exc())  # Add this line to log the traceback

fabricatio/models/advanced.py

@@ -1,7 +1,7 @@
 """A module for advanced models and functionalities."""
 
 from types import CodeType
-from typing import List, Optional, Tuple, Unpack
+from typing import Any, Dict, List, Optional, Tuple, Unpack
 
 import orjson
 from fabricatio._rust_instances import template_manager
@@ -67,6 +67,7 @@ class HandleTask(WithBriefing, ToolBoxUsage):
         self,
         task: Task,
         tools: List[Tool],
+        data: Dict[str, Any],
         **kwargs: Unpack[LLMKwargs],
     ) -> Tuple[CodeType, List[str]]:
         """Asynchronously drafts the tool usage code for a task based on a given task object and tools."""
@@ -82,17 +83,23 @@ class HandleTask(WithBriefing, ToolBoxUsage):
                 to_extract := JsonCapture.convert_with(response, orjson.loads)
             ):
                 return source, to_extract
+
             return None
 
+        q = template_manager.render_template(
+            configs.templates.draft_tool_usage_code_template,
+            {
+                "data_module_name": configs.toolbox.data_module_name,
+                "tool_module_name": configs.toolbox.tool_module_name,
+                "task": task.briefing,
+                "deps": task.dependencies_prompt,
+                "tools": [{"name": t.name, "briefing": t.briefing} for t in tools],
+                "data": data,
+            },
+        )
+        logger.debug(f"Code Drafting Question: \n{q}")
         return await self.aask_validate(
-            question=template_manager.render_template(
-                configs.templates.draft_tool_usage_code_template,
-                {
-                    "tool_module_name": configs.toolbox.tool_module_name,
-                    "task": task.briefing,
-                    "tools": [tool.briefing for tool in tools],
-                },
-            ),
+            question=q,
             validator=_validator,
             system_message=f"# your personal briefing: \n{self.briefing}",
             **kwargs,
@@ -101,18 +108,20 @@ class HandleTask(WithBriefing, ToolBoxUsage):
     async def handle_fin_grind(
         self,
         task: Task,
+        data: Dict[str, Any],
         **kwargs: Unpack[LLMKwargs],
     ) -> Optional[Tuple]:
         """Asynchronously handles a task based on a given task object and parameters."""
-        logger.info(f"Handling task: {task.briefing}")
+        logger.info(f"Handling task: \n{task.briefing}")
 
         tools = await self.gather_tools(task)
-        logger.info(f"{self.name} have gathered {len(tools)} tools gathered")
+        logger.info(f"{self.name} have gathered {[t.name for t in tools]}")
 
         if tools:
-            executor = ToolExecutor(execute_sequence=tools)
-            code, to_extract = await self.draft_tool_usage_code(task, tools, **kwargs)
-            cxt = await executor.execute(code)
+            executor = ToolExecutor(candidates=tools, data=data)
+            code, to_extract = await self.draft_tool_usage_code(task, tools, data, **kwargs)
+
+            cxt = executor.execute(code)
             if to_extract:
                 return tuple(cxt.get(k) for k in to_extract)
 

fabricatio/models/generic.py

@@ -68,7 +68,7 @@ class WithDependency(Base):
     """Class that manages file dependencies."""
 
     dependencies: List[str] = Field(default_factory=list)
-    """The file dependencies of the task, a list of file paths."""
+    """The file dependencies which is needed to read or write to meet a specific requirement, a list of file paths."""
 
     def add_dependency[P: str | Path](self, dependency: P | List[P]) -> Self:
         """Add a file dependency to the task.
@@ -99,6 +99,26 @@ class WithDependency(Base):
             self.dependencies.remove(Path(d).as_posix())
         return self
 
+    def clear_dependencies(self) -> Self:
+        """Clear all file dependencies from the task.
+
+        Returns:
+            Self: The current instance of the task.
+        """
+        self.dependencies.clear()
+        return self
+
+    def override_dependencies[P: str | Path](self, dependencies: List[P]) -> Self:
+        """Override the file dependencies of the task.
+
+        Args:
+            dependencies (List[str | Path]): The file dependencies to override the task's dependencies.
+
+        Returns:
+            Self: The current instance of the task.
+        """
+        return self.clear_dependencies().add_dependency(dependencies)
+
     @property
     def dependencies_prompt(self) -> str:
         """Generate a prompt for the task based on the file dependencies.
@@ -109,7 +129,8 @@ class WithDependency(Base):
         return template_manager.render_template(
             configs.templates.dependencies_template,
             {
-                (pth := Path(p)).as_posix(): {
+                (pth := Path(p)).name: {
+                    "path": pth.as_posix(),
                     "exists": pth.exists(),
                     "description": (identity := magika.identify_path(pth)).output.description,
                     "size": f"{pth.stat().st_size / (1024 * 1024) if pth.exists() and pth.is_file() else 0:.3f} MB",

fabricatio/models/role.py

@@ -9,7 +9,6 @@ from fabricatio.models.advanced import ProposeTask
 from fabricatio.models.events import Event
 from fabricatio.models.tool import ToolBox
 from fabricatio.models.usages import ToolBoxUsage
-from fabricatio.toolboxes import basic_toolboxes
 from pydantic import Field
 
 
@@ -19,7 +18,7 @@ class Role(ProposeTask, ToolBoxUsage):
     registry: dict[Event | str, WorkFlow] = Field(...)
     """ The registry of events and workflows."""
 
-    toolboxes: Set[ToolBox] = Field(default=basic_toolboxes)
+    toolboxes: Set[ToolBox] = Field(default_factory=set)
 
     def model_post_init(self, __context: Any) -> None:
         """Register the workflows in the role to the event bus."""

fabricatio/models/task.py

@@ -7,6 +7,8 @@ from asyncio import Queue
 from enum import Enum
 from typing import Any, List, Optional, Self
 
+from fabricatio._rust_instances import template_manager
+from fabricatio.config import configs
 from fabricatio.core import env
 from fabricatio.journal import logger
 from fabricatio.models.events import Event, EventLike
@@ -49,8 +51,8 @@ class Task[T](WithBriefing, WithJsonExample, WithDependency):
     description: str = Field(default="")
     """The description of the task."""
 
-    goal: str = Field(default="")
-    """The goal of the task."""
+    goal: List[str] = Field(default=[])
+    """The goal of the task, a list of strings."""
 
     namespace: List[str] = Field(default_factory=list)
     """The namespace of the task, a list of namespace segment, as string."""
@@ -97,12 +99,12 @@ class Task[T](WithBriefing, WithJsonExample, WithDependency):
         return self
 
     @classmethod
-    def simple_task(cls, name: str, goal: str, description: str) -> Self:
+    def simple_task(cls, name: str, goal: List[str], description: str) -> Self:
         """Create a simple task with a name, goal, and description.
 
         Args:
             name (str): The name of the task.
-            goal (str): The goal of the task.
+            goal (List[str]): The goal of the task.
             description (str): The description of the task.
 
         Returns:
@@ -110,18 +112,18 @@ class Task[T](WithBriefing, WithJsonExample, WithDependency):
         """
         return cls(name=name, goal=goal, description=description)
 
-    def update_task(self, goal: Optional[str] = None, description: Optional[str] = None) -> Self:
+    def update_task(self, goal: Optional[List[str] | str] = None, description: Optional[str] = None) -> Self:
         """Update the goal and description of the task.
 
         Args:
-            goal (str, optional): The new goal of the task.
+            goal (str|List[str], optional): The new goal of the task.
             description (str, optional): The new description of the task.
 
         Returns:
             Task: The updated instance of the `Task` class.
         """
         if goal:
-            self.goal = goal
+            self.goal = goal if isinstance(goal, list) else [goal]
         if description:
             self.description = description
         return self
@@ -214,7 +216,7 @@ class Task[T](WithBriefing, WithJsonExample, WithDependency):
         Returns:
             Task: The running instance of the `Task` class.
         """
-        logger.info(f"Starting task {self.name}")
+        logger.info(f"Starting task `{self.name}`")
         self._status = TaskStatus.Running
         await env.emit_async(self.running_label, self)
         return self
@@ -225,6 +227,7 @@ class Task[T](WithBriefing, WithJsonExample, WithDependency):
         Returns:
             Task: The cancelled instance of the `Task` class.
         """
+        logger.info(f"Cancelling task `{self.name}`")
         self._status = TaskStatus.Cancelled
         await env.emit_async(self.cancelled_label, self)
         return self
@@ -235,7 +238,7 @@ class Task[T](WithBriefing, WithJsonExample, WithDependency):
         Returns:
             Task: The failed instance of the `Task` class.
         """
-        logger.error(f"Task {self.name} failed")
+        logger.info(f"Failing task `{self.name}`")
         self._status = TaskStatus.Failed
         await env.emit_async(self.failed_label, self)
         return self
@@ -267,4 +270,7 @@ class Task[T](WithBriefing, WithJsonExample, WithDependency):
         Returns:
             str: The briefing of the task.
         """
-        return f"{super().briefing}\n{self.goal}"
+        return template_manager.render_template(
+            configs.templates.task_briefing_template,
+            self.model_dump(),
+        )