fabricatio 0.3.15.dev5__cp313-cp313-win_amd64.whl → 0.4.0.dev0__cp313-cp313-win_amd64.whl

fabricatio/models/kwargs_types.py

@@ -1,121 +0,0 @@
-"""This module contains the types for the keyword arguments of the methods in the models module."""
-
-from typing import Dict, List, NotRequired, Optional, Required, TypedDict
-
-
-class ChunkKwargs(TypedDict):
-    """Configuration parameters for chunking operations."""
-
-    max_chunk_size: int
-    max_overlapping_rate: NotRequired[float]
-
-
-class EmbeddingKwargs(TypedDict, total=False):
-    """Configuration parameters for text embedding operations.
-
-    These settings control the behavior of embedding models that convert text
-    to vector representations.
-    """
-
-    model: str
-    dimensions: int
-    timeout: int
-    caching: bool
-
-
-class LLMKwargs(TypedDict, total=False):
-    """Configuration parameters for language model inference.
-
-    These arguments control the behavior of large language model calls,
-    including generation parameters and caching options.
-    """
-
-    model: Optional[str]
-    temperature: float
-    stop: str | list[str]
-    top_p: float
-    max_tokens: int
-    stream: bool
-    timeout: int
-    max_retries: int
-    no_cache: bool  # if the req uses cache in this call
-    no_store: bool  # If store the response of this call to cache
-    cache_ttl: int  # how long the stored cache is alive, in seconds
-    s_maxage: int  # max accepted age of cached response, in seconds
-    presence_penalty: float
-    frequency_penalty: float
-
-
-class GenerateKwargs(LLMKwargs, total=False):
-    """Arguments for content generation operations.
-
-    Extends LLMKwargs with additional parameters specific to generation tasks,
-    such as the number of generated items and the system message.
-    """
-
-    system_message: str
-
-
-class ValidateKwargs[T](GenerateKwargs, total=False):
-    """Arguments for content validation operations.
-
-    Extends LLMKwargs with additional parameters specific to validation tasks,
-    such as limiting the number of validation attempts.
-    """
-
-    default: Optional[T]
-    max_validations: int
-
-
-class CompositeScoreKwargs(ValidateKwargs[List[Dict[str, float]]], total=False):
-    """Arguments for composite score generation operations.
-
-    Extends GenerateKwargs with parameters for generating composite scores
-    based on specific criteria and weights.
-    """
-
-    topic: str
-    criteria: set[str]
-    weights: Dict[str, float]
-    manual: Dict[str, str]
-
-
-class BestKwargs(CompositeScoreKwargs, total=False):
-    """Arguments for choose top-k operations."""
-
-    k: int
-
-
-class ReviewInnerKwargs[T](ValidateKwargs[T], total=False):
-    """Arguments for content review operations."""
-
-    criteria: set[str]
-
-
-# noinspection PyTypedDict
-class ReviewKwargs[T](ReviewInnerKwargs[T], total=False):
-    """Arguments for content review operations.
-
-    Extends GenerateKwargs with parameters for evaluating content against
-    specific topics and review criteria.
-    """
-
-    rating_manual: Dict[str, str]
-    topic: Required[str]
-
-
-class ReferencedKwargs[T](ValidateKwargs[T], total=False):
-    """Arguments for content review operations."""
-
-    reference: str
-
-
-# noinspection PyTypedDict
-class ChooseKwargs[T](ValidateKwargs[T], total=False):
-    """Arguments for selection operations.
-
-    Extends GenerateKwargs with parameters for selecting among options,
-    such as the number of items to choose.
-    """
-
-    k: int

fabricatio/models/role.py

@@ -1,156 +0,0 @@
-"""Module that contains the Role class for managing workflows and their event registrations."""
-
-from functools import partial
-from typing import Any, Callable, Dict, Self, Type
-
-from fabricatio.emitter import env
-from fabricatio.journal import logger
-from fabricatio.models.action import WorkFlow
-from fabricatio.models.generic import WithBriefing
-from fabricatio.rust import Event
-from fabricatio.utils import is_subclass_of_base
-from pydantic import ConfigDict, Field
-
-is_toolbox_usage = partial(is_subclass_of_base, base_module="fabricatio.models.usages", base_name="ToolBoxUsage")
-is_scoped_config = partial(is_subclass_of_base, base_module="fabricatio.models.generic", base_name="ScopedConfig")
-
-
-class Role(WithBriefing):
-    """Class that represents a role with a registry of events and workflows.
-
-    A Role serves as a container for workflows, managing their registration to events
-    and providing them with shared configuration like tools and personality.
-    """
-
-    model_config = ConfigDict(use_attribute_docstrings=True, arbitrary_types_allowed=True)
-    name: str = ""
-    """The name of the role."""
-    description: str = ""
-    """A brief description of the role's responsibilities and capabilities."""
-
-    registry: Dict[Event, WorkFlow] = Field(default_factory=dict)
-    """The registry of events and workflows."""
-    dispatch_on_init: bool = True
-    """Whether to dispatch registered workflows on initialization."""
-
-    def model_post_init(self, __context: Any) -> None:
-        """Initialize the role by resolving configurations and registering workflows.
-
-        Args:
-            __context: The context used for initialization
-        """
-        self.name = self.name or self.__class__.__name__
-
-        if self.dispatch_on_init:
-            self.resolve_configuration().dispatch()
-
-    def register_workflow(self, event: Event, workflow: WorkFlow) -> Self:
-        """Register a workflow to the role's registry."""
-        if event in self.registry:
-            logger.warning(
-                f"Event `{event.collapse()}` is already registered with workflow "
-                f"`{self.registry[event].name}`. It will be overwritten by `{workflow.name}`."
-            )
-        self.registry[event] = workflow
-        return self
-
-    def dispatch(self) -> Self:
-        """Register each workflow in the registry to its corresponding event in the event bus.
-
-        Returns:
-            Self: The role instance for method chaining
-        """
-        for event, workflow in self.registry.items():
-            logger.debug(f"Registering workflow: `{workflow.name}` for event: `{event.collapse()}`")
-            env.on(event, workflow.serve)
-        return self
-
-    def resolve_configuration(self) -> Self:
-        """Apply role-level configuration to all workflows in the registry.
-
-        This includes setting up fallback configurations, injecting personality traits,
-        and providing tool access to workflows and their steps.
-
-        Returns:
-            Self: The role instance for method chaining
-        """
-        for workflow in self.registry.values():
-            logger.debug(f"Resolving config for workflow: `{workflow.name}`")
-            self._configure_scoped_config(workflow)._configure_toolbox_usage(workflow)
-
-            workflow.inject_personality(self.briefing)
-        return self
-
-    def _propagate_config(
-        self,
-        workflow: WorkFlow,
-        has_capability: Callable[[Type], bool],
-        config_method_name: str,
-        capability_description: str,
-    ) -> Self:
-        """Propagates configuration from the Role to a Workflow and its Actions.
-
-        This method checks if the Role, Workflow, or its Actions possess a specific
-        capability (e.g., being a ScopedConfig or ToolBoxUsage). If they do,
-        a specified configuration method is called on them to apply or inherit
-        settings.
-
-        The configuration flows hierarchically:
-        1. If the Role has the capability, it's the initial source.
-        2. If the Workflow also has the capability, it can inherit from the Role
-           and then becomes the source for its Actions.
-        3. Actions with the capability inherit from the determined source (either
-           Workflow or Role).
-
-        Args:
-            workflow: The WorkFlow instance to configure.
-            has_capability: A callable that takes a Type and returns True if
-                            the type possesses the specific capability, False otherwise.
-            config_method_name: The name of the method to call on an object
-                                (Role, Workflow, Action) to apply the configuration.
-                                For example, "fallback_to" or "supply_tools_from".
-            capability_description: A string describing the capability, used for
-                                    logging purposes (e.g., "scoped config", "toolbox usage").
-        """
-        # This variable will hold the object from which Actions should inherit their configuration.
-        # It could be the Role itself or the Workflow, depending on their capabilities.
-        config_source_for_actions = None
-
-        # Check if the Role itself has the capability.
-        if has_capability(self.__class__):
-            # If the Role has the capability, it becomes the initial source for configuration.
-            config_source_for_actions = self
-
-        # Check if the Workflow has the capability.
-        if has_capability(workflow.__class__):
-            logger.debug(
-                f"Configuring {capability_description} inherited from `{self.name}` for workflow: `{workflow.name}`"
-            )
-            # If the Role was already identified as a config source,
-            # the Workflow an inherit its configuration directly from the Role.
-            if config_source_for_actions is not None:
-                # Call the specified configuration method on the workflow, passing the Role (self) as the source.
-                getattr(workflow, config_method_name)(config_source_for_actions)
-
-            # After potentially inheriting from the Role, the Workflow itself becomes
-            # the source of configuration for its Actions.
-            config_source_for_actions = workflow
-
-        # If a configuration source (either Role or Workflow) has been established:
-        if config_source_for_actions is not None:
-            # Iterate over all actions within the workflow.
-            # Filter for actions that possess the specified capability.
-            for action in (act for act in workflow.iter_actions() if has_capability(act.__class__)):
-                # Call the specified configuration method on the action,
-                # passing the determined config_source_for_actions.
-                getattr(action, config_method_name)(config_source_for_actions)
-
-        return self
-
-    def _configure_scoped_config(self, workflow: WorkFlow) -> Self:
-        """Configure scoped configuration for workflow and its actions."""
-        return self._propagate_config(workflow, is_scoped_config, "fallback_to", "scoped config")
-
-    def _configure_toolbox_usage(self, workflow: WorkFlow) -> Self:
-        """Configure toolbox usage for workflow and its actions."""
-        return self._propagate_config(workflow, is_toolbox_usage, "supply_tools_from", "toolbox usage")

fabricatio/models/task.py

@@ -1,310 +0,0 @@
-"""This module defines the `Task` class, which represents a task with a status and output.
-
-It includes methods to manage the task's lifecycle, such as starting, finishing, cancelling, and failing the task.
-"""
-
-from asyncio import Queue
-from typing import Any, Dict, List, Optional, Self, Union
-
-from fabricatio.emitter import env
-from fabricatio.journal import logger
-from fabricatio.models.generic import ProposedAble, WithBriefing, WithDependency
-from fabricatio.rust import CONFIG, TEMPLATE_MANAGER, Event, TaskStatus
-from pydantic import Field, PrivateAttr
-
-type EventLike = Union[str, Event, List[str]]
-
-
-class Task[T](WithBriefing, ProposedAble, WithDependency):
-    """A class representing a task with a status and output.
-
-    Attributes:
-        name (str): The name of the task.
-        description (str): The description of the task.
-        goals (str): The goal of the task.
-        dependencies (List[str]): The file dependencies of the task, a list of file paths.
-        namespace (List[str]): The namespace of the task, a list of namespace segment, as string.
-    """
-
-    name: str = Field(...)
-    """The name of the task, which should be concise and descriptive."""
-
-    description: str = Field(default="")
-    """A detailed explanation of the task that includes all necessary information. Should be clear and answer what, why, when, where, who, and how questions."""
-
-    goals: List[str] = Field(default_factory=list)
-    """A list of objectives that the task aims to accomplish. Each goal should be clear and specific. Complex tasks should be broken into multiple smaller goals."""
-
-    namespace: List[str] = Field(default_factory=list)
-    """A list of string segments that identify the task's location in the system. If not specified, defaults to an empty list."""
-
-    dependencies: List[str] = Field(default_factory=list)
-    """A list of file paths that are needed or mentioned in the task's description (either reading or writing) to complete this task. If not specified, defaults to an empty list."""
-
-    _output: Queue[T | None] = PrivateAttr(default_factory=Queue)
-    """The output queue of the task."""
-
-    _status: TaskStatus = PrivateAttr(default=TaskStatus.Pending)
-    """The status of the task."""
-
-    _namespace: Event = PrivateAttr(default_factory=Event)
-    """The namespace of the task as an event, which is generated from the namespace list."""
-    _extra_init_context: Dict = PrivateAttr(default_factory=dict)
-    """Extra initialization context for the task, which is designed to override the one of the Workflow."""
-
-    @property
-    def extra_init_context(self) -> Dict:
-        """Extra initialization context for the task, which is designed to override the one of the Workflow."""
-        return self._extra_init_context
-
-    def update_init_context(self, /, **kwargs) -> Self:
-        """Update the extra initialization context for the task."""
-        self.extra_init_context.update(kwargs)
-        return self
-
-    def model_post_init(self, __context: Any) -> None:
-        """Initialize the task with a namespace event."""
-        self._namespace.concat(self.namespace)
-
-    def move_to(self, new_namespace: EventLike) -> Self:
-        """Move the task to a new namespace.
-
-        Args:
-            new_namespace (EventLike): The new namespace to move the task to.
-
-        Returns:
-            Task: The moved instance of the `Task` class.
-        """
-        logger.debug(f"Moving task `{self.name}` to `{new_namespace}`")
-        self._namespace.clear().concat(new_namespace)
-        self.namespace = self._namespace.segments
-        return self
-
-    def nested_move_to(self, new_parent_namespace: EventLike) -> Self:
-        """Move the task to a new namespace by nesting it under the new parent namespace.
-
-        Args:
-            new_parent_namespace (EventLike): The new parent namespace to move the task to.
-
-        Returns:
-            Task: The nested moved instance of the `Task` class.
-        """
-        logger.debug(f"Nested moving task `{self.name}` to `{new_parent_namespace}`")
-        self._namespace.clear().concat(new_parent_namespace).concat(self.namespace)
-        self.namespace = self._namespace.segments
-        return self
-
-    def update_task(self, goal: Optional[List[str] | str] = None, description: Optional[str] = None) -> Self:
-        """Update the goal and description of the task.
-
-        Args:
-            goal (str|List[str], optional): The new goal of the task.
-            description (str, optional): The new description of the task.
-
-        Returns:
-            Task: The updated instance of the `Task` class.
-        """
-        if goal:
-            self.goals = goal if isinstance(goal, list) else [goal]
-        if description:
-            self.description = description
-        return self
-
-    async def get_output(self) -> T | None:
-        """Get the output of the task.
-
-        Returns:
-            T: The output of the task.
-        """
-        logger.debug(f"Getting output for task {self.name}")
-        return await self._output.get()
-
-    def status_label(self, status: TaskStatus) -> str:
-        """Return a formatted status label for the task.
-
-        Args:
-            status (fabricatio.constants.TaskStatus): The status of the task.
-
-        Returns:
-            str: The formatted status label.
-        """
-        return self._namespace.derive(self.name).push(status).collapse()
-
-    @property
-    def pending_label(self) -> str:
-        """Return the pending status label for the task.
-
-        Returns:
-            str: The pending status label.
-        """
-        return self.status_label(TaskStatus.Pending)
-
-    @property
-    def running_label(self) -> str:
-        """Return the running status label for the task.
-
-        Returns:
-            str: The running status label.
-        """
-        return self.status_label(TaskStatus.Running)
-
-    @property
-    def finished_label(self) -> str:
-        """Return the finished status label for the task.
-
-        Returns:
-            str: The finished status label.
-        """
-        return self.status_label(TaskStatus.Finished)
-
-    @property
-    def failed_label(self) -> str:
-        """Return the failed status label for the task.
-
-        Returns:
-            str: The failed status label.
-        """
-        return self.status_label(TaskStatus.Failed)
-
-    @property
-    def cancelled_label(self) -> str:
-        """Return the cancelled status label for the task.
-
-        Returns:
-            str: The cancelled status label.
-        """
-        return self.status_label(TaskStatus.Cancelled)
-
-    async def finish(self, output: T) -> Self:
-        """Mark the task as finished and set the output.
-
-        Args:
-            output (T): The output of the task.
-
-        Returns:
-            Task: The finished instance of the `Task` class.
-        """
-        logger.info(f"Finishing task {self.name}")
-        self._status = TaskStatus.Finished
-        await self._output.put(output)
-        logger.debug(f"Output set for task {self.name}")
-        await env.emit_async(self.finished_label, self)
-        logger.debug(f"Emitted finished event for task {self.name}")
-        return self
-
-    async def start(self) -> Self:
-        """Mark the task as running.
-
-        Returns:
-            Task: The running instance of the `Task` class.
-        """
-        logger.info(f"Starting task `{self.name}`")
-        self._status = TaskStatus.Running
-        await env.emit_async(self.running_label, self)
-        return self
-
-    async def cancel(self) -> Self:
-        """Mark the task as cancelled.
-
-        Returns:
-            Task: The cancelled instance of the `Task` class.
-        """
-        logger.info(f"Cancelling task `{self.name}`")
-        self._status = TaskStatus.Cancelled
-        await self._output.put(None)
-        await env.emit_async(self.cancelled_label, self)
-        return self
-
-    async def fail(self) -> Self:
-        """Mark the task as failed.
-
-        Returns:
-            Task: The failed instance of the `Task` class.
-        """
-        logger.info(f"Failing task `{self.name}`")
-        self._status = TaskStatus.Failed
-        await self._output.put(None)
-        await env.emit_async(self.failed_label, self)
-        return self
-
-    def publish(self, new_namespace: Optional[EventLike] = None) -> Self:
-        """Publish the task to the event bus.
-
-        Args:
-            new_namespace(EventLike, optional): The new namespace to move the task to.
-
-        Returns:
-            Task: The published instance of the `Task` class.
-        """
-        if new_namespace:
-            self.move_to(new_namespace)
-        logger.info(f"Publishing task `{(label := self.pending_label)}`")
-        env.emit_future(label, self)
-        return self
-
-    async def delegate(self, new_namespace: Optional[EventLike] = None) -> T | None:
-        """Delegate the task to the event.
-
-        Args:
-            new_namespace(EventLike, optional): The new namespace to move the task to.
-
-        Returns:
-            T|None: The output of the task.
-        """
-        if new_namespace:
-            self.move_to(new_namespace)
-        logger.info(f"Delegating task `{(label := self.pending_label)}`")
-        env.emit_future(label, self)
-        return await self.get_output()
-
-    @property
-    def briefing(self) -> str:
-        """Return a briefing of the task including its goal.
-
-        Returns:
-            str: The briefing of the task.
-        """
-        return TEMPLATE_MANAGER.render_template(
-            CONFIG.templates.task_briefing_template,
-            self.model_dump(),
-        )
-
-    def is_running(self) -> bool:
-        """Check if the task is running.
-
-        Returns:
-            bool: True if the task is running, False otherwise.
-        """
-        return self._status == TaskStatus.Running
-
-    def is_finished(self) -> bool:
-        """Check if the task is finished.
-
-        Returns:
-            bool: True if the task is finished, False otherwise.
-        """
-        return self._status == TaskStatus.Finished
-
-    def is_failed(self) -> bool:
-        """Check if the task is failed.
-
-        Returns:
-            bool: True if the task is failed, False otherwise.
-        """
-        return self._status == TaskStatus.Failed
-
-    def is_cancelled(self) -> bool:
-        """Check if the task is cancelled.
-
-        Returns:
-            bool: True if the task is cancelled, False otherwise.
-        """
-        return self._status == TaskStatus.Cancelled
-
-    def is_pending(self) -> bool:
-        """Check if the task is pending.
-
-        Returns:
-            bool: True if the task is pending, False otherwise.
-        """
-        return self._status == TaskStatus.Pending