fabricatio 0.1.3__py3-none-any.whl → 0.2.0.dev1__py3-none-any.whl

fabricatio/actions/__init__.py

@@ -1,5 +1,5 @@
 """module for actions."""
 
-from fabricatio.actions.transmission import SendTask
+from fabricatio.actions.transmission import PublishTask
 
-__all__ = ["SendTask"]
+__all__ = ["PublishTask"]

fabricatio/actions/transmission.py

@@ -2,15 +2,19 @@ from typing import List
 
 from fabricatio.journal import logger
 from fabricatio.models.action import Action
+from fabricatio.models.events import EventLike
 from fabricatio.models.task import Task
 
 
-class SendTask(Action):
-    """Action that sends a task to a user."""
+class PublishTask(Action):
+    """An action that publishes a task to a list of targets."""
 
-    name: str = "send_task"
+    name: str = "publish_task"
+    """The name of the action."""
+    description: str = "Publish a task to a list of targets."
 
-    async def _execute(self, send_targets: List[str], send_task: Task, **_) -> None:
+    async def _execute(self, send_targets: List[EventLike], send_task: Task, **_) -> None:
+        """Execute the action by sending the task to the specified targets."""
         logger.info(f"Sending task {send_task.name} to {send_targets}")
         for target in send_targets:
-            await send_task.publish(target)
+            await send_task.move_to(target).publish()

fabricatio/config.py

@@ -1,7 +1,17 @@
-from typing import List, Literal
+from typing import List, Literal, Optional
 
 from appdirs import user_config_dir
