fabricatio 0.2.1.dev0__cp313-cp313-win_amd64.whl

fabricatio/__init__.py

@@ -0,0 +1,37 @@
+"""Fabricatio is a Python library for building llm app using event-based agent structure."""
+
+from fabricatio._rust_instances import template_manager
+from fabricatio.core import env
+from fabricatio.fs import magika
+from fabricatio.journal import logger
+from fabricatio.models.action import Action, WorkFlow
+from fabricatio.models.events import Event
+from fabricatio.models.role import Role
+from fabricatio.models.task import Task
+from fabricatio.models.tool import ToolBox
+from fabricatio.models.utils import Message, Messages
+from fabricatio.parser import Capture, CodeBlockCapture, JsonCapture, PythonCapture
+from fabricatio.toolboxes import arithmetic_toolbox, basic_toolboxes, fs_toolbox, task_toolbox
+
+__all__ = [
+    "Action",
+    "Capture",
+    "CodeBlockCapture",
+    "Event",
+    "JsonCapture",
+    "Message",
+    "Messages",
+    "PythonCapture",
+    "Role",
+    "Task",
+    "ToolBox",
+    "WorkFlow",
+    "arithmetic_toolbox",
+    "basic_toolboxes",
+    "env",
+    "fs_toolbox",
+    "logger",
+    "magika",
+    "task_toolbox",
+    "template_manager",
+]

fabricatio/_rust.pyi

@@ -0,0 +1,53 @@
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+class TemplateManager:
+    """TemplateManager class for managing handlebars templates."""
+    def __init__(
+        self, template_dirs: List[Path], suffix: Optional[str] = None, active_loading: Optional[bool] = None
+    ) -> None:
+        """Initialize the template manager.
+
+        Args:
+            template_dirs (List[Path]): A list of paths to directories containing templates.
+            suffix (str, optional): The suffix of template files. None means 'hbs' suffix.
+            active_loading (bool, optional): Whether to enable active loading of templates.
+        """
+
+    @property
+    def template_count(self) -> int:
+        """Get the number of templates discovered."""
+
+    def get_template_source(self, name: str) -> Optional[str]:
+        """Get the source path of a template by name.
+
+        Args:
+            name (str): The name of the template to retrieve.
+
+        Returns:
+            Optional[str]: The source path of the template.
+        """
+
+    def discover_templates(self) -> None:
+        """Discover templates in the specified directories."""
+
+    def render_template(self, name: str, data: Dict[str, Any]) -> str:
+        """Render a template with the given name and data.
+
+        Args:
+            name (str): The name of the template to render.
+            data (Dict[str, Any]): The data to pass to the template.
+
+        Returns:
+            str: The rendered template.
+        """
+
+def blake3_hash(content: bytes) -> str:
+    """Calculate the BLAKE3 hash of the given data.
+
+    Args:
+        content (bytes): The data to hash.
+
+    Returns:
+        str: The BLAKE3 hash of the data.
+    """

fabricatio/_rust_instances.py

@@ -0,0 +1,8 @@
+from fabricatio._rust import TemplateManager
+from fabricatio.config import configs
+
+template_manager = TemplateManager(
+    template_dirs=configs.templates.template_dir,
+    suffix=configs.templates.template_suffix,
+    active_loading=configs.templates.active_loading,
+)

fabricatio/actions/__init__.py

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

fabricatio/actions/communication.py

@@ -0,0 +1,15 @@
+"""Actions that involve communication with the user."""
+
+from fabricatio.models.action import Action
+from fabricatio.models.task import Task
+
+
+class Examining(Action):
+    """Action that examines the input data."""
+
+    name: str = "talk"
+    output_key: str = "examine_pass"
+
+    async def _execute(self, exam_target: Task[str], to_examine: str, **_) -> bool:
+        """Examine the input data."""
+        # TODO

fabricatio/actions/transmission.py

@@ -0,0 +1,23 @@
+"""Actions for transmitting tasks to targets."""
+
+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 PublishTask(Action):
+    """An action that publishes a task to a list of targets."""
+
+    name: str = "publish_task"
+    """The name of the action."""
+    description: str = "Publish a task to a list of targets."
+    """The description of the action."""
+
+    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.move_to(target).publish()

fabricatio/config.py

