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

fabricatio/models/task.py

@@ -0,0 +1,220 @@
+"""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
+
+
+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):
+    """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."""
+    _output: Queue = PrivateAttr(default_factory=lambda: Queue(maxsize=1))
+    status: TaskStatus = Field(default=TaskStatus.Pending)
+    """The status of the task."""
+    goal: str = Field(default="")
+    """The goal 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,63 @@
+from typing import Any, Self, Tuple
+
+from pydantic import Field, 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."""
+    _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)
+
+    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)

{fabricatio-0.1.0.dist-info → fabricatio-0.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.1.0
+Version: 0.1.1
 Summary: A LLM multi-agent framework.
 Author-email: Whth <zettainspector@foxmail.com>
 License: MIT License
@@ -25,6 +25,7 @@ License: MIT License
         OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
         SOFTWARE.
 License-File: LICENSE
+Keywords: agents,ai,llm,multi-agent
 Classifier: Framework :: AsyncIO
 Classifier: Framework :: Pydantic :: 2
 Classifier: License :: OSI Approved :: MIT License
@@ -36,11 +37,90 @@ Requires-Dist: aiohttp>=3.11.11
 Requires-Dist: aiomultiprocess>=0.9.1
 Requires-Dist: appdirs>=1.4.4
 Requires-Dist: asyncio>=3.4.3
+Requires-Dist: gitpython>=3.1.44
 Requires-Dist: litellm>=1.60.0
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: pydantic-settings>=2.7.1
 Requires-Dist: pydantic>=2.10.6
 Requires-Dist: pymitter>=1.0.0
+Requires-Dist: regex>=2024.11.6
 Requires-Dist: rich>=13.9.4
-Provides-Extra: cli
-Requires-Dist: typer>=0.15.1; extra == 'cli'
+Requires-Dist: shutilwhich>=1.1.0
+Description-Content-Type: text/markdown
+
+## Usage
+
+### Defining a Task
+
+```python
+from fabricatio.models.task import Task
+
+task = Task(name="say hello", goal="say hello", description="say hello to the world")
+```
+
+
+### Creating an Action
+
+```python
+from fabricatio import Action, logger
+from fabricatio.models.task import Task
+
+class Talk(Action):
+    async def _execute(self, task_input: Task[str], **_) -> Any:
+        ret = "Hello fabricatio!"
+        logger.info("executing talk action")
+        return ret
+```
+
+
+### Assigning a Role
+
+```python
+from fabricatio.models.role import Role
+from fabricatio.models.action import WorkFlow
+
+class TestWorkflow(WorkFlow):
+    pass
+
+role = Role(name="Test Role", actions=[TestWorkflow()])
+```
+
+
+### Logging
+
+Fabricatio uses Loguru for logging. You can configure the log level and file in the `config.py` file.
+
+```python
+from fabricatio.config import DebugConfig
+
+debug_config = DebugConfig(log_level="DEBUG", log_file="fabricatio.log")
+```
+
+
+## Configuration
+
+Fabricatio uses Pydantic for configuration management. You can define your settings in the `config.py` file.
+
+```python
+from fabricatio.config import Settings
+
+settings = Settings(llm=LLMConfig(api_endpoint="https://api.example.com"))
+```
+
+
+## Testing
+
+Fabricatio includes a set of tests to ensure the framework works as expected. You can run the tests using `pytest`.
+
+```bash
+pytest
+```
+
+
+## Contributing
+
+Contributions to Fabricatio are welcome! Please submit a pull request with your changes.
+
+## License
+
+Fabricatio is licensed under the MIT License. See the [LICENSE](LICENSE) file for more information.

fabricatio-0.1.1.dist-info/RECORD

@@ -0,0 +1,19 @@
+fabricatio/__init__.py,sha256=nFPtohqceECRYzU-WlVT6o4oSaKN0vGok-w9JIaiJfs,644
+fabricatio/config.py,sha256=Y-XPY23p6DrNk9YUMMpu1ECNON-hRUMUDePqeW6Qx0w,6954
+fabricatio/core.py,sha256=B6KBIfBRF023HF0UUaUprEkQd6sT7G_pexGXQ9btJnE,5788
+fabricatio/journal.py,sha256=CW9HePtgTiboOyPTExq9GjG5BseZcbc-S6lxDXrpmv0,667
+fabricatio/parser.py,sha256=Nxrfw-m0DVaI0wIE1b6LK67zXiYbQdXtv8ZqiZd3hbw,2096
+fabricatio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fabricatio/models/action.py,sha256=M-12dc-nQiNJU6Y9j-dr4Ef3642vRvzHlzxekBepzaU,3358
+fabricatio/models/events.py,sha256=0p42QmNDzmC76DhMwW1H_Mlg15MQ_XjEqkCJc8UkIB8,2055
+fabricatio/models/generic.py,sha256=_1HKN3tdU-SI1uEnMZnAaUFH1_7IvEOfyE0I8JP9TX8,14929
+fabricatio/models/role.py,sha256=0P8Ys84cHNYk1uhPfkJdIOl8-GiqO5y3gAE2IZX_MbQ,1123
+fabricatio/models/task.py,sha256=1ZTMktQGuCe7LGWfNFQEL-7M4adoKA_esmZgVS23CnU,6772
+fabricatio/models/tool.py,sha256=UkEp1Nzbl5wZX21q_Z2VkpiJmVDSdoGDzINQniO8hSY,3536
+fabricatio/models/utils.py,sha256=2mgXla9_K3dnRrz6hIKzmltTYPmvDk0MBjjEBkCXTdg,2474
+fabricatio/toolboxes/__init__.py,sha256=bjefmPd7wBaWhbZzdMPXvrjMTeRzlUh_Dev2PUAc124,158
+fabricatio/toolboxes/task.py,sha256=xgyPetm2R_HlQwpzE8YPnBN7QOYLd0-T8E6QPZG1PPQ,204
+fabricatio-0.1.1.dist-info/METADATA,sha256=2y5f2Z9wK_sOyKJpLHO6-CBRXZq9Z4JeMKnL7LFafD8,3766
+fabricatio-0.1.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+fabricatio-0.1.1.dist-info/licenses/LICENSE,sha256=do7J7EiCGbq0QPbMAL_FqLYufXpHnCnXBOuqVPwSV8Y,1088
+fabricatio-0.1.1.dist-info/RECORD,,

fabricatio/fs.py

@@ -1 +0,0 @@
-# TODO: fs capabilities impl