-from pydantic import BaseModel, ConfigDict, Field, FilePath, HttpUrl, NonNegativeFloat, PositiveInt, SecretStr
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    DirectoryPath,
+    Field,
+    FilePath,
+    HttpUrl,
+    NonNegativeFloat,
+    PositiveInt,
+    SecretStr,
+)
 from pydantic_settings import (
     BaseSettings,
     DotEnvSettingsSource,
@@ -12,6 +22,8 @@ from pydantic_settings import (
     TomlConfigSettingsSource,
 )
 
+ROAMING_DIR = user_config_dir("fabricatio", "", roaming=True)
+
 
 class LLMConfig(BaseModel):
     """LLM configuration class.
@@ -32,59 +44,37 @@ class LLMConfig(BaseModel):
 
     model_config = ConfigDict(use_attribute_docstrings=True)
     api_endpoint: HttpUrl = Field(default=HttpUrl("https://api.openai.com"))
-    """
-    OpenAI API Endpoint.
-    """
+    """OpenAI API Endpoint."""
 
     api_key: SecretStr = Field(default=SecretStr(""))
-    """
-    OpenAI API key. Empty by default for security reasons, should be set before use.
-    """
+    """OpenAI API key. Empty by default for security reasons, should be set before use."""
 
     timeout: PositiveInt = Field(default=300)
-    """
-    The timeout of the LLM model in seconds. Default is 300 seconds as per request.
-    """
+    """The timeout of the LLM model in seconds. Default is 300 seconds as per request."""
 
     max_retries: PositiveInt = Field(default=3)
-    """
-    The maximum number of retries. Default is 3 retries.
-    """
+    """The maximum number of retries. Default is 3 retries."""
 
     model: str = Field(default="gpt-3.5-turbo")
-    """
-    The LLM model name. Set to 'gpt-3.5-turbo' as per request.
-    """
+    """The LLM model name. Set to 'gpt-3.5-turbo' as per request."""
 
     temperature: NonNegativeFloat = Field(default=1.0)
-    """
-    The temperature of the LLM model. Controls randomness in generation. Set to 1.0 as per request.
-    """
+    """The temperature of the LLM model. Controls randomness in generation. Set to 1.0 as per request."""
 
     stop_sign: str | List[str] = Field(default=("\n\n", "User:"))
-    """
-    The stop sign of the LLM model. No default stop sign specified.
-    """
+    """The stop sign of the LLM model. No default stop sign specified."""
 
     top_p: NonNegativeFloat = Field(default=0.35)
-    """
-    The top p of the LLM model. Controls diversity via nucleus sampling. Set to 0.35 as per request.
-    """
+    """The top p of the LLM model. Controls diversity via nucleus sampling. Set to 0.35 as per request."""
 
     generation_count: PositiveInt = Field(default=1)
-    """
-    The number of generations to generate. Default is 1.
-    """
+    """The number of generations to generate. Default is 1."""
 
     stream: bool = Field(default=False)
-    """
-    Whether to stream the LLM model's response. Default is False.
-    """
+    """Whether to stream the LLM model's response. Default is False."""
 
     max_tokens: PositiveInt = Field(default=8192)
-    """
-    The maximum number of tokens to generate. Set to 8192 as per request.
-    """
+    """The maximum number of tokens to generate. Set to 8192 as per request."""
 
 
 class PymitterConfig(BaseModel):
@@ -98,19 +88,13 @@ class PymitterConfig(BaseModel):
 
     model_config = ConfigDict(use_attribute_docstrings=True)
     delimiter: str = Field(default=".", frozen=True)
-    """
-    The delimiter used to separate the event name into segments.
-    """
+    """The delimiter used to separate the event name into segments."""
 
     new_listener_event: bool = Field(default=False, frozen=True)
-    """
-    If set, a newListener event is emitted when a new listener is added.
-    """
+    """If set, a newListener event is emitted when a new listener is added."""
 
     max_listeners: int = Field(default=-1, frozen=True)
-    """
-    The maximum number of listeners per event.
-    """
+    """The maximum number of listeners per event."""
 
 
 class DebugConfig(BaseModel):
@@ -124,14 +108,28 @@ class DebugConfig(BaseModel):
     model_config = ConfigDict(use_attribute_docstrings=True)
 
     log_level: Literal["DEBUG", "INFO", "SUCCESS", "WARNING", "ERROR", "CRITICAL"] = Field(default="INFO")
-    """
-    The log level of the application.
-    """
+    """The log level of the application."""
 
-    log_file: FilePath = Field(default=f"{user_config_dir('fabricatio', roaming=True)}.log")
-    """
-    The log file of the application.
-    """
+    log_file: FilePath = Field(default=rf"{ROAMING_DIR}\fabricatio.log")
+    """The log file of the application."""
+
+
+class Code2PromptConfig(BaseModel):
+    """Code2Prompt configuration class."""
+
+    model_config = ConfigDict(use_attribute_docstrings=True)
+    template_dir: List[DirectoryPath] = Field(
+        default_factory=lambda: [r".\c2p_templates", rf"{ROAMING_DIR}\c2p_templates"]
+    )
+    """The directory containing the templates for code2prompt."""
+
+
+class MagikaConfig(BaseModel):
+    """Magika configuration class."""
+
+    model_config = ConfigDict(use_attribute_docstrings=True)
+    model_dir: Optional[DirectoryPath] = Field(default=None)
+    """The directory containing the models for magika."""
 
 
 class Settings(BaseSettings):
@@ -141,6 +139,8 @@ class Settings(BaseSettings):
         llm (LLMConfig): LLM Configuration
         debug (DebugConfig): Debug Configuration
         pymitter (PymitterConfig): Pymitter Configuration
+        code2prompt (Code2PromptConfig): Code2Prompt Configuration
+        magika (MagikaConfig): Magika Configuration
     """
 
     model_config = SettingsConfigDict(
@@ -148,25 +148,25 @@ class Settings(BaseSettings):
         env_nested_delimiter="__",
         pyproject_toml_depth=1,
         pyproject_toml_table_header=("tool", "fabricatio"),
-        toml_file=["fabricatio.toml", f"{user_config_dir('fabricatio', roaming=True)}.toml"],
+        toml_file=["fabricatio.toml", rf"{ROAMING_DIR}\fabricatio.toml"],
         env_file=[".env", ".envrc"],
         use_attribute_docstrings=True,
     )
 
     llm: LLMConfig = Field(default_factory=LLMConfig)
-    """
-    LLM Configuration
-    """
+    """LLM Configuration"""
 
     debug: DebugConfig = Field(default_factory=DebugConfig)
-    """
-    Debug Configuration
-    """
+    """Debug Configuration"""
 
     pymitter: PymitterConfig = Field(default_factory=PymitterConfig)
-    """
-    Pymitter Configuration
-    """
+    """Pymitter Configuration"""
+
+    code2prompt: Code2PromptConfig = Field(default_factory=Code2PromptConfig)
+    """Code2Prompt Configuration"""
+
+    magika: MagikaConfig = Field(default_factory=MagikaConfig)
+    """Magika Configuration"""
 
     @classmethod
     def settings_customise_sources(

fabricatio/decorators.py

@@ -0,0 +1,56 @@
+from functools import wraps
+from shutil import which
+from typing import Callable
+
+from fabricatio.journal import logger
+
+
+def depend_on_external_cmd[**P, R](bin_name: str, install_tip: str) -> Callable[[Callable[P, R]], Callable[P, R]]:
+    """Decorator to check for the presence of an external command.
+
+    Args:
+        bin_name (str): The name of the required binary.
+        install_tip (str): Installation instructions for the required binary.
+
+    Returns:
+        Callable[[Callable[P, R]], Callable[P, R]]: A decorator that wraps the function to check for the binary.
+
+    Raises:
+        RuntimeError: If the required binary is not found.
+    """
+
+    def decorator(func: Callable[P, R]) -> Callable[P, R]:
+        """Decorator to wrap the function with binary presence check.
+
+        Args:
+            func (Callable[P, R]): The function to be decorated.
+
+        Returns:
+            Callable[P, R]: The wrapped function.
+        """
+
+        @wraps(func)
+        def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+            """Wrapper function to check for the presence of the required binary.
+
+            Args:
+                *args: Positional arguments for the function.
+                **kwargs: Keyword arguments for the function.
+
+            Returns:
+                R: The result of the function call.
+
+            Raises:
+                RuntimeError: If the required binary is not found.
+            """
+            if which(bin_name) is None:
+                err = (
+                    f"{bin_name} is required to run function: {func.__name__}, please install it first.\n{install_tip}"
+                )
+                logger.critical(err)
+                raise RuntimeError(err)
+            return func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator

fabricatio/fs/__init__.py

@@ -0,0 +1 @@
+"""FileSystem manipulation module for Fabricatio."""

fabricatio/fs/readers.py

@@ -0,0 +1,5 @@
+from magika import Magika
+
+from fabricatio.config import configs
+
+magika = Magika(model_dir=configs.magika.model_dir)

fabricatio/models/action.py

@@ -41,7 +41,7 @@ class Action(WithBriefing, LLMUsage):
         return cxt
 
 
-class WorkFlow(WithBriefing, LLMUsage):
+class WorkFlow[A: Type[Action] | Action](WithBriefing, LLMUsage):
     """Class that represents a workflow to be executed in a task."""
 
     _context: Queue[Dict[str, Any]] = PrivateAttr(default_factory=lambda: Queue(maxsize=1))
@@ -49,12 +49,14 @@ class WorkFlow(WithBriefing, LLMUsage):
 
     _instances: Tuple[Action, ...] = PrivateAttr(...)
 
-    steps: Tuple[Type[Action], ...] = Field(...)
-    """ The steps to be executed in the workflow."""
+    steps: Tuple[A, ...] = 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."""
     task_output_key: str = Field(default="task_output")
     """ The key of the task output data."""
+    extra_init_context: Dict[str, Any] = Field(default_factory=dict, frozen=True)
+    """ The extra context dictionary to be used for workflow initialization."""
 
     def model_post_init(self, __context: Any) -> None:
         """Initialize the workflow by setting fallbacks for each step.
@@ -62,7 +64,11 @@ class WorkFlow(WithBriefing, LLMUsage):
         Args:
             __context: The context to be used for initialization.
         """
-        self._instances = tuple(step() for step in self.steps)
+        temp = []
+        for step in self.steps:
+            temp.append(step if isinstance(step, Action) else step())
+        self._instances = tuple(temp)
+
         for step in self._instances:
             step.fallback_to(self)
 
@@ -73,13 +79,13 @@ class WorkFlow(WithBriefing, LLMUsage):
             task: The task to be served.
         """
         await task.start()
-        await self._context.put({self.task_input_key: task})
+        await self._init_context()
         current_action = None
         try:
             for step in self._instances:
                 logger.debug(f"Executing step: {step.name}")
-                ctx = await self._context.get()
-                modified_ctx = await step.act(ctx)
+                cxt = await self._context.get()
+                modified_ctx = await step.act(cxt)
                 await self._context.put(modified_ctx)
                 current_action = step.name
             logger.info(f"Finished executing workflow: {self.name}")
@@ -88,3 +94,8 @@ class WorkFlow(WithBriefing, LLMUsage):
             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
             await task.fail()  # Mark the task as failed
+
+    async def _init_context(self) -> None:
+        """Initialize the context dictionary for workflow execution."""
+        logger.debug(f"Initializing context for workflow: {self.name}")
+        await self._context.put({self.task_input_key: None, **dict(self.extra_init_context)})

fabricatio/models/events.py

@@ -4,6 +4,8 @@ from pydantic import BaseModel, ConfigDict, Field
 
 from fabricatio.config import configs
 
+type EventLike = str | List[str] | Self
+
 
 class Event(BaseModel):
     """A class representing an event."""
@@ -14,16 +16,25 @@ class Event(BaseModel):
     """ The segments of the namespaces."""
 
     @classmethod
-    def from_string(cls, event: str) -> Self:
-        """Create an Event instance from a string.
+    def instantiate_from(cls, event: EventLike) -> Self:
+        """Create an Event instance from a string or list of strings or an Event instance.
 
         Args:
-            event (str): The event string.
+            event (EventLike): The event to instantiate from.
 
         Returns:
             Event: The Event instance.
         """
-        return cls(segments=event.split(configs.pymitter.delimiter))
+        if isinstance(event, Event):
+            return event.clone()
+        if isinstance(event, str):
+            event = event.split(configs.pymitter.delimiter)
+
+        return cls(segments=event)
+
+    def derive(self, event: EventLike) -> Self:
+        """Derive a new event from this event and another event or a string."""
+        return self.clone().concat(event)
 
     def collapse(self) -> str:
         """Collapse the event into a string."""
@@ -41,6 +52,10 @@ class Event(BaseModel):
         self.segments.append(segment)
         return self
 
+    def push_wildcard(self) -> Self:
+        """Push a wildcard segment to the event."""
+        return self.push("*")
+
     def pop(self) -> str:
         """Pop a segment from the event."""
         return self.segments.pop()
@@ -50,19 +65,15 @@ class Event(BaseModel):
         self.segments.clear()
         return self
 
-    def concat(self, event: Self | str) -> Self:
+    def concat(self, event: EventLike) -> Self:
         """Concatenate another event to this event."""
-        if isinstance(event, str):
-            event = Event.from_string(event)
-        self.segments.extend(event.segments)
+        self.segments.extend(Event.instantiate_from(event).segments)
         return self
 
     def __hash__(self) -> int:
         """Return the hash of the event, using the collapsed string."""
         return hash(self.collapse())
 
-    def __eq__(self, other: Self | str) -> bool:
+    def __eq__(self, other: str | List[str] | Self) -> bool:
         """Check if the event is equal to another event or a string."""
-        if isinstance(other, Event):
-            other = other.collapse()
-        return self.collapse() == other
+        return self.collapse() == Event.instantiate_from(other).collapse()

fabricatio/models/generic.py

@@ -1,4 +1,5 @@
 from asyncio import Queue
+from pathlib import Path
 from typing import Callable, Dict, Iterable, List, Optional, Self
 
 import litellm
@@ -17,6 +18,7 @@ from pydantic import (
 )
 
 from fabricatio.config import configs
+from fabricatio.fs.readers import magika
 from fabricatio.models.utils import Messages
 
 
@@ -464,3 +466,52 @@ class WithJsonExample(Base):
             {field_name: field_info.description for field_name, field_info in cls.model_fields.items()},
             option=orjson.OPT_INDENT_2 | orjson.OPT_SORT_KEYS,
         ).decode()
