fabricatio 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

fabricatio/models/role.py

@@ -1,14 +1,50 @@
-from typing import List
+from typing import Any
 
-from pydantic import Field
+from pydantic import Field, ValidationError
 
+from fabricatio.core import env
+from fabricatio.journal import logger
 from fabricatio.models.action import WorkFlow
-from fabricatio.models.generic import Memorable, WithToDo, WithBriefing, LLMUsage
+from fabricatio.models.events import Event
+from fabricatio.models.generic import LLMUsage, Memorable, WithBriefing, WithToDo
+from fabricatio.models.task import Task
+from fabricatio.parser import JsonCapture
 
 
-class Role[T: WorkFlow](Memorable, WithBriefing, WithToDo, LLMUsage):
-    workflows: List[T] = Field(frozen=True)
-    """A list of action names that the role can perform."""
+class Role(Memorable, WithBriefing, WithToDo, LLMUsage):
+    """Class that represents a role with a registry of events and workflows."""
 
-    async def act(self):
-        pass
+    registry: dict[Event | str, WorkFlow] = Field(...)
+    """ The registry of events and workflows."""
+
+    def model_post_init(self, __context: Any) -> None:
+        """Register the workflows in the role to the event bus."""
+        for event, workflow in self.registry.items():
+            workflow.fallback_to(self)
+            logger.debug(
+                f"Registering workflow: {workflow.name} for event: {event.collapse() if isinstance(event, Event) else event}"
+            )
+            env.on(event, workflow.serve)
+
+    async def propose(self, prompt: str) -> Task:
+        """Propose a task based on the provided prompt."""
+        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[0]}")
+                return Task.model_validate_json(cap[0] if cap else response)
+            except ValidationError as e:
+                logger.error(f"Failed to parse task from JSON: {e}")
+                return None
+
+        return await self.aask_validate(
+            f"{prompt} \n\nBased on requirement above, "
+            f"you need to construct a task to satisfy that requirement in JSON format "
+            f"written like this: \n\n```json\n{Task.json_example()}\n```\n\n"
+            f"No extra explanation needed. ",
+            _validate_json,
+            system_message=f"# your personal briefing: \n{self.briefing}",
+        )

fabricatio/models/task.py

