fabricatio 0.2.0.dev4__cp312-cp312-win_amd64.whl

fabricatio/__init__.py

@@ -0,0 +1,32 @@
+"""Fabricatio is a Python library for building llm app using event-based agent structure."""
+
+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.templates import templates_manager
+
+__all__ = [
+    "Action",
+    "Capture",
+    "CodeBlockCapture",
+    "Event",
+    "JsonCapture",
+    "Message",
+    "Messages",
+    "PythonCapture",
+    "Role",
+    "Task",
+    "ToolBox",
+    "WorkFlow",
+    "env",
+    "logger",
+    "magika",
+    "templates_manager",
+]

fabricatio/_rust.pyi

@@ -0,0 +1 @@
+def download_templates() -> None: ...

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,13 @@
+from fabricatio.models.action import Action
+from fabricatio.models.task import Task
+
+
+class Talk(Action):
+    """Action that says hello to the world."""
+
+    name: str = "talk"
+    output_key: str = "talk_response"
+
+    async def _execute(self, task_input: Task[str], **_) -> str:
+        """Execute the action."""
+        return await self.aask(task_input.briefing, system_message=task_input.generate_prompt())

fabricatio/actions/transmission.py

@@ -0,0 +1,32 @@
+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()
+
+
+class CycleTask(Action):
+    """An action that cycles a task through a list of targets."""
+
+    name: str = "cycle_task"
+    """The name of the action."""
+    description: str = "Cycle a task through a list of targets"
+
+    async def _execute(self, task_input: Task, **_) -> None:
+        """Execute the action by cycling the task through the specified targets."""

fabricatio/config.py

@@ -0,0 +1,206 @@
+"""Configuration module for the Fabricatio application."""
+
+from pathlib import Path
+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", "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."""
+
+
+class Code2PromptConfig(BaseModel):
+    """Code2Prompt configuration class."""
+
+    model_config = ConfigDict(use_attribute_docstrings=True)
+    template_dir: List[DirectoryPath] = Field(
+        default_factory=lambda: [Path(r".\templates"), Path(rf"{ROAMING_DIR}\templates")]
+    )
+    """The directory containing the templates for code2prompt."""
+
+    template_suffix: str = Field(default=".hbs", frozen=True)
+    """The suffix of the template files 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):
+    """Application settings class.
+
+    Attributes:
+        llm (LLMConfig): LLM Configuration
+        debug (DebugConfig): Debug Configuration
+        pymitter (PymitterConfig): Pymitter Configuration
+        code2prompt (Code2PromptConfig): Code2Prompt 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"""
+
+    code2prompt: Code2PromptConfig = Field(default_factory=Code2PromptConfig)
+    """Code2Prompt Configuration"""
+
+    magika: MagikaConfig = Field(default_factory=MagikaConfig)
+    """Magika 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()

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,5 @@
+"""FileSystem manipulation module for Fabricatio."""
+
+from fabricatio.fs.readers import magika
+
+__all__ = ["magika"]

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/journal.py

@@ -0,0 +1,23 @@
+"""Logging setup for the project."""
+
+import sys
+
+from loguru import logger
+from rich import traceback
+
+from fabricatio.config import configs
+
+traceback.install()
+logger.remove()
+logger.add(
+    configs.debug.log_file, level=configs.debug.log_level, rotation="1 weeks", retention="1 month", compression="zip"
+)
+logger.add(sys.stderr, level=configs.debug.log_level)
+
+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,128 @@
+"""Module that contains the classes for actions and workflows."""
+
+import traceback
+from abc import abstractmethod
+from asyncio import Queue
+from typing import Any, Dict, Self, Tuple, Type, Unpack
+
+from fabricatio.journal import logger
+from fabricatio.models.generic import LLMUsage, WithBriefing
+from fabricatio.models.task import ProposeTask, Task
+from pydantic import Field, PrivateAttr
+
+
+class Action(ProposeTask):
+    """Class that represents an action to be executed in a workflow."""
+
+    personality: str = Field(default="")
+    """The personality of whom the action belongs to."""
+    output_key: str = Field(default="")
+    """The key of the output data."""
+
+    @abstractmethod
+    async def _execute(self, **cxt: Unpack) -> Any:
+        """Execute the action with the provided arguments.
+
+        Args:
+            **cxt: The context dictionary containing input and output data.
+
+        Returns:
+            The result of the action execution.
+        """
+        pass
+
+    async def act(self, cxt: Dict[str, Any]) -> Dict[str, Any]:
+        """Perform the action by executing it and setting the output data.
+
+        Args:
+            cxt: The context dictionary containing input and output data.
+        """
+        ret = await self._execute(**cxt)
+        if self.output_key:
+            logger.debug(f"Setting output: {self.output_key}")
+            cxt[self.output_key] = ret
+        return cxt
+
+    def briefing(self) -> str:
+        """Return a brief description of the action."""
+        if self.personality:
+            return f"## Your personality: \n{self.personality}\n# The action you are going to perform: \n{super().briefing}"
+        return f"# The action you are going to perform: \n{super().briefing}"
+
+
+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))
+    """ The context dictionary to be used for workflow execution."""
+
+    _instances: Tuple[Action, ...] = PrivateAttr(...)
+    """ The instances of the workflow steps."""
+
+    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.
+
+        Args:
+            __context: The context to be used for initialization.
+        """
+        temp = []
+        for step in self.steps:
+            temp.append(step if isinstance(step, Action) else step())
+        self._instances = tuple(temp)
+
+    def inject_personality(self, personality: str) -> Self:
+        """Inject the personality of the workflow.
+
+        Args:
+            personality: The personality to be injected.
+
+        Returns:
+            Self: The instance of the workflow with the injected personality.
+        """
+        for a in self._instances:
+            if not a.personality:
+                a.personality = personality
+        return self
+
+    async def serve(self, task: Task) -> None:
+        """Serve the task by executing the workflow steps.
+
+        Args:
+            task: The task to be served.
+        """
+        await task.start()
+        await self._init_context()
+        current_action = None
+        try:
+            for step in self._instances:
+                logger.debug(f"Executing step: {step.name}")
+                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}")
+            await task.finish((await self._context.get()).get(self.task_output_key, None))
+        except RuntimeError as e:
+            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)})
+
+    def fallback_to_self(self) -> Self:
+        """Set the fallback for each step to the workflow itself."""
+        for step in self._instances:
+            step.fallback_to(self)
+        return self