+
+
+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."""
+
+    def add_dependency[P: str | Path](self, dependency: P | List[P]) -> Self:
+        """Add a file dependency to the task.
+
+        Args:
+            dependency (str | Path | List[str | Path]): The file dependency to add to the task.
+
+        Returns:
+            Self: The current instance of the task.
+        """
+        if not isinstance(dependency, list):
+            dependency = [dependency]
+        self.dependencies.extend(Path(d).as_posix() for d in dependency)
+        return self
+
+    def remove_dependency[P: str | Path](self, dependency: P | List[P]) -> Self:
+        """Remove a file dependency from the task.
+
+        Args:
+            dependency (str | Path | List[str | Path]): The file dependency to remove from the task.
+
+        Returns:
+            Self: The current instance of the task.
+        """
+        if not isinstance(dependency, list):
+            dependency = [dependency]
+        for d in dependency:
+            self.dependencies.remove(Path(d).as_posix())
+        return self
+
+    def generate_prompt(self) -> str:
+        """Generate a prompt for the task based on the file dependencies.
+
+        Returns:
+            str: The generated prompt for the task.
+        """
+        contents = [Path(d).read_text("utf-8") for d in self.dependencies]
+        recognized = [magika.identify_path(c) for c in contents]
+        out = ""
+        for r, p, c in zip(recognized, self.dependencies, contents, strict=False):
+            out += f"---\n\n> {p}\n```{r.dl.ct_label}\n{c}\n```\n\n"
+        return out

fabricatio/models/task.py

@@ -5,15 +5,14 @@ It includes methods to manage the task's lifecycle, such as starting, finishing,
 
 from asyncio import Queue
 from enum import Enum
-from typing import Optional, Self
+from typing import Any, List, 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.events import Event
-from fabricatio.models.generic import WithBriefing, WithJsonExample
+from fabricatio.models.events import Event, EventLike
+from fabricatio.models.generic import WithBriefing, WithDependency, WithJsonExample
 
 
 class TaskStatus(Enum):
@@ -34,13 +33,15 @@ class TaskStatus(Enum):
     Cancelled = "cancelled"
 
 
-class Task[T](WithBriefing, WithJsonExample):
+class Task[T](WithBriefing, WithJsonExample, WithDependency):
     """A class representing a task with a status and output.
 
     Attributes:
         name (str): The name of the task.
         description (str): The description of the task.
         goal (str): The goal of the task.