@@ -0,0 +1,263 @@
+"""Configuration module for the Fabricatio application."""
+
+from typing import List, Literal, Optional
+
+from appdirs import user_config_dir
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    DirectoryPath,
+    Field,
+    FilePath,
+    HttpUrl,
+    NonNegativeFloat,
+    PositiveInt,
+    SecretStr,
+)
+from pydantic_settings import (
+    BaseSettings,
+    DotEnvSettingsSource,
+    EnvSettingsSource,
+    PydanticBaseSettingsSource,
+    PyprojectTomlConfigSettingsSource,
+    SettingsConfigDict,
+    TomlConfigSettingsSource,
+)
+
+ROAMING_DIR = user_config_dir("fabricatio", "", roaming=True)
+
+
+class LLMConfig(BaseModel):
+    """LLM configuration class.
+
+    Attributes:
+        api_endpoint (HttpUrl): OpenAI API Endpoint.
+        api_key (SecretStr): OpenAI API key. Empty by default for security reasons, should be set before use.
+        timeout (PositiveInt): The timeout of the LLM model in seconds. Default is 300 seconds as per request.
+        max_retries (PositiveInt): The maximum number of retries. Default is 3 retries.
+        model (str): The LLM model name. Set to 'gpt-3.5-turbo' as per request.
+        temperature (NonNegativeFloat): The temperature of the LLM model. Controls randomness in generation. Set to 1.0 as per request.
+        stop_sign (str): The stop sign of the LLM model. No default stop sign specified.
+        top_p (NonNegativeFloat): The top p of the LLM model. Controls diversity via nucleus sampling. Set to 0.35 as per request.
+        generation_count (PositiveInt): The number of generations to generate. Default is 1.
+        stream (bool): Whether to stream the LLM model's response. Default is False.
+        max_tokens (PositiveInt): The maximum number of tokens to generate. Set to 8192 as per request.
+    """
+
+    model_config = ConfigDict(use_attribute_docstrings=True)
+    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 | List[str] = Field(default=("\n\n\n", "User:"))
+    """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 PymitterConfig(BaseModel):
+    """Pymitter configuration class.
+
+    Attributes:
+        delimiter (str): The delimiter used to separate the event name into segments.
+        new_listener_event (bool): If set, a newListener event is emitted when a new listener is added.
+        max_listeners (int): The maximum number of listeners per event.
+    """
+
+    model_config = ConfigDict(use_attribute_docstrings=True)
+    delimiter: str = Field(default="::", frozen=True)
+    """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."""
+
+    max_listeners: int = Field(default=-1, frozen=True)
+    """The maximum number of listeners per event."""
+
+
+class DebugConfig(BaseModel):
+    """Debug configuration class.
+
+    Attributes:
+        log_level (Literal["DEBUG", "INFO", "SUCCESS", "WARNING", "ERROR", "CRITICAL"]): The log level of the application.
+        log_file (FilePath): The log file of the application.
+    """
+
+    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."""
+
+    log_file: FilePath = Field(default=rf"{ROAMING_DIR}\fabricatio.log")
+    """The log file of the application."""
+
+    rotation: int = Field(default=1)
+    """The rotation of the log file. in weeks."""
+
+    retention: int = Field(default=2)
+    """The retention of the log file. in weeks."""
+
+    streaming_visible: bool = Field(default=False)
+    """Whether to print the llm output when streaming."""
+
+
+class TemplateConfig(BaseModel):
+    """Template configuration class."""
+
+    model_config = ConfigDict(use_attribute_docstrings=True)
+    template_dir: List[DirectoryPath] = Field(
+        default_factory=lambda: [DirectoryPath(r".\templates"), DirectoryPath(rf"{ROAMING_DIR}\templates")]
+    )
+    """The directory containing the templates."""
+    active_loading: bool = Field(default=False)
+    """Whether to enable active loading of templates."""
+
+    template_suffix: str = Field(default="hbs", frozen=True)
+    """The suffix of the templates."""
+
+    propose_task_template: str = Field(default="propose_task")
+    """The name of the propose task template which will be used to propose a task."""
+
+    draft_tool_usage_code_template: str = Field(default="draft_tool_usage_code")
+    """The name of the draft tool usage code template which will be used to draft tool usage code."""
+
+    make_choice_template: str = Field(default="make_choice")
+    """The name of the make choice template which will be used to make a choice."""
+
+    make_judgment_template: str = Field(default="make_judgment")
+    """The name of the make judgment template which will be used to make a judgment."""
+
+    dependencies_template: str = Field(default="dependencies")
+    """The name of the dependencies template which will be used to manage dependencies."""
+
+    task_briefing_template: str = Field(default="task_briefing")
+    """The name of the task briefing template which will be used to brief a task."""
+
+
+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 GeneralConfig(BaseModel):
+    """Global configuration class."""
+
+    model_config = ConfigDict(use_attribute_docstrings=True)
+    workspace: DirectoryPath = Field(default=DirectoryPath(r"."))
+    """The workspace directory for the application."""
+
+    confirm_on_ops: bool = Field(default=True)
+    """Whether to confirm on operations."""
+
+
+class ToolBoxConfig(BaseModel):
+    """Toolbox configuration class."""
+
+    model_config = ConfigDict(use_attribute_docstrings=True)
+
+    tool_module_name: str = Field(default="Toolbox")
+    """The name of the module containing the toolbox."""
+
+    data_module_name: str = Field(default="Data")
+    """The name of the module containing the data."""
+
+
+class Settings(BaseSettings):
+    """Application settings class.
+
+    Attributes:
+        llm (LLMConfig): LLM Configuration
+        debug (DebugConfig): Debug Configuration
+        pymitter (PymitterConfig): Pymitter Configuration
+        templates (TemplateConfig): Template Configuration
+        magika (MagikaConfig): Magika Configuration
+    """
+
+    model_config = SettingsConfigDict(
+        env_prefix="FABRIK_",
+        env_nested_delimiter="__",
+        pyproject_toml_depth=1,
+        pyproject_toml_table_header=("tool", "fabricatio"),
+        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"""
+
+    debug: DebugConfig = Field(default_factory=DebugConfig)
+    """Debug Configuration"""
+
+    pymitter: PymitterConfig = Field(default_factory=PymitterConfig)
+    """Pymitter Configuration"""
+
+    templates: TemplateConfig = Field(default_factory=TemplateConfig)
+    """Template Configuration"""
+
+    magika: MagikaConfig = Field(default_factory=MagikaConfig)
+    """Magika Configuration"""
+
+    general: GeneralConfig = Field(default_factory=GeneralConfig)
+    """General Configuration"""
+
+    toolbox: ToolBoxConfig = Field(default_factory=ToolBoxConfig)
+    """Toolbox 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, ...]:
+        """Customize settings sources.
+
+        Args:
+            settings_cls (type[BaseSettings]): The settings class.
+            init_settings (PydanticBaseSettingsSource): Initial settings source.
+            env_settings (PydanticBaseSettingsSource): Environment settings source.
+            dotenv_settings (PydanticBaseSettingsSource): Dotenv settings source.
+            file_secret_settings (PydanticBaseSettingsSource): File secret settings source.
+
+        Returns:
+            tuple[PydanticBaseSettingsSource, ...]: A tuple of settings sources.
+        """
+        return (
+            DotEnvSettingsSource(settings_cls),
+            EnvSettingsSource(settings_cls),
+            TomlConfigSettingsSource(settings_cls),
+            PyprojectTomlConfigSettingsSource(settings_cls),
+        )
+
+
+configs: Settings = Settings()

fabricatio/core.py

@@ -0,0 +1,167 @@
+"""Core module that contains the Env class for managing event handling."""
+
+from typing import Callable, Optional, Self, overload
+
+from pydantic import BaseModel, ConfigDict, PrivateAttr
+from pymitter import EventEmitter
+
+from fabricatio.config import configs
+from fabricatio.models.events import Event
+
+
+class Env(BaseModel):
+    """Environment class that manages event handling using EventEmitter."""
+
+    model_config = ConfigDict(use_attribute_docstrings=True)
+    _ee: EventEmitter = PrivateAttr(
+        default_factory=lambda: EventEmitter(
+            delimiter=configs.pymitter.delimiter,
+            new_listener=configs.pymitter.new_listener_event,
+            max_listeners=configs.pymitter.max_listeners,
+            wildcard=True,
+        )
+    )
+
+    @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: Optional[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: Optional[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)
+
+        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: Optional[Callable[P, R]] = None,
+    ) -> 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:
+            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)
+
+        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.
+        """
+        if isinstance(event, Event):
+            event = event.collapse()
+
+        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.
+        """
+        if isinstance(event, Event):
+            event = event.collapse()
+        return await self._ee.emit_async(event, *args, **kwargs)
+
+
+env = Env()