@@ -0,0 +1,224 @@
+"""This module defines the Task class, which represents a task with a status and output.
+
+It includes methods to manage the task's lifecycle, such as starting, finishing, cancelling, and failing the task.
+"""
+
+from asyncio import Queue
+from enum import Enum
+from typing import Optional, Self
+
+from pydantic import Field, PrivateAttr
+
+from fabricatio.config import configs
+from fabricatio.core import env
+from fabricatio.journal import logger
+from fabricatio.models.generic import WithBriefing, WithJsonExample
+
+
+class TaskStatus(Enum):
+    """Enum that represents the status of a task."""
+
+    Pending = "pending"
+    Running = "running"
+    Finished = "finished"
+    Failed = "failed"
+    Cancelled = "cancelled"
+
+
+class Task[T](WithBriefing, WithJsonExample):
+    """Class that represents a task with a status and output.
+
+    Attributes:
+        name (str): The name of the task.
+        description (str): The description of the task.
+        _output (Queue): The output queue of the task.
+        _status (TaskStatus): The status of the task.
+        goal (str): The goal of the task.
+    """
+
+    name: str = Field(...)
+    """The name of the task."""
+
+    description: str = Field(default="")
+    """The description of the task."""
+
+    goal: str = Field(default="")
+    """The goal of the task."""
+
+    _output: Queue = PrivateAttr(default_factory=lambda: Queue(maxsize=1))
+    """The output queue of the task."""
+    _status: TaskStatus = PrivateAttr(default=TaskStatus.Pending)
+    """The status of the task."""
+
+    @classmethod
+    def simple_task(cls, name: str, goal: 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.
+            description (str): The description of the task.
+
+        Returns:
+            Self: A new instance of the Task class.
+        """
+        return cls(name=name, goal=goal, description=description)
+
+    def update_task(self, goal: Optional[str] = None, description: Optional[str] = None) -> Self:
+        """Update the goal and description of the task.
+
+        Args:
+            goal (Optional[str]): The new goal of the task.
+            description (Optional[str]): The new description of the task.
+
+        Returns:
+            Self: The updated instance of the Task class.
+        """
+        if goal:
+            self.goal = goal
+        if description:
+            self.description = description
+        return self
+
+    async def get_output(self) -> T:
+        """Get the output of the task.
+
+        Returns:
+            T: The output of the task.
+        """
+        logger.debug(f"Getting output for task {self.name}")
+        return await self._output.get()
+
+    def status_label(self, status: TaskStatus) -> str:
+        """Return a formatted status label for the task.
+
+        Args:
+            status (TaskStatus): The status of the task.
+
+        Returns:
+            str: The formatted status label.
+        """
+        return f"{self.name}{configs.pymitter.delimiter}{status.value}"
+
+    @property
+    def pending_label(self) -> str:
+        """Return the pending status label for the task.
+
+        Returns:
+            str: The pending status label.
+        """
+        return self.status_label(TaskStatus.Pending)
+
+    @property
+    def running_label(self) -> str:
+        """Return the running status label for the task.
+
+        Returns:
+            str: The running status label.
+        """
+        return self.status_label(TaskStatus.Running)
+
+    @property
+    def finished_label(self) -> str:
+        """Return the finished status label for the task.
+
+        Returns:
+            str: The finished status label.
+        """
+        return self.status_label(TaskStatus.Finished)
+
+    @property
+    def failed_label(self) -> str:
+        """Return the failed status label for the task.
+
+        Returns:
+            str: The failed status label.
+        """
+        return self.status_label(TaskStatus.Failed)
+
+    @property
+    def cancelled_label(self) -> str:
+        """Return the cancelled status label for the task.
+
+        Returns:
+            str: The cancelled status label.
+        """
+        return self.status_label(TaskStatus.Cancelled)
+
+    async def finish(self, output: T) -> Self:
+        """Mark the task as finished and set the output.
+
+        Args:
+            output (T): The output of the task.
+
+        Returns:
+            Self: The finished instance of the Task class.
+        """
+        logger.info(f"Finishing task {self.name}")
+        self._status = TaskStatus.Finished
+        await self._output.put(output)
+        logger.debug(f"Output set for task {self.name}")
+        await env.emit_async(self.finished_label, self)
+        logger.debug(f"Emitted finished event for task {self.name}")
+        return self
+
+    async def start(self) -> Self:
+        """Mark the task as running.
+
+        Returns:
+            Self: The running instance of the Task class.
+        """
+        logger.info(f"Starting task {self.name}")
+        self._status = TaskStatus.Running
+        await env.emit_async(self.running_label, self)
+        return self
+
+    async def cancel(self) -> Self:
+        """Mark the task as cancelled.
+
+        Returns:
+            Self: The cancelled instance of the Task class.
+        """
+        self._status = TaskStatus.Cancelled
+        await env.emit_async(self.cancelled_label, self)
+        return self
+
+    async def fail(self) -> Self:
+        """Mark the task as failed.
+
+        Returns:
+            Self: The failed instance of the Task class.
+        """
+        logger.error(f"Task {self.name} failed")
+        self._status = TaskStatus.Failed
+        await env.emit_async(self.failed_label, self)
+        return self
+
+    async def publish(self) -> Self:
+        """Publish the task to the environment.
+
+        Returns:
+            Self: The published instance of the Task class.
+        """
+        logger.info(f"Publishing task {self.name}")
+        await env.emit_async(self.pending_label, self)
+        return self
+
+    async def delegate(self) -> T:
+        """Delegate the task to the environment.
+
+        Returns:
+            T: The output of the task.
+        """
+        logger.info(f"Delegating task {self.name}")
+        await env.emit_async(self.pending_label, self)
+        return await self.get_output()
+
+    @property
+    def briefing(self) -> str:
+        """Return a briefing of the task including its goal.
+
+        Returns:
+            str: The briefing of the task.
+        """
+        return f"{super().briefing}\n{self.goal}"

fabricatio/models/tool.py

@@ -1,80 +1,101 @@
-from inspect import signature, getfullargspec
-from typing import Callable, List
-
-from pydantic import Field
-
-from fabricatio.models.generic import WithBriefing
-
-
-class Tool[**P, R](WithBriefing):
-    """A class representing a tool with a callable source function."""
-    source: Callable[P, R]
-
-    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> R:
-        """Invoke the tool's source function with the provided arguments."""
-        return self.source(*args, **kwargs)
-
-    def briefing(self) -> str:
-        """Return a brief description of the tool.
-
-        Returns:
-            str: A brief description of the tool.
-        """
-        source_signature = str(signature(self.source))
-        # 获取源函数的返回类型
-        return_annotation = getfullargspec(self.source).annotations.get('return', 'None')
-        return f"{self.name}{source_signature} -> {return_annotation}\n{self.description}"
-
-
-class ToolBox(WithBriefing):
-    """A class representing a collection of tools."""
-    tools: List[Tool] = Field(default_factory=list)
-    """A list of tools in the toolbox."""
-
-    def collect_tool[**P, R](self, func: Callable[P, R]) -> Callable[P, R]:
-        """Add a callable function to the toolbox as a tool.
-
-        Args:
-            func (Callable[P, R]): The function to be added as a tool.
-
-        Returns:
-            Callable[P, R]: The added function.
-
-        Raises:
-            AssertionError: If the provided function is not callable or lacks a name.
-        """
-        assert callable(func), "The tool must be a callable function."
-        assert func.__name__, "The tool must have a name."
-
-        tool = Tool(source=func, name=func.__name__, description=func.__doc__ or "")
-        self.tools.append(tool)
-        return func
-
-    def briefing(self) -> str:
-        """Return a brief description of the toolbox.
-
-        Returns:
-            str: A brief description of the toolbox.
-        """
-        list_out = "\n\n".join([f'- {tool.briefing}' for tool in self.tools])
-        toc = (f"## {self.name}: {self.description}\n"
-               f"## {len(self.tools)} tools available:\n")
-        return f"{toc}\n\n{list_out}"
-
-    def invoke_tool[**P, R](self, name: str, *args: P.args, **kwargs: P.kwargs) -> R:
-        """Invoke a tool by name with the provided arguments.
-
-        Args:
-            name (str): The name of the tool to invoke.
-            *args (P.args): Positional arguments to pass to the tool.
-            **kwargs (P.kwargs): Keyword arguments to pass to the tool.
-
-        Returns:
-            R: The result of the tool's execution.
-
-        Raises:
-            AssertionError: If no tool with the specified name is found.
-        """
-        tool = next((tool for tool in self.tools if tool.name == name), None)
-        assert tool, f"No tool named {name} found."
-        return tool(*args, **kwargs)
+from inspect import getfullargspec, signature
+from typing import Any, Callable, List, Self
+
+from pydantic import Field
+
+from fabricatio.models.generic import WithBriefing
+
+
+class Tool[**P, R](WithBriefing):
+    """A class representing a tool with a callable source function."""
+
+    name: str = Field(default="")
+    """The name of the tool."""
+
+    description: str = Field(default="")
+    """The description of the tool."""
+
+    source: Callable[P, R]
+    """The source function of the tool."""
+
+    def model_post_init(self, __context: Any) -> None:
+        """Initialize the tool with a name and a source function."""
+        self.name = self.name or self.source.__name__
+        assert self.name, "The tool must have a name."
+        self.description = self.description or self.source.__doc__ or ""
+
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> R:
+        """Invoke the tool's source function with the provided arguments."""
+        return self.source(*args, **kwargs)
+
+    @property
+    def briefing(self) -> str:
+        """Return a brief description of the tool.
+
+        Returns:
+            str: A brief description of the tool.
+        """
+        source_signature = str(signature(self.source))
+        # 获取源函数的返回类型
+        return_annotation = getfullargspec(self.source).annotations.get("return", "None")
+        return f"{self.name}{source_signature} -> {return_annotation}\n{self.description}"
+
+
+class ToolBox(WithBriefing):
+    """A class representing a collection of tools."""
+
+    tools: List[Tool] = Field(default_factory=list)
+    """A list of tools in the toolbox."""
+
+    def collect_tool[**P, R](self, func: Callable[P, R]) -> Callable[P, R]:
+        """Add a callable function to the toolbox as a tool.
+
+        Args:
+            func (Callable[P, R]): The function to be added as a tool.
+
+        Returns:
+            Callable[P, R]: The added function.
+        """
+        self.tools.append(Tool(source=func))
+        return func
+
+    def add_tool[**P, R](self, func: Callable[P, R]) -> Self:
+        """Add a callable function to the toolbox as a tool.
+
+        Args:
+            func (Callable): The function to be added as a tool.
+
+        Returns:
+            Self: The current instance of the toolbox.
+        """
+        self.tools.append(Tool(source=func))
+        return self
+
+    @property
+    def briefing(self) -> str:
+        """Return a brief description of the toolbox.
+
+        Returns:
+            str: A brief description of the toolbox.
+        """
+        list_out = "\n\n".join([f"- {tool.briefing}" for tool in self.tools])
+        toc = f"## {self.name}: {self.description}\n## {len(self.tools)} tools available:"
+        return f"{toc}\n\n{list_out}"
+
+    def invoke_tool[**P, R](self, name: str, *args: P.args, **kwargs: P.kwargs) -> R:
+        """Invoke a tool by name with the provided arguments.
+
+        Args:
+            name (str): The name of the tool to invoke.
+            *args (P.args): Positional arguments to pass to the tool.
+            **kwargs (P.kwargs): Keyword arguments to pass to the tool.
+
+        Returns:
+            R: The result of the tool's execution.
+
+        Raises:
+            AssertionError: If no tool with the specified name is found.
+        """
+        tool = next((tool for tool in self.tools if tool.name == name), None)
+        assert tool, f"No tool named {name} found."
+        return tool(*args, **kwargs)

fabricatio/models/utils.py

@@ -1,9 +1,11 @@
-from typing import Literal, Self, List, Dict
+from typing import Dict, List, Literal, Self
 
-from pydantic import BaseModel, Field, ConfigDict
+from pydantic import BaseModel, ConfigDict, Field
 
 
 class Message(BaseModel):
+    """A class representing a message."""
+
     model_config = ConfigDict(use_attribute_docstrings=True)
     role: Literal["user", "system", "assistant"] = Field(default="user")
     """
@@ -16,13 +18,10 @@ class Message(BaseModel):
 
 
 class Messages(list):
-    """
-    A list of messages.
-    """
+    """A list of messages."""
 
     def add_message(self, role: Literal["user", "system", "assistant"], content: str) -> Self:
-        """
-        Adds a message to the list with the specified role and content.
+        """Adds a message to the list with the specified role and content.
 
         Args:
             role (Literal["user", "system", "assistant"]): The role of the message sender.
@@ -36,8 +35,7 @@ class Messages(list):
         return self
 
     def add_user_message(self, content: str) -> Self:
-        """
-        Adds a user message to the list with the specified content.
+        """Adds a user message to the list with the specified content.
 
         Args:
             content (str): The content of the user message.
@@ -48,8 +46,7 @@ class Messages(list):
         return self.add_message("user", content)
 
     def add_system_message(self, content: str) -> Self:
-        """
-        Adds a system message to the list with the specified content.
+        """Adds a system message to the list with the specified content.
 
         Args:
             content (str): The content of the system message.
@@ -60,8 +57,7 @@ class Messages(list):
         return self.add_message("system", content)
 
     def add_assistant_message(self, content: str) -> Self:
-        """
-        Adds an assistant message to the list with the specified content.
+        """Adds an assistant message to the list with the specified content.
 
         Args:
             content (str): The content of the assistant message.
@@ -72,8 +68,7 @@ class Messages(list):
         return self.add_message("assistant", content)
 
     def as_list(self) -> List[Dict[str, str]]:
-        """
-        Converts the messages to a list of dictionaries.
+        """Converts the messages to a list of dictionaries.
 
         Returns:
             list[dict]: A list of dictionaries representing the messages.

fabricatio/parser.py

@@ -0,0 +1,66 @@
+from typing import Any, Self, Tuple
+
+import regex
+from pydantic import Field, PositiveInt, PrivateAttr
+from regex import Pattern, compile
+
+from fabricatio.models.generic import Base
+
+
+class Capture(Base):
+    """A class to capture patterns in text using regular expressions.
+
+    Attributes:
+        pattern (str): The regular expression pattern to search for.
+        _compiled (Pattern): The compiled regular expression pattern.
+    """
+
+    target_groups: Tuple[int, ...] = Field(default_factory=tuple)
+    """The target groups to capture from the pattern."""
+    pattern: str = Field(frozen=True)
+    """The regular expression pattern to search for."""
+    flags: PositiveInt = Field(default=regex.DOTALL | regex.MULTILINE | regex.IGNORECASE, frozen=True)
+    """The flags to use when compiling the regular expression pattern."""
+    _compiled: Pattern = PrivateAttr()
+
+    def model_post_init(self, __context: Any) -> None:
+        """Initialize the compiled regular expression pattern after the model is initialized.
+
+        Args:
+            __context (Any): The context in which the model is initialized.
+        """
+        self._compiled = compile(self.pattern, self.flags)
+
+    def capture(self, text: str) -> Tuple[str, ...] | None:
+        """Capture the first occurrence of the pattern in the given text.
+
+        Args:
+            text (str): The text to search the pattern in.
+
+        Returns:
+            str | None: The captured text if the pattern is found, otherwise None.
+
+        """
+        match = self._compiled.search(text)
+        if match is None:
+            return None
+
+        if self.target_groups:
+            return tuple(match.group(g) for g in self.target_groups)
+        return (match.group(),)
+
+    @classmethod
+    def capture_code_block(cls, language: str) -> Self:
+        """Capture the first occurrence of a code block in the given text.
+
+        Args:
+            language (str): The text containing the code block.
+
+        Returns:
+            Self: The instance of the class with the captured code block.
+        """
+        return cls(pattern=f"```{language}\n(.*?)\n```", target_groups=(1,))
+
+
+JsonCapture = Capture.capture_code_block("json")
+PythonCapture = Capture.capture_code_block("python")

fabricatio/toolboxes/__init__.py

@@ -0,0 +1,7 @@
+"""Contains the built-in toolboxes for the Fabricatio package."""
+
+from fabricatio.toolboxes.task import TaskToolBox
+
+__all__ = [
+    "TaskToolBox",
+]

fabricatio/toolboxes/task.py

@@ -0,0 +1,4 @@
+from fabricatio.models.task import Task
+from fabricatio.models.tool import ToolBox
+
+TaskToolBox = ToolBox(name="TaskToolBox", description="A toolbox for tasks management.").add_tool(Task.simple_task)