+        dependencies (List[str]): The file dependencies of the task, a list of file paths.
+        namespace (List[str]): The namespace of the task, a list of namespace segment, as string.
     """
 
     name: str = Field(...)
@@ -52,12 +53,35 @@ class Task[T](WithBriefing, WithJsonExample):
     goal: str = Field(default="")
     """The goal of the task."""
 
+    namespace: List[str] = Field(default_factory=list)
+    """The namespace of the task, a list of namespace segment, as string."""
+
     _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."""
 
+    _namespace: Event = PrivateAttr(default_factory=Event)
+    """The namespace of the task as an event, which is generated from the namespace list."""
+
+    def model_post_init(self, __context: Any) -> None:
+        """Initialize the task with a namespace event."""
+        self._namespace.segments.extend(self.namespace)
+
+    def move_to(self, new_namespace: EventLike) -> Self:
+        """Move the task to a new namespace.
+
+        Args:
+            new_namespace (List[str]): The new namespace to move the task to.
+
+        Returns:
+            Task: The moved instance of the `Task` class.
+        """
+        self.namespace = new_namespace
+        self._namespace.clear().concat(new_namespace)
+        return self
+
     @classmethod
     def simple_task(cls, name: str, goal: str, description: str) -> Self:
         """Create a simple task with a name, goal, and description.
@@ -106,7 +130,7 @@ class Task[T](WithBriefing, WithJsonExample):
         Returns:
             str: The formatted status label.
         """
-        return f"{self.name}{configs.pymitter.delimiter}{status.value}"
+        return self._namespace.derive(self.name).push(status.value).collapse()
 
     @property
     def pending_label(self) -> str:
@@ -202,36 +226,24 @@ class Task[T](WithBriefing, WithJsonExample):
         await env.emit_async(self.failed_label, self)
         return self
 
-    async def publish(self, event_namespace: Event | str = "") -> Self:
-        """Publish the task with an optional event namespace.
-
-        Args:
-            event_namespace (Event | str, optional): The event namespace to use. Defaults to an empty string.
+    async def publish(self) -> Self:
+        """Publish the task to the event bus.
 
         Returns:
-            Task: The published instance of the `Task` class.
+            Task: The published instance of the `Task` class
         """
-        if isinstance(event_namespace, str):
-            event_namespace = Event.from_string(event_namespace)
-
         logger.info(f"Publishing task {self.name}")
-        await env.emit_async(event_namespace.concat(self.pending_label).collapse(), self)
+        await env.emit_async(self.pending_label, self)
         return self
 
-    async def delegate(self, event_namespace: Event | str = "") -> T:
-        """Delegate the task with an optional event namespace and return the output.
-
-        Args:
-            event_namespace (Event | str, optional): The event namespace to use. Defaults to an empty string.
+    async def delegate(self) -> T:
+        """Delegate the task to the event bus and wait for the output.
 
         Returns:
-            T: The output of the task.
+            T: The output of the task
         """
-        if isinstance(event_namespace, str):
-            event_namespace = Event.from_string(event_namespace)
-
         logger.info(f"Delegating task {self.name}")
-        await env.emit_async(event_namespace.concat(self.pending_label).collapse(), self)
+        await env.emit_async(self.pending_label, self)
         return await self.get_output()
 
     @property

fabricatio/parser.py

@@ -64,3 +64,4 @@ class Capture(Base):
 
 JsonCapture = Capture.capture_code_block("json")
 PythonCapture = Capture.capture_code_block("python")
+CodeBlockCapture = Capture.capture_code_block("")

fabricatio-0.2.0.dev1.dist-info/METADATA

@@ -0,0 +1,246 @@
+Metadata-Version: 2.4
+Name: fabricatio
+Version: 0.2.0.dev1
+Summary: A LLM multi-agent framework.
+Author-email: Whth <zettainspector@foxmail.com>
+License: MIT License
+        
+        Copyright (c) 2025 Whth Yotta
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        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
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+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: code2prompt
+Requires-Dist: gitpython>=3.1.44
+Requires-Dist: litellm>=1.60.0
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: magika>=0.5.1
+Requires-Dist: orjson>=3.10.15
+Requires-Dist: pydantic-settings>=2.7.1
+Requires-Dist: pydantic>=2.10.6
+Requires-Dist: pymitter>=1.0.0
+Requires-Dist: questionary>=2.1.0
+Requires-Dist: regex>=2024.11.6
+Requires-Dist: rich>=13.9.4
+Description-Content-Type: text/markdown
+
+# Fabricatio
+
+---
+
+Fabricatio is a powerful framework designed to facilitate the creation and management of tasks, actions, and workflows. It leverages modern Python features and libraries to provide a robust and flexible environment for building applications that require task automation and orchestration.
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Usage](#usage)
+    - [Defining a Task](#defining-a-task)
+    - [Creating an Action](#creating-an-action)
+    - [Assigning a Role](#assigning-a-role)
+    - [Logging](#logging)
+- [Configuration](#configuration)
+    - [LLM Configuration](#llm-configuration)
+    - [Debug Configuration](#debug-configuration)
+- [Examples](#examples)
+    - [Simple Task Example](#simple-task-example)
+    - [Complex Workflow Example](#complex-workflow-example)
+- [Contributing](#contributing)
+- [License](#license)
+
+## Installation
+To install Fabricatio, you can use pip:
+
+```bash
+pip install fabricatio
+```
+
+Alternatively, you can clone the repository and install it manually:
+
+```bash
+git clone https://github.com/your-repo/fabricatio.git
+cd fabricatio
+pip install .
+```
+
+
+## Usage
+
+### Defining a Task
+
+A task in Fabricatio is defined using the `Task` class. You can specify the name, goal, and description of the 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
+
+Actions are the building blocks of workflows. They perform specific tasks and can be asynchronous.
+
+```python
+from fabricatio import Action, logger
+from fabricatio.models.task import Task
+
+class Talk(Action):
+    async def _execute(self, task_input: Task[str], **_) -> str:
+        ret = "Hello fabricatio!"
+        logger.info("executing talk action")
+        return ret
+```
+
+
+### Assigning a Role
+
+Roles in Fabricatio are responsible for executing workflows. You can define a role with a set of actions.
+
+```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.
+
+### LLM Configuration
+
+The Large Language Model (LLM) configuration is managed by the `LLMConfig` class.
+
+```python
+from fabricatio.config import LLMConfig
+
+llm_config = LLMConfig(api_endpoint="https://api.example.com")
+```
+
+
+### Debug Configuration
+
+The debug configuration is managed by the `DebugConfig` class.
+
+```python
+from fabricatio.config import DebugConfig
+
+debug_config = DebugConfig(log_level="DEBUG", log_file="fabricatio.log")
+```
+
+
+## Examples
+
+### Simple Task Example
+
+Here is a simple example of a task that prints "Hello fabricatio!".
+
+```python
+import asyncio
+from fabricatio import Action, Role, Task, WorkFlow, logger
+
+task = Task(name="say hello", goal="say hello", description="say hello to the world")
+
+class Talk(Action):
+    async def _execute(self, task_input: Task[str], **_) -> Any:
+        ret = "Hello fabricatio!"
+        logger.info("executing talk action")
+        return ret
+
+class TestWorkflow(WorkFlow):
+    pass
+
+role = Role(name="Test Role", actions=[TestWorkflow()])
+
+async def main() -> None:
+    await role.act(task)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+
+### Complex Workflow Example
+
+Here is a more complex example that demonstrates how to create a workflow with multiple actions.
+
+```python
+import asyncio
+from fabricatio import Action, Role, Task, WorkFlow, logger
+
+task = Task(name="complex task", goal="perform complex operations", description="a task with multiple actions")
+
+class ActionOne(Action):
+    async def _execute(self, task_input: Task[str], **_) -> Any:
+        ret = "Action One executed"
+        logger.info(ret)
+        return ret
+
+class ActionTwo(Action):
+    async def _execute(self, task_input: Task[str], **_) -> Any:
+        ret = "Action Two executed"
+        logger.info(ret)
+        return ret
+
+class ComplexWorkflow(WorkFlow):
+    actions = [ActionOne(), ActionTwo()]
+
+role = Role(name="Complex Role", actions=[ComplexWorkflow()])
+
+async def main() -> None:
+    await role.act(task)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+
+## 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.2.0.dev1.dist-info/RECORD

@@ -0,0 +1,24 @@
+fabricatio/__init__.py,sha256=nFPtohqceECRYzU-WlVT6o4oSaKN0vGok-w9JIaiJfs,644
+fabricatio/config.py,sha256=emkIpaXRQykAX_C2ND8tKR2DQUJJEN0mvdMDTklwOXw,7823
+fabricatio/core.py,sha256=B6KBIfBRF023HF0UUaUprEkQd6sT7G_pexGXQ9btJnE,5788
+fabricatio/decorators.py,sha256=Qsyb-_cDwtXY5yhyLrYZEAlrHh5ZuEooQ8vEOUAxj8k,1855
+fabricatio/journal.py,sha256=CW9HePtgTiboOyPTExq9GjG5BseZcbc-S6lxDXrpmv0,667
+fabricatio/parser.py,sha256=6PNFNNyHNkNG7vTS1ejFc4vCzl1OCy4bqB0e4Ty_-Qs,2365
+fabricatio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fabricatio/actions/__init__.py,sha256=eFmFVPQvtNgFynIXBVr3eP-vWQDWCPng60YY5LXvZgg,115
+fabricatio/actions/transmission.py,sha256=TABvBB127hC3KYvm7zJp_i-_GF9wXXCR-k8bxfhNYak,768
+fabricatio/fs/__init__.py,sha256=OL9f4jZDYcErSM7Yw7rhy97f8QDE-6wZIoGz1reS3Z0,54
+fabricatio/fs/readers.py,sha256=mw0VUH3P7Wk0SMlcQm2yOfjEz5C3mQ_kjduAjecaxgY,123
+fabricatio/models/action.py,sha256=CbGuR9dHnu87MFAzLWj8cVHZtFNyT_VuwT3pWlKJvEk,3925
+fabricatio/models/events.py,sha256=pW3sfxEFWTafbP4bn4hVFSe8qloYrrzOgi9oMCqAEgw,2604
+fabricatio/models/generic.py,sha256=noHow8dUjMnNiasl2ZHaZeCMpxzDme9QvxTetoyB45w,19539
+fabricatio/models/role.py,sha256=jdabuYRXwgvpYoNwvazygDiZHGGQApUIIKltniu78O8,2151
+fabricatio/models/task.py,sha256=mWIQHdi1mNJlER5ZFeywsZxg4Skm-VnjW2z8ZEMJLNE,8190
+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.2.0.dev1.dist-info/METADATA,sha256=RIwaKlrpJQplobxDYSljYSlUXwC-Ai2F1SPYzBxGG0A,7054
+fabricatio-0.2.0.dev1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+fabricatio-0.2.0.dev1.dist-info/licenses/LICENSE,sha256=do7J7EiCGbq0QPbMAL_FqLYufXpHnCnXBOuqVPwSV8Y,1088
+fabricatio-0.2.0.dev1.dist-info/RECORD,,

fabricatio-0.1.3.dist-info/METADATA

@@ -1,127 +0,0 @@
-Metadata-Version: 2.4
-Name: fabricatio
-Version: 0.1.3
-Summary: A LLM multi-agent framework.
-Author-email: Whth <zettainspector@foxmail.com>
-License: MIT License
-        
-        Copyright (c) 2025 Whth Yotta
-        
-        Permission is hereby granted, free of charge, to any person obtaining a copy
-        of this software and associated documentation files (the "Software"), to deal
-        in the Software without restriction, including without limitation the rights
-        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-        copies of the Software, and to permit persons to whom the Software is
-        furnished to do so, subject to the following conditions:
-        
-        The above copyright notice and this permission notice shall be included in all
-        copies or substantial portions of the Software.
-        
-        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-        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
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: Implementation :: CPython
-Classifier: Typing :: Typed
-Requires-Python: >=3.12
-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: orjson>=3.10.15
-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
-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.3.dist-info/RECORD

@@ -1,21 +0,0 @@
-fabricatio/__init__.py,sha256=nFPtohqceECRYzU-WlVT6o4oSaKN0vGok-w9JIaiJfs,644
-fabricatio/config.py,sha256=EOlVkuEBAHESAlrGtolGwEG2YrTaJPhEGPKS7QDxrx0,6995
-fabricatio/core.py,sha256=B6KBIfBRF023HF0UUaUprEkQd6sT7G_pexGXQ9btJnE,5788
-fabricatio/journal.py,sha256=CW9HePtgTiboOyPTExq9GjG5BseZcbc-S6lxDXrpmv0,667
-fabricatio/parser.py,sha256=On_YUCvOuA0FA_NtDVNJqKp7KEO_sUE89oO_WnkEhQ4,2314
-fabricatio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fabricatio/actions/__init__.py,sha256=n3lwq9FPNtvfLu2L1pX4UkwiPITU7luk-b4aMJyjIC8,109
-fabricatio/actions/transmission.py,sha256=Azog4ItVk7aASdYzTwzyckzYG2hDFSXctnA7qp-Qlq0,502
-fabricatio/models/action.py,sha256=M-12dc-nQiNJU6Y9j-dr4Ef3642vRvzHlzxekBepzaU,3358
-fabricatio/models/events.py,sha256=PlavKOD94Q9Q9iPoQPkf9HJdznBtzuSUrPtUoVtkQxU,2143
-fabricatio/models/generic.py,sha256=Sxpx0BO0t85YF5Lwks6F165N6TJsDe7xym28dQG5Mqs,17681
-fabricatio/models/role.py,sha256=jdabuYRXwgvpYoNwvazygDiZHGGQApUIIKltniu78O8,2151
-fabricatio/models/task.py,sha256=8IXT192t5EXVHAdHj45DJNdBhdA2xmh36S_vKyEw6y0,7757
-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.3.dist-info/METADATA,sha256=pDZPikewIva_s6riDaxhlOmvd92ls_JoS_VqETPwDdM,3797
-fabricatio-0.1.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-fabricatio-0.1.3.dist-info/licenses/LICENSE,sha256=do7J7EiCGbq0QPbMAL_FqLYufXpHnCnXBOuqVPwSV8Y,1088
-fabricatio-0.1.3.dist-info/RECORD,,