fabricatio 0.2.1.dev0__cp313-cp313-win_amd64.whl → 0.3.14.dev5__cp313-cp313-win_amd64.whl

fabricatio/config.py

@@ -1,263 +0,0 @@
-"""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/models/advanced.py

@@ -1,128 +0,0 @@
-"""A module for advanced models and functionalities."""
-
-from types import CodeType
-from typing import Any, Dict, List, Optional, Tuple, Unpack
-
-import orjson
-from fabricatio._rust_instances import template_manager
-from fabricatio.config import configs
-from fabricatio.models.generic import WithBriefing
-from fabricatio.models.kwargs_types import LLMKwargs
-from fabricatio.models.task import Task
-from fabricatio.models.tool import Tool, ToolExecutor
-from fabricatio.models.usages import LLMUsage, ToolBoxUsage
-from fabricatio.parser import JsonCapture, PythonCapture
-from loguru import logger
-from pydantic import PositiveInt, ValidationError
-
-
-class ProposeTask(WithBriefing, LLMUsage):
-    """A class that proposes a task based on a prompt."""
-
-    async def propose[T](
-        self,
-        prompt: str,
-        max_validations: PositiveInt = 2,
-        **kwargs: Unpack[LLMKwargs],
-    ) -> Task[T]:
-        """Asynchronously proposes a task based on a given prompt and parameters.
-
-        Parameters:
-            prompt: The prompt text for proposing a task, which is a string that must be provided.
-            max_validations: The maximum number of validations allowed, default is 2.
-            **kwargs: The keyword arguments for the LLM (Large Language Model) usage.
-
-        Returns:
-            A Task object based on the proposal result.
-        """
-        if not prompt:
-            err = f"{self.name}: Prompt must be provided."
-            logger.error(err)
-            raise ValueError(err)
-
-        def _validate_json(response: str) -> None | Task:
-            try:
-                cap = JsonCapture.capture(response)
-                logger.debug(f"Response: \n{response}")
-                logger.info(f"Captured JSON: \n{cap}")
-                return Task.model_validate_json(cap)
-            except ValidationError as e:
-                logger.error(f"Failed to parse task from JSON: {e}")
-                return None
-
-        template_data = {"prompt": prompt, "json_example": Task.json_example()}
-        return await self.aask_validate(
-            question=template_manager.render_template(configs.templates.propose_task_template, template_data),
-            validator=_validate_json,
-            system_message=f"# your personal briefing: \n{self.briefing}",
-            max_validations=max_validations,
-            **kwargs,
-        )
-
-
-class HandleTask(WithBriefing, ToolBoxUsage):
-    """A class that handles a task based on a task object."""
-
-    async def draft_tool_usage_code(
-        self,
-        task: Task,
-        tools: List[Tool],
-        data: Dict[str, Any],
-        **kwargs: Unpack[LLMKwargs],
-    ) -> Tuple[CodeType, List[str]]:
-        """Asynchronously drafts the tool usage code for a task based on a given task object and tools."""
-        logger.info(f"Drafting tool usage code for task: {task.briefing}")
-
-        if not tools:
-            err = f"{self.name}: Tools must be provided to draft the tool usage code."
-            logger.error(err)
-            raise ValueError(err)
-
-        def _validator(response: str) -> Tuple[CodeType, List[str]] | None:
-            if (source := PythonCapture.convert_with(response, lambda resp: compile(resp, "<string>", "exec"))) and (
-                to_extract := JsonCapture.convert_with(response, orjson.loads)
-            ):
-                return source, to_extract
-
-            return None
-
-        q = template_manager.render_template(
-            configs.templates.draft_tool_usage_code_template,
-            {
-                "data_module_name": configs.toolbox.data_module_name,
-                "tool_module_name": configs.toolbox.tool_module_name,
-                "task": task.briefing,
-                "deps": task.dependencies_prompt,
-                "tools": [{"name": t.name, "briefing": t.briefing} for t in tools],
-                "data": data,
-            },
-        )
-        logger.debug(f"Code Drafting Question: \n{q}")
-        return await self.aask_validate(
-            question=q,
-            validator=_validator,
-            system_message=f"# your personal briefing: \n{self.briefing}",
-            **kwargs,
-        )
-
-    async def handle_fin_grind(
-        self,
-        task: Task,
-        data: Dict[str, Any],
-        **kwargs: Unpack[LLMKwargs],
-    ) -> Optional[Tuple]:
-        """Asynchronously handles a task based on a given task object and parameters."""
-        logger.info(f"Handling task: \n{task.briefing}")
-
-        tools = await self.gather_tools(task)
-        logger.info(f"{self.name} have gathered {[t.name for t in tools]}")
-
-        if tools:
-            executor = ToolExecutor(candidates=tools, data=data)
-            code, to_extract = await self.draft_tool_usage_code(task, tools, data, **kwargs)
-
-            cxt = executor.execute(code)
-            if to_extract:
-                return tuple(cxt.get(k) for k in to_extract)
-
-        return None

fabricatio/models/events.py

@@ -1,82 +0,0 @@
-"""The module containing the Event class."""
-
-from typing import List, Self, Union
-
-from fabricatio.config import configs
-from pydantic import BaseModel, ConfigDict, Field
-
-type EventLike = Union[str, List[str], "Event"]
-
-
-class Event(BaseModel):
-    """A class representing an event."""
-
-    model_config = ConfigDict(use_attribute_docstrings=True)
-
-    segments: List[str] = Field(default_factory=list, frozen=True)
-    """ The segments of the namespaces."""
-
-    @classmethod
-    def instantiate_from(cls, event: EventLike) -> Self:
-        """Create an Event instance from a string or list of strings or an Event instance.
-
-        Args:
-            event (EventLike): The event to instantiate from.
-
-        Returns:
-            Event: The Event instance.
-        """
-        if isinstance(event, Event):
-            return event.clone()
-        if isinstance(event, str):
-            event = event.split(configs.pymitter.delimiter)
-
-        return cls(segments=event)
-
-    def derive(self, event: EventLike) -> Self:
-        """Derive a new event from this event and another event or a string."""
-        return self.clone().concat(event)
-
-    def collapse(self) -> str:
-        """Collapse the event into a string."""
-        return configs.pymitter.delimiter.join(self.segments)
-
-    def clone(self) -> Self:
-        """Clone the event."""
-        return Event(segments=list(self.segments))
-
-    def push(self, segment: str) -> Self:
-        """Push a segment to the event."""
-        if not segment:
-            raise ValueError("The segment must not be empty.")
-        if configs.pymitter.delimiter in segment:
-            raise ValueError("The segment must not contain the delimiter.")
-
-        self.segments.append(segment)
-        return self
-
-    def push_wildcard(self) -> Self:
-        """Push a wildcard segment to the event."""
-        return self.push("*")
-
-    def pop(self) -> str:
-        """Pop a segment from the event."""
-        return self.segments.pop()
-
-    def clear(self) -> Self:
-        """Clear the event."""
-        self.segments.clear()
-        return self
-
-    def concat(self, event: EventLike) -> Self:
-        """Concatenate another event to this event."""
-        self.segments.extend(Event.instantiate_from(event).segments)
-        return self
-
-    def __hash__(self) -> int:
-        """Return the hash of the event, using the collapsed string."""
-        return hash(self.collapse())
-
-    def __eq__(self, other: str | List[str] | Self) -> bool:
-        """Check if the event is equal to another event or a string."""
-        return self.collapse() == Event.instantiate_from(other).collapse()

fabricatio/models/utils.py

@@ -1,78 +0,0 @@
-"""A module containing utility classes for the models."""
-
-from typing import Dict, List, Literal, Self
-
-from pydantic import BaseModel, ConfigDict, Field
-
-
-class Message(BaseModel):
-    """A class representing a message."""
-
-    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/toolboxes/task.py

@@ -1,6 +0,0 @@
-"""This module contains the toolbox for tasks management."""
-
-from fabricatio.models.task import Task
-from fabricatio.models.tool import ToolBox
-
-task_toolbox = ToolBox(name="TaskToolBox", description="A toolbox for tasks management.").add_tool(Task.simple_task)