fabricatio 0.2.0.dev20__cp312-cp312-manylinux_2_34_x86_64.whl → 0.2.1__cp312-cp312-manylinux_2_34_x86_64.whl

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)
@@ -173,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):
@@ -185,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/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."""

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.

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

@@ -51,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."""
@@ -99,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:
@@ -112,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
@@ -272,5 +272,5 @@ class Task[T](WithBriefing, WithJsonExample, WithDependency):
         """
         return template_manager.render_template(
             configs.templates.task_briefing_template,
-            self.model_dump(include={"name", "description", "dependencies", "goal"}),
+            self.model_dump(),
         )

fabricatio/models/tool.py

@@ -3,11 +3,11 @@
 from importlib.machinery import ModuleSpec
 from importlib.util import module_from_spec
 from inspect import iscoroutinefunction, signature
-from sys import modules
 from types import CodeType, ModuleType
 from typing import Any, Callable, Dict, List, Optional, Self, overload
 
 from fabricatio.config import configs
+from fabricatio.decorators import use_temp_module
 from fabricatio.journal import logger
 from fabricatio.models.generic import WithBriefing
 from pydantic import BaseModel, ConfigDict, Field
@@ -36,7 +36,7 @@ class Tool[**P, R](WithBriefing):
 
     def invoke(self, *args: P.args, **kwargs: P.kwargs) -> R:
         """Invoke the tool's source function with the provided arguments."""
-        logger.info(f"Invoking tool: {self.name} with args: {args} and kwargs: {kwargs}")
+        logger.info(f"Invoking tool: {self.name}")
         return self.source(*args, **kwargs)
 
     @property
@@ -127,21 +127,37 @@ class ToolExecutor(BaseModel):
     """A class representing a tool executor with a sequence of tools to execute."""
 
     model_config = ConfigDict(use_attribute_docstrings=True)
-    execute_sequence: List[Tool] = Field(default_factory=list, frozen=True)
+    candidates: List[Tool] = Field(default_factory=list, frozen=True)
     """The sequence of tools to execute."""
 
+    data: Dict[str, Any] = Field(default_factory=dict)
+    """The data that could be used when invoking the tools."""
+
     def inject_tools[M: ModuleType](self, module: Optional[M] = None) -> M:
-        """Inject the tools into the provided module."""
+        """Inject the tools into the provided module or default."""
         module = module or module_from_spec(spec=ModuleSpec(name=configs.toolbox.tool_module_name, loader=None))
-        for tool in self.execute_sequence:
+        for tool in self.candidates:
+            logger.debug(f"Injecting tool: {tool.name}")
             setattr(module, tool.name, tool.invoke)
         return module
 
+    def inject_data[M: ModuleType](self, module: Optional[M] = None) -> M:
+        """Inject the data into the provided module or default."""
+        module = module or module_from_spec(spec=ModuleSpec(name=configs.toolbox.data_module_name, loader=None))
+        for key, value in self.data.items():
+            logger.debug(f"Injecting data: {key}")
+            setattr(module, key, value)
+        return module
+
     def execute[C: Dict[str, Any]](self, source: CodeType, cxt: Optional[C] = None) -> C:
         """Execute the sequence of tools with the provided context."""
-        modules[configs.toolbox.tool_module_name] = self.inject_tools()
-        exec(source, cxt)  # noqa: S102
-        modules.pop(configs.toolbox.tool_module_name)
+        cxt = cxt or {}
+
+        @use_temp_module([self.inject_data(), self.inject_tools()])
+        def _exec() -> None:
+            exec(source, cxt)  # noqa: S102
+
+        _exec()
         return cxt
 
     @overload
@@ -169,4 +185,4 @@ class ToolExecutor(BaseModel):
             for toolbox in toolboxes:
                 tools.append(toolbox[tool_name])
 
-        return cls(execute_sequence=tools)
+        return cls(candidates=tools)

fabricatio/models/usages.py

@@ -225,19 +225,24 @@ class LLMUsage(Base):
             configs.templates.make_choice_template,
             {
                 "instruction": instruction,
-                "options": [m.model_dump(include={"name", "briefing"}) for m in choices],
+                "options": [{"name": m.name, "briefing": m.briefing} for m in choices],
                 "k": k,
             },
         )
-        names = [c.name for c in choices]
+        names = {c.name for c in choices}
+        logger.debug(f"Start choosing between {names} with prompt: \n{prompt}")
 
         def _validate(response: str) -> List[T] | None:
             ret = JsonCapture.convert_with(response, orjson.loads)
-            if not isinstance(ret, List) or len(ret) != k:
+
+            if not isinstance(ret, List) or (0 < k != len(ret)):
+                logger.error(f"Incorrect Type or length of response: \n{ret}")
                 return None
             if any(n not in names for n in ret):
+                logger.error(f"Invalid choice in response: \n{ret}")
                 return None
-            return ret
+
+            return [next(toolbox for toolbox in choices if toolbox.name == toolbox_str) for toolbox_str in ret]
 
         return await self.aask_validate(
             question=prompt,
@@ -247,6 +252,41 @@ class LLMUsage(Base):
             **kwargs,
         )
 
+    async def apick[T: WithBriefing](
+        self,
+        instruction: str,
+        choices: List[T],
+        max_validations: PositiveInt = 2,
+        system_message: str = "",
+        **kwargs: Unpack[LLMKwargs],
+    ) -> T:
+        """Asynchronously picks a single choice from a list of options using AI validation.
+
+        This method is a convenience wrapper around `achoose` that always selects exactly one item.
+
+        Args:
+            instruction (str): The user-provided instruction/question description.
+            choices (List[T]): A list of candidate options, requiring elements to have `name` and `briefing` fields.
+            max_validations (PositiveInt): Maximum number of validation failures, default is 2.
+            system_message (str): Custom system-level prompt, defaults to an empty string.
+            **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage, such as `model`,
+                `temperature`, `stop`, `top_p`, `max_tokens`, `stream`, `timeout`, and `max_retries`.
+
+        Returns:
+            T: The single selected item from the choices list.
+
+        Raises:
+            ValueError: If validation fails after maximum attempts or if no valid selection is made.
+        """
+        return await self.achoose(
+            instruction=instruction,
+            choices=choices,
+            k=1,
+            max_validations=max_validations,
+            system_message=system_message,
+            **kwargs,
+        )[0]
+
     async def ajudge(
         self,
         prompt: str,

fabricatio/parser.py

@@ -49,8 +49,12 @@ class Capture(BaseModel):
             return None
 
         if self.target_groups:
-            return tuple(match.group(g) for g in self.target_groups)
-        return match.group(1)
+            cap = tuple(match.group(g) for g in self.target_groups)
+            logger.debug(f"Captured text: {'\n\n'.join(cap)}")
+            return cap
+        cap = match.group(1)
+        logger.debug(f"Captured text: \n{cap}")
+        return cap
 
     def convert_with[T](self, text: str, convertor: Callable[[Tuple[str, ...]], T] | Callable[[str], T]) -> T | None:
         """Convert the given text using the pattern.
@@ -62,12 +66,12 @@ class Capture(BaseModel):
         Returns:
             str | None: The converted text if the pattern is found, otherwise None.
         """
-        if cap := self.capture(text) is None:
+        if (cap := self.capture(text)) is None:
             return None
         try:
             return convertor(cap)
         except (ValueError, SyntaxError) as e:
-            logger.error(f"Failed to convert text using convertor: {convertor.__name__}, error: \n{e}")
+            logger.error(f"Failed to convert text using {convertor.__name__} to convert.\nerror: {e}\n {cap}")
             return None
 
     @classmethod