fabricatio 0.1.0__py3-none-any.whl

fabricatio/__init__.py

@@ -0,0 +1,18 @@
+from fabricatio.core import Env
+from fabricatio.logger import logger
+from fabricatio.models.action import Action, WorkFlow
+from fabricatio.models.events import Event
+from fabricatio.models.role import Role
+from fabricatio.models.tool import ToolBox
+from fabricatio.models.utils import Messages
+
+__all__ = [
+    "Env",
+    "logger",
+    "Action",
+    "Event",
+    "Messages",
+    "Role",
+    "ToolBox",
+    "WorkFlow",
+]

fabricatio/config.py

@@ -0,0 +1,122 @@
+from typing import Literal
+
+from appdirs import user_config_dir
+from pydantic import BaseModel, HttpUrl, SecretStr, PositiveInt, NonNegativeFloat, Field, FilePath
+from pydantic_settings import (
+    BaseSettings,
+    SettingsConfigDict,
+    PydanticBaseSettingsSource,
+    TomlConfigSettingsSource,
+    PyprojectTomlConfigSettingsSource,
+    EnvSettingsSource,
+    DotEnvSettingsSource,
+)
+
+
+class LLMConfig(BaseModel):
+    api_endpoint: HttpUrl = Field(default=HttpUrl("https://api.openai.com"))
+    """
+    OpenAI API Endpoint.
+    """
+
+    api_key: SecretStr = Field(default=SecretStr(""))
+    """
+    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.
+    """
+
+    max_retries: PositiveInt = Field(default=3)
+    """
+    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.
+    """
+
+    temperature: NonNegativeFloat = Field(default=1.0)
+    """
+    The temperature of the LLM model. Controls randomness in generation. Set to 1.0 as per request.
+    """
+
+    stop_sign: str = Field(default="")
+    """
+    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.
+    """
+
+    generation_count: PositiveInt = Field(default=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.
+    """
+
+    max_tokens: PositiveInt = Field(default=8192)
+    """
+    The maximum number of tokens to generate. Set to 8192 as per request.
+    """
+
+
+class DebugConfig(BaseModel):
+    log_level: Literal["DEBUG", "INFO", "SUCCESS", "WARNING", "ERROR", "CRITICAL"] = Field(default="INFO")
+    """
+    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.
+    """
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(
+        env_prefix="FABRIK_",
+        env_nested_delimiter="__",
+        pyproject_toml_depth=1,
+        toml_file=["fabricatio.toml", f"{user_config_dir("fabricatio", roaming=True)}.toml"],
+        env_file=[".env", ".envrc"],
+        use_attribute_docstrings=True,
+    )
+
+    llm: LLMConfig = Field(default_factory=LLMConfig)
+    """
+    LLM Configuration
+    """
+
+    debug: DebugConfig = Field(default_factory=DebugConfig)
+    """
+    Debug Configuration
+    """
+
+    @classmethod
+    def settings_customise_sources(
+            cls,
+            settings_cls: type[BaseSettings],
+            init_settings: PydanticBaseSettingsSource,
+            env_settings: PydanticBaseSettingsSource,
+            dotenv_settings: PydanticBaseSettingsSource,
+            file_secret_settings: PydanticBaseSettingsSource,
+    ) -> tuple[PydanticBaseSettingsSource, ...]:
+        return (
+            DotEnvSettingsSource(settings_cls),
+            EnvSettingsSource(settings_cls),
+            TomlConfigSettingsSource(settings_cls),
+            PyprojectTomlConfigSettingsSource(settings_cls),
+        )
+
+
+configs: Settings = Settings()

fabricatio/core.py

@@ -0,0 +1,148 @@
+from typing import Callable, Self, overload
+
+from pydantic import BaseModel, ConfigDict, PrivateAttr
+from pymitter import EventEmitter
+
+from fabricatio.models.events import Event
+
+
+class Env(BaseModel):
+    """
+    Environment class that manages event handling using EventEmitter.
+
+    Attributes:
+        _ee (EventEmitter): Private attribute for event handling.
+    """
+
+    model_config = ConfigDict(use_attribute_docstrings=True)
+    _ee: EventEmitter = PrivateAttr(default_factory=EventEmitter)
+
+    @overload
+    def on(self, event: str | Event, /, ttl: int = -1) -> Self:
+        """
+        Registers an event listener that listens indefinitely or for a specified number of times.
+
+        Args:
+            event (str | Event): The event to listen for.
+            ttl (int): Time-to-live for the listener. If -1, the listener will listen indefinitely.
+
+        Returns:
+            Self: The current instance of Env.
+        """
+        ...
+
+    @overload
+    def on[**P, R](
+            self, event: str | Event, func: Callable[P, R] = None, /, ttl: int = -1
+    ) -> Callable[[Callable[P, R]], Callable[P, R]]:
+        """
+        Registers an event listener with a specific function that listens indefinitely or for a specified number of times.
+
+        Args:
+            event (str | Event): The event to listen for.
+            func (Callable[P, R]): The function to be called when the event is emitted.
+            ttl (int): Time-to-live for the listener. If -1, the listener will listen indefinitely.
+
+        Returns:
+            Callable[[Callable[P, R]], Callable[P, R]]: A decorator that registers the function as an event listener.
+        """
+        ...
+
+    def on[**P, R](
+            self,
+            event: str | Event,
+            func: Callable[P, R] = None,
+            /,
+            ttl=-1,
+    ) -> Callable[[Callable[P, R]], Callable[P, R]] | Self:
+        """
+        Registers an event listener with a specific function that listens indefinitely or for a specified number of times.
+        Args:
+            event (str | Event): The event to listen for.
+            func (Callable[P, R]): The function to be called when the event is emitted.
+            ttl (int): Time-to-live for the listener. If -1, the listener will listen indefinitely.
+
+        Returns:
+            Callable[[Callable[P, R]], Callable[P, R]] | Self: A decorator that registers the function as an event listener or the current instance of Env.
+        """
+        if isinstance(event, Event):
+            event = event.collapse()
+        if func is None:
+            return self._ee.on(event, ttl=ttl)
+
+        else:
+            self._ee.on(event, func, ttl=ttl)
+            return self
+
+    @overload
+    def once[**P, R](
+            self,
+            event: str | Event,
+    ) -> Callable[[Callable[P, R]], Callable[P, R]]:
+        """
+        Registers an event listener that listens only once.
+
+        Args:
+            event (str | Event): The event to listen for.
+
+        Returns:
+            Callable[[Callable[P, R]], Callable[P, R]]: A decorator that registers the function as an event listener.
+        """
+        ...
+
+    @overload
+    def once[**P, R](self, event: str | Event, func: Callable[[Callable[P, R]], Callable[P, R]]) -> Self:
+        """
+        Registers an event listener with a specific function that listens only once.
+
+        Args:
+            event (str | Event): The event to listen for.
+            func (Callable[P, R]): The function to be called when the event is emitted.
+
+        Returns:
+            Self: The current instance of Env.
+        """
+        ...
+
+    def once[**P, R](
+            self, event: str | Event, func: Callable[P, R] = None
+    ) -> Callable[[Callable[P, R]], Callable[P, R]] | Self:
+        """
+
+        Args:
+            event (str | Event): The event to listen for.
+            func (Callable[P, R]): The function to be called when the event is emitted.
+
+        Returns:
+            Callable[[Callable[P, R]], Callable[P, R]] | Self: A decorator that registers the function as an event listener or the current instance
+        """
+        if isinstance(event, Event):
+            event = event.collapse()
+        if func is None:
+            return self._ee.once(event)
+
+        else:
+            self._ee.once(event, func)
+            return self
+
+    def emit[**P](self, event: str | Event, *args: P.args, **kwargs: P.kwargs) -> None:
+        """
+        Emits an event to all registered listeners.
+
+        Args:
+            event (str | Event): The event to emit.
+            *args: Positional arguments to pass to the listeners.
+            **kwargs: Keyword arguments to pass to the listeners.
+        """
+        self._ee.emit(event, *args, **kwargs)
+
+    async def emit_async[**P](self, event: str | Event, *args: P.args, **kwargs: P.kwargs) -> None:
+        """
+        Asynchronously emits an event to all registered listeners.
+
+        Args:
+            event (str | Event): The event to emit.
+            *args: Positional arguments to pass to the listeners.
+            **kwargs: Keyword arguments to pass to the listeners.
+        """
+        return await self._ee.emit_async(event, *args, **kwargs)

fabricatio/fs.py

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

fabricatio/logger.py

@@ -0,0 +1,16 @@
+from loguru import logger
+from rich import traceback
+
+from fabricatio.config import configs
+
+traceback.install()
+logger.level(configs.debug.log_level)
+logger.add(configs.debug.log_file, rotation="1 weeks", retention="1 month", compression="zip")
+
+if __name__ == "__main__":
+    logger.debug("This is a trace message.")
+    logger.info("This is an information message.")
+    logger.success("This is a success message.")
+    logger.warning("This is a warning message.")
+    logger.error("This is an error message.")
+    logger.critical("This is a critical message.")

fabricatio/models/action.py

@@ -0,0 +1,22 @@
+from abc import abstractmethod
+from typing import Tuple
+
+from pydantic import Field
+
+from fabricatio.models.generic import WithBriefing, LLMUsage
+
+
+class Action(WithBriefing, LLMUsage):
+
+    @abstractmethod
+    async def execute(self, *args, **kwargs):
+        pass
+
+
+class WorkFlow(WithBriefing, LLMUsage):
+    steps: Tuple[Action, ...] = Field(default=())
+
+    async def execute(self, *args, **kwargs):
+        # TODO dispatch params to each step according to the step's signature
+        for step in self.steps:
+            await step.execute(*args, **kwargs)

fabricatio/models/events.py

@@ -0,0 +1,68 @@
+from typing import List, Self
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class Event(BaseModel):
+    model_config = ConfigDict(use_attribute_docstrings=True)
+    delimiter: str = Field(default=".", frozen=True)
+    """ The delimiter used to separate the event name into segments."""
+
+    segments: List[str] = Field(default_factory=list, frozen=True)
+    """ The segments of the namespaces."""
+
+    @classmethod
+    def from_string(cls, event: str, delimiter: str = ".") -> Self:
+        """
+        Create an Event instance from a string.
+
+        Args:
+            event (str): The event string.
+            delimiter (str): The delimiter used to separate the event name into segments.
+
+        Returns:
+            Event: The Event instance.
+        """
+        return cls(delimiter=delimiter, segments=event.split(delimiter))
+
+    def collapse(self) -> str:
+        """
+        Collapse the event into a string.
+        """
+        return self.delimiter.join(self.segments)
+
+    def clone(self) -> Self:
+        """
+        Clone the event.
+        """
+        return Event(delimiter=self.delimiter, segments=[segment for segment in self.segments])
+
+    def push(self, segment: str) -> Self:
+        """
+        Push a segment to the event.
+        """
+        assert segment, "The segment must not be empty."
+        assert self.delimiter not in segment, "The segment must not contain the delimiter."
+
+        self.segments.append(segment)
+        return self
+
+    def pop(self) -> str:
+        """
+        Pop a segment from the event.
+        """
+        return self.segments.pop()
+
+    def clear(self) -> Self:
+        """
+        Clear the event.
+        """
+        self.segments.clear()
+        return self
+
+    def concat(self, event: Self) -> Self:
+        """
+        Concatenate another event to this event.
+        """
+        self.segments.extend(event.segments)
+        return self

fabricatio/models/generic.py

@@ -0,0 +1,310 @@
+from asyncio import Queue
+from typing import Iterable, Any, Dict, Self, List
+
+import litellm
+from litellm.types.utils import StreamingChoices, ModelResponse, Choices
+from pydantic import (
+    BaseModel,
+    Field,
+    PositiveInt,
+    NonNegativeInt,
+    ConfigDict,
+    HttpUrl,
+    SecretStr,
+    NonNegativeFloat,
+    PrivateAttr,
+)
+
+from fabricatio.config import configs
+from fabricatio.models.utils import Messages
+
+
+class Base(BaseModel):
+    model_config = ConfigDict(use_attribute_docstrings=True)
+
+
+class WithToDo(Base):
+    _todo: Queue[str] = PrivateAttr(default_factory=Queue)
+    """
+    The todo list of the current instance.
+    """
+
+    async def add_todo(self, todo_msg: str) -> Self:
+        """
+        Add a todo item to the todo list.
+        Args:
+            todo_msg: The todo item to be added to the todo list.
+
+        Returns:
+            Self: The current instance object to support method chaining.
+        """
+
+        await self._todo.put(todo_msg)
+        return self
+
+    async def get_todo(self) -> str:
+        """
+        Get the last todo item from the todo list.
+        Returns:
+            str: The last todo item from the todo list.
+
+        """
+        # Pop the last todo item from the todo list
+        return await self._todo.get()
+
+
+class Named(Base):
+    name: str = Field(frozen=True)
+    """
+    Name of the object.
+    """
+
+
+class Described(Base):
+    description: str = Field(default="", frozen=True)
+    """
+    Description of the object.
+    """
+
+
+class WithBriefing(Named, Described):
+
+    @property
+    def briefing(self) -> str:
+        """
+        Get the briefing of the object.
+        Returns:
+            str: The briefing of the object.
+        """
+        return f"{self.name}: {self.description}" if self.description else self.name
+
+
+class Memorable(Base):
+    memory: List[str] = Field(default_factory=list)
+    """
+    Memory list.
+    """
+    memory_max_size: NonNegativeInt = Field(default=0)
+    """
+    Maximum size of the memory list.
+    """
+
+    def add_memory(self, memories: str | Iterable[str]) -> Self:
+        """
+        Add memory items to the memory list.
+
+        This method appends memory items to the memory list of the current instance.
+
+        Parameters:
+        - memories: str | Iterable[str] - A single memory item as a string or multiple memory items as an iterable.
+
+        Returns:
+        - Returns the current instance object to support method chaining.
+
+        This method design allows users to add memory items to the memory list
+        through a unified interface, enhancing code usability and extensibility.
+        """
+        # Convert a single memory item to a list
+        if isinstance(memories, str):
+            memories = [memories]
+        # Add memory items to the memory list
+        self.memory.extend(memories)
+        # Limit the memory list size if the maximum size is set
+        if self.memory_max_size > 0:
+            self.memory = self.memory[-self.memory_max_size:]
+        # Return the current instance object to support method chaining
+        return self
+
+    def top_memories(self, n: PositiveInt = 1) -> List[str]:
+        """
+        Get the top memory items from the memory list.
+
+        This method returns the top memory items from the memory list of the current instance.
+
+        Parameters:
+        - n: PositiveInt - The number of top memory items to return.
+
+        Returns:
+        - List[str] - The top memory items from the memory list.
+
+        This method design allows users to get the top memory items from the memory list
+        through a unified interface, enhancing code usability and extensibility.
+        """
+        # Get the top memory items from the memory list
+        return self.memory[-n:]
+
+    def top_memories_as_string(self, n: PositiveInt = 1, separator: str = "\n\n") -> str:
+        """
+        Get the memory items as a string.
+
+        This method returns the memory items as a string from the memory list of the current instance.
+
+        Parameters:
+        - n: PositiveInt - The number of memory items to return.
+        - separator: str - The separator to join memory items.
+
+        Returns:
+        - str - The memory items as a string.
+
+        This method design allows users to get the memory items as a string from the memory list
+        through a unified interface, enhancing code usability and extensibility.
+        """
+        # Get the top memory items from the memory list
+        memories = self.top_memories(n)
+        # Join memory items with the separator
+        return separator.join(memories)
+
+    def clear_memories(self) -> Self:
+        """
+        Clear all memory items.
+
+        This method clears all memory items from the memory list of the current instance.
+
+        Parameters:
+        - self: The current instance object.
+
+        Returns:
+        - Returns the current instance object to support method chaining.
+
+        This method design allows users to clear all memory items from the memory list
+        through a unified interface, enhancing code usability and extensibility.
+        """
+        # Clear all memory items from the memory list
+        self.memory.clear()
+        # Return the current instance object to support method chaining
+        return self
+
+
+class LLMUsage(Base):
+    llm_api_endpoint: HttpUrl = Field(default=configs.llm.api_endpoint)
+    """
+    The OpenAI API endpoint.
+    """
+
+    llm_api_key: SecretStr = Field(default=configs.llm.api_key)
+    """
+    The OpenAI API key.
+    """
+
+    llm_timeout: PositiveInt = Field(default=configs.llm.timeout)
+    """
+    The timeout of the LLM model.
+    """
+
+    llm_max_retries: PositiveInt = Field(default=configs.llm.max_retries)
+    """
+    The maximum number of retries.
+    """
+
+    llm_model: str = Field(default=configs.llm.model)
+    """
+    The LLM model name.
+    """
+
+    llm_temperature: NonNegativeFloat = Field(default=configs.llm.temperature)
+    """
+    The temperature of the LLM model.
+    """
+
+    llm_stop_sign: str = Field(default=configs.llm.stop_sign)
+    """
+    The stop sign of the LLM model.
+    """
+
+    llm_top_p: NonNegativeFloat = Field(default=configs.llm.top_p)
+    """
+    The top p of the LLM model.
+    """
+
+    llm_generation_count: PositiveInt = Field(default=configs.llm.generation_count)
+    """
+    The number of generations to generate.
+    """
+
+    llm_stream: bool = Field(default=configs.llm.stream)
+    """
+    Whether to stream the LLM model's response.
+    """
+
+    llm_max_tokens: PositiveInt = Field(default=configs.llm.max_tokens)
+    """
+    The maximum number of tokens to generate.
+    """
+
+    def model_post_init(self, __context: Any) -> None:
+        litellm.api_key = self.llm_api_key.get_secret_value()
+        litellm.api_base = self.llm_api_endpoint.unicode_string()
+
+    async def aquery(
+            self,
+            messages: List[Dict[str, str]],
+            model: str | None = None,
+            temperature: NonNegativeFloat | None = None,
+            stop: str | None = None,
+            top_p: NonNegativeFloat | None = None,
+            max_tokens: PositiveInt | None = None,
+            n: PositiveInt | None = None,
+            stream: bool | None = None,
+            timeout: PositiveInt | None = None,
+            max_retries: PositiveInt | None = None,
+    ) -> ModelResponse:
+        """
+        Asynchronously queries the language model to generate a response based on the provided messages and parameters.
+
+        Parameters:
+        - messages (List[Dict[str, str]]): A list of messages, where each message is a dictionary containing the role and content of the message.
+        - model (str | None): The name of the model to use. If not provided, the default model will be used.
+        - temperature (NonNegativeFloat | None): Controls the randomness of the output. Lower values make the output more deterministic.
+        - stop (str | None): A sequence at which to stop the generation of the response.
+        - top_p (NonNegativeFloat | None): Controls the diversity of the output through nucleus sampling.
+        - max_tokens (PositiveInt | None): The maximum number of tokens to generate in the response.
+        - n (PositiveInt | None): The number of responses to generate.
+        - stream (bool | None): Whether to receive the response in a streaming fashion.
+        - timeout (PositiveInt | None): The timeout duration for the request.
+        - max_retries (PositiveInt | None): The maximum number of retries in case of failure.
+
+        Returns:
+        - ModelResponse: An object containing the generated response and other metadata from the model.
+        """
+        # Call the underlying asynchronous completion function with the provided and default parameters
+        return await litellm.acompletion(
+            messages=messages,
+            model=model or self.llm_model,
+            temperature=temperature or self.llm_temperature,
+            stop=stop or self.llm_stop_sign,
+            top_p=top_p or self.llm_top_p,
+            max_tokens=max_tokens or self.llm_max_tokens,
+            n=n or self.llm_generation_count,
+            stream=stream or self.llm_stream,
+            timeout=timeout or self.llm_timeout,
+            max_retries=max_retries or self.llm_max_retries,
+        )
+
+    async def aask(
+            self,
+            question: str,
+            system_message: str = "",
+            model: str | None = None,
+            temperature: NonNegativeFloat | None = None,
+            stop: str | None = None,
+            top_p: NonNegativeFloat | None = None,
+            max_tokens: PositiveInt | None = None,
+            n: PositiveInt | None = None,
+            stream: bool | None = None,
+            timeout: PositiveInt | None = None,
+            max_retries: PositiveInt | None = None,
+    ) -> List[Choices | StreamingChoices]:
+        return (
+            await self.aquery(
+                messages=Messages().add_system_message(system_message).add_user_message(question),
+                model=model,
+                temperature=temperature,
+                stop=stop,
+                top_p=top_p,
+                max_tokens=max_tokens,
+                n=n,
+                stream=stream,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        ).choices

fabricatio/models/role.py

@@ -0,0 +1,14 @@
+from typing import List
+
+from pydantic import Field
+
+from fabricatio.models.action import WorkFlow
+from fabricatio.models.generic import Memorable, WithToDo, WithBriefing, LLMUsage
+
+
+class Role[T: WorkFlow](Memorable, WithBriefing, WithToDo, LLMUsage):
+    workflows: List[T] = Field(frozen=True)
+    """A list of action names that the role can perform."""
+
+    async def act(self):
+        pass

fabricatio/models/tool.py

@@ -0,0 +1,80 @@
+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)

fabricatio/models/utils.py

@@ -0,0 +1,81 @@
+from typing import Literal, Self, List, Dict
+
+from pydantic import BaseModel, Field, ConfigDict
+
+
+class Message(BaseModel):
+    model_config = ConfigDict(use_attribute_docstrings=True)
+    role: Literal["user", "system", "assistant"] = Field(default="user")
+    """
+    Who is sending the message.
+    """
+    content: str = Field(default="")
+    """
+    The content of the message.
+    """
+
+
+class Messages(list):
+    """
+    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.
+
+        Args:
+            role (Literal["user", "system", "assistant"]): The role of the message sender.
+            content (str): The content of the message.
+
+        Returns:
+            Self: The current instance of Messages to allow method chaining.
+        """
+        if content:
+            self.append(Message(role=role, content=content))
+        return self
+
+    def add_user_message(self, content: str) -> Self:
+        """
+        Adds a user message to the list with the specified content.
+
+        Args:
+            content (str): The content of the user message.
+
+        Returns:
+            Self: The current instance of Messages to allow method chaining.
+        """
+        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.
+
+        Args:
+            content (str): The content of the system message.
+
+        Returns:
+            Self: The current instance of Messages to allow method chaining.
+        """
+        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.
+
+        Args:
+            content (str): The content of the assistant message.
+
+        Returns:
+            Self: The current instance of Messages to allow method chaining.
+        """
+        return self.add_message("assistant", content)
+
+    def as_list(self) -> List[Dict[str, str]]:
+        """
+        Converts the messages to a list of dictionaries.
+
+        Returns:
+            list[dict]: A list of dictionaries representing the messages.
+        """
+        return [message.model_dump() for message in self]

fabricatio-0.1.0.dist-info/METADATA

@@ -0,0 +1,46 @@
+Metadata-Version: 2.4
+Name: fabricatio
+Version: 0.1.0
+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
+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: 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: rich>=13.9.4
+Provides-Extra: cli
+Requires-Dist: typer>=0.15.1; extra == 'cli'

fabricatio-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+fabricatio/__init__.py,sha256=eyBnyKBsNZJOuHwVoDNCpLNdTj3a_B2raHtHh8dsgSg,420
+fabricatio/config.py,sha256=aYvBVyJ3TBA6neDYJroxRKNEGgPA1Q8ncKE1YMH7jKU,3605
+fabricatio/core.py,sha256=XVvhpgR4BNDkhWnxTDouw8qyT0v--xKeRjp2BiRMO4E,5194
+fabricatio/fs.py,sha256=EBcqgSmsVWAKDm0ceiJ4IYYGPgP_qlO7tNl1O4tYUBk,30
+fabricatio/logger.py,sha256=NwfIbSvFnhOrkCREyU_WDC80c3DTJr9NA4OH8oZmrXE,581
+fabricatio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fabricatio/models/action.py,sha256=6KAeG5MWnWQzsj_SrQAKkIMduTv1Ry4Bc_v7LRXfjfM,585
+fabricatio/models/events.py,sha256=0VtavawE3H60ICOFa1eb-t2Iunl0zhvq0PikzGCE1rw,1978
+fabricatio/models/generic.py,sha256=3CUCgXRVx_qKj-jTKh6GJ2jggRPHRwRXlNcOe_c6wlM,10624
+fabricatio/models/role.py,sha256=0OZX724IsQwmjdVecJxst0TSo_UcJKI_rlJBEFOgD9o,410
+fabricatio/models/tool.py,sha256=_Cj5yG447M5dQNFSu08bMuyVLmA7QZGvtAziyeNqJa0,2871
+fabricatio/models/utils.py,sha256=TT4m7CymJXSVc_bqI9k6Inymj3AHbz7bh2tVgw4LW7Y,2491
+fabricatio-0.1.0.dist-info/METADATA,sha256=ltTqOsOFVwkaRV8HIvrGuBf21wt9P-EyfmFMSIHEnkw,2082
+fabricatio-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+fabricatio-0.1.0.dist-info/licenses/LICENSE,sha256=do7J7EiCGbq0QPbMAL_FqLYufXpHnCnXBOuqVPwSV8Y,1088
+fabricatio-0.1.0.dist-info/RECORD,,

fabricatio-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

fabricatio-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+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.