fabricatio 0.1.0__tar.gz

fabricatio-0.1.0/.github/workflows/build-package.yaml

@@ -0,0 +1,58 @@
+name: Build and Release
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  check-and-release:
+    runs-on: windows-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Install the latest version of uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          version: "latest"
+
+      - name: Build
+        run: |
+          uv build
+
+      - name: Get current version
+        id: get_version
+        run: |
+          CURRENT_VERSION=$(grep '^version' pyproject.toml | cut -d '"' -f 2)
+          echo "CURRENT_VERSION=v$CURRENT_VERSION" >> $GITHUB_OUTPUT
+        shell: bash
+      - name: Get latest tag
+        uses: JinoArch/get-latest-tag@latest
+        id: tag
+
+      - name: Check if version has changed
+        id: check_version_change
+        run: |
+          LATEST_TAG=${{ steps.tag.outputs.latestTag  }}
+          echo "Latest tag is $LATEST_TAG"
+          echo "Current version is ${{ steps.get_version.outputs.CURRENT_VERSION }}"
+          if [ "$LATEST_TAG" != "${{ steps.get_version.outputs.CURRENT_VERSION }}" ]; then
+              echo "VERSION_CHANGED=true" >> $GITHUB_OUTPUT
+            else
+              echo "VERSION_CHANGED=false" >> $GITHUB_OUTPUT
+          fi
+        shell: bash
+
+
+      - name: Create Release and upload assets
+        if: ${{ steps.check_version_change.outputs.VERSION_CHANGED == 'true' }}
+        id: create_release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: ${{ steps.get_version.outputs.CURRENT_VERSION }}
+          name: ${{ steps.get_version.outputs.CURRENT_VERSION }}
+          files: |
+            dist/*
+        env:
+          GITHUB_TOKEN: ${{ secrets.PAT }}

fabricatio-0.1.0/.github/workflows/pre-commit.yaml

@@ -0,0 +1,25 @@
+name: Pre-commit checks
+
+on:
+  pull_request:
+    branches:
+      - '**'
+  push:
+    branches:
+      - '**'
+
+jobs:
+  pre-commit-check:
+    runs-on: ubuntu-latest
+    environment: pre-commit
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      - name: Install the latest version of uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          version: "latest"
+      - name: Initialize pre-commit
+        run: uvx pre-commit install
+      - name: Run pre-commit hooks
+        run: uvx pre-commit run --all-files

fabricatio-0.1.0/.gitignore

@@ -0,0 +1,11 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+.idea

fabricatio-0.1.0/.python-version

@@ -0,0 +1 @@
+3.12

fabricatio-0.1.0/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.

fabricatio-0.1.0/PKG-INFO

@@ -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/pyproject.toml

@@ -0,0 +1,67 @@
+[project]
+name = "fabricatio"
+version = "0.1.0"
+description = "A LLM multi-agent framework."
+readme = "README.md"
+license = { file = "LICENSE" }
+authors = [
+    { name = "Whth", email = "zettainspector@foxmail.com" }
+]
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: Implementation :: CPython",
+    "Framework :: AsyncIO",
+    "Framework :: Pydantic :: 2",
+    "Typing :: Typed",
+]
+requires-python = ">=3.12"
+dependencies = [
+    "aiohttp>=3.11.11",
+    "aiomultiprocess>=0.9.1",
+    "appdirs>=1.4.4",
+    "asyncio>=3.4.3",
+    "litellm>=1.60.0",
+    "loguru>=0.7.3",
+    "pydantic>=2.10.6",
+    "pydantic-settings>=2.7.1",
+    "pymitter>=1.0.0",
+    "rich>=13.9.4",
+]
+
+[project.optional-dependencies]
+cli = [
+    "typer>=0.15.1",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+
+[dependency-groups]
+dev = [
+    "pytest>=8.3.4",
+    "pytest-cov>=6.0.0",
+    "pytest-env>=1.1.5",
+    "pytest-flake8>=1.3.0",
+    "pytest-mock>=3.14.0",
+    "pytest-rerunfailures>=15.0",
+    "pytest-xdist>=3.6.1",
+]
+cli = [
+    "click>=8.1.8",
+]
+
+[[tool.uv.index]]
+url = "https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple"
+
+[[tool.uv.index]]
+url = "https://mirrors.huaweicloud.com/repository/pypi/simple"
+
+[[tool.uv.index]]
+url = "https://mirrors.aliyun.com/pypi/simple/"
+
+[[tool.uv.index]]
+url = "https://mirrors.bfsu.edu.cn/pypi/web/simple"
+default = true

fabricatio-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/fabricatio/fs.py

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

fabricatio-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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