fabricatio 0.2.6.dev4__tar.gz → 0.2.6.dev5__tar.gz

{fabricatio-0.2.6.dev4 → fabricatio-0.2.6.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.6.dev4
+Version: 0.2.6.dev5
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12

{fabricatio-0.2.6.dev4 → fabricatio-0.2.6.dev5}/examples/make_diary/diary.py

@@ -57,7 +57,7 @@ class DumpText(Action):
             ["dump the text contained in `text_to_dump` to a file", "only return the path of the written file"]
         )
 
-        path = await self.handle_fin_grind(
+        path = await self.handle_fine_grind(
             task_input,
             {"text_to_dump": dump_text},
         )

{fabricatio-0.2.6.dev4 → fabricatio-0.2.6.dev5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fabricatio"
-version = "0.2.6-dev4"
+version = "0.2.6-dev5"
 description = "A LLM multi-agent framework."
 readme = "README.md"
 license = { file = "LICENSE" }

fabricatio-0.2.6.dev5/python/fabricatio/capabilities/covalidate.py

@@ -0,0 +1,160 @@
+"""Co-validation capability for LLMs."""
+
+from asyncio import gather
+from typing import Callable, List, Optional, Union, Unpack, overload
+
+from fabricatio import TEMPLATE_MANAGER
+from fabricatio.config import configs
+from fabricatio.journal import logger
+from fabricatio.models.kwargs_types import GenerateKwargs
+from fabricatio.models.usages import LLMUsage
+
+
+class CoValidate(LLMUsage):
+    """Class that represents a co-validation capability using multiple LLMs.
+
+    This class provides methods to validate responses by attempting multiple approaches:
+    1. Using the primary LLM to generate a response
+    2. Using a secondary (co-) model to refine responses that fail validation
+    3. Trying multiple times if needed
+    """
+
+    @overload
+    async def aask_covalidate[T](
+        self,
+        question: str,
+        validator: Callable[[str], T | None],
+        co_model: Optional[str] = None,
+        co_temperature: Optional[float] = None,
+        co_top_p: Optional[float] = None,
+        co_max_tokens: Optional[int] = None,
+        max_validations: int = 2,
+        default: None = None,
+        **kwargs: Unpack[GenerateKwargs],
+    ) -> T | None: ...
+
+    @overload
+    async def aask_covalidate[T](
+        self,
+        question: str,
+        validator: Callable[[str], T | None],
+        co_model: Optional[str] = None,
+        co_temperature: Optional[float] = None,
+        co_top_p: Optional[float] = None,
+        co_max_tokens: Optional[int] = None,
+        max_validations: int = 2,
+        default: T = ...,
+        **kwargs: Unpack[GenerateKwargs],
+    ) -> T: ...
+
+    @overload
+    async def aask_covalidate[T](
+        self,
+        question: List[str],
+        validator: Callable[[str], T | None],
+        co_model: Optional[str] = None,
+        co_temperature: Optional[float] = None,
+        co_top_p: Optional[float] = None,
+        co_max_tokens: Optional[int] = None,
+        max_validations: int = 2,
+        default: None = None,
+        **kwargs: Unpack[GenerateKwargs],
+    ) -> List[T | None]: ...
+
+    @overload
+    async def aask_covalidate[T](
+        self,
+        question: List[str],
+        validator: Callable[[str], T | None],
+        co_model: Optional[str] = None,
+        co_temperature: Optional[float] = None,
+        co_top_p: Optional[float] = None,
+        co_max_tokens: Optional[int] = None,
+        max_validations: int = 2,
+        default: T = ...,
+        **kwargs: Unpack[GenerateKwargs],
+    ) -> List[T]: ...
+
+    async def aask_covalidate[T](
+        self,
+        question: Union[str, List[str]],
+        validator: Callable[[str], T | None],
+        co_model: Optional[str] = None,
+        co_temperature: Optional[float] = None,
+        co_top_p: Optional[float] = None,
+        co_max_tokens: Optional[int] = None,
+        max_validations: int = 2,
+        default: Optional[T] = None,
+        **kwargs: Unpack[GenerateKwargs],
+    ) -> Union[T | None, List[T | None]]:
+        """Ask the LLM with co-validation to obtain a validated response.
+
+        This method attempts to generate a response that passes validation using two approaches:
+        1. First, it asks the primary LLM using the original question
+        2. If validation fails, it uses a secondary (co-) model with a template to improve the response
+        3. The process repeats up to max_validations times
+
+        Args:
+            question: String question or list of questions to ask
+            validator: Function that validates responses, returns result or None if invalid
+            co_model: Optional model name for the co-validator
+            co_temperature: Optional temperature setting for the co-validator
+            co_top_p: Optional top_p setting for the co-validator
+            co_max_tokens: Optional maximum tokens for the co-validator response
+            max_validations: Maximum number of validation attempts
+            default: Default value to return if validation fails
+            **kwargs: Additional keyword arguments passed to aask method
+
+        Returns:
+            The validated result (T) or default if validation fails.
+            If input is a list of questions, returns a list of results.
+        """
+
+        async def validate_single_question(q: str) -> Optional[T]:
+            """Process a single question with validation attempts."""
+            validation_kwargs = kwargs.copy()
+
+            for lap in range(max_validations):
+                try:
+                    # First attempt: direct question to primary model
+                    response = await self.aask(question=q, **validation_kwargs)
+                    if response and (validated := validator(response)):
+                        logger.debug(f"Successfully validated the primary response at {lap}th attempt.")
+                        return validated
+
+                    # Second attempt: use co-model with validation template
+                    co_prompt = TEMPLATE_MANAGER.render_template(
+                        configs.templates.co_validation_template,
+                        {"original_q": q, "original_a": response},
+                    )
+                    co_response = await self.aask(
+                        question=co_prompt,
+                        model=co_model,
+                        temperature=co_temperature,
+                        top_p=co_top_p,
+                        max_tokens=co_max_tokens,
+                    )
+
+                    if co_response and (validated := validator(co_response)):
+                        logger.debug(f"Successfully validated the co-response at {lap}th attempt.")
+                        return validated
+
+                except Exception as e:  # noqa: BLE001
+                    logger.error(f"Error during validation: \n{e}")
+                    break
+
+                # Disable caching for subsequent attempts
+                if not validation_kwargs.get("no_cache"):
+                    validation_kwargs["no_cache"] = True
+                    logger.debug("Disabled cache for the next attempt")
+
+            if default is None:
+                logger.error(f"Failed to validate the response after {max_validations} attempts.")
+            return default
+
+        # Handle single question or list of questions
+        if isinstance(question, str):
+            return await validate_single_question(question)
+
+        # Process multiple questions in parallel
+        return await gather(*[validate_single_question(q) for q in question])

{fabricatio-0.2.6.dev4 → fabricatio-0.2.6.dev5}/python/fabricatio/capabilities/task.py

@@ -84,7 +84,7 @@ class HandleTask(WithBriefing, ToolBoxUsage):
             **self.prepend(cast(Dict[str, Any], kwargs)),
         )
 
-    async def handle_fin_grind(
+    async def handle_fine_grind(
         self,
         task: Task,
         data: Dict[str, Any],
@@ -110,4 +110,4 @@ class HandleTask(WithBriefing, ToolBoxUsage):
 
     async def handle(self, task: Task, data: Dict[str, Any], **kwargs: Unpack[ValidateKwargs]) -> Optional[Tuple]:
         """Asynchronously handles a task based on a given task object and parameters."""
-        return await self.handle_fin_grind(task, data, **kwargs)
+        return await self.handle_fine_grind(task, data, **kwargs)

{fabricatio-0.2.6.dev4 → fabricatio-0.2.6.dev5}/python/fabricatio/config.py

@@ -48,37 +48,37 @@ class LLMConfig(BaseModel):
     """
 
     model_config = ConfigDict(use_attribute_docstrings=True)
-    api_endpoint: HttpUrl = Field(default=HttpUrl("https://api.openai.com"))
+    api_endpoint: Optional[HttpUrl] = Field(default=HttpUrl("https://api.openai.com"))
     """OpenAI API Endpoint."""
 
-    api_key: SecretStr = Field(default=SecretStr(""))
+    api_key: Optional[SecretStr] = Field(default=SecretStr("sk-setyourkey"))
     """OpenAI API key. Empty by default for security reasons, should be set before use."""
 
-    timeout: PositiveInt = Field(default=300)
+    timeout: Optional[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)
+    max_retries: Optional[PositiveInt] = Field(default=3)
     """The maximum number of retries. Default is 3 retries."""
 
-    model: str = Field(default="gpt-3.5-turbo")
+    model: Optional[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)
+    temperature: Optional[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_factory=lambda: ["\n\n\n", "User:"])
+    stop_sign: Optional[str | List[str]] = Field(default="")
     """The stop sign of the LLM model. No default stop sign specified."""
 
-    top_p: NonNegativeFloat = Field(default=0.35)
+    top_p: Optional[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)
+    generation_count: Optional[PositiveInt] = Field(default=1)
     """The number of generations to generate. Default is 1."""
 
-    stream: bool = Field(default=False)
+    stream: Optional[bool] = Field(default=False)
     """Whether to stream the LLM model's response. Default is False."""
 
-    max_tokens: PositiveInt = Field(default=8192)
+    max_tokens: Optional[PositiveInt] = Field(default=8192)
     """The maximum number of tokens to generate. Set to 8192 as per request."""
 
     rpm: Optional[PositiveInt] = Field(default=100)
@@ -93,7 +93,7 @@ class EmbeddingConfig(BaseModel):
 
     model_config = ConfigDict(use_attribute_docstrings=True)
 
-    model: str = Field(default="text-embedding-ada-002")
+    model: Optional[str] = Field(default="text-embedding-ada-002")
     """The embedding model name. """
 
     dimensions: Optional[PositiveInt] = Field(default=None)
@@ -102,10 +102,10 @@ class EmbeddingConfig(BaseModel):
     timeout: Optional[PositiveInt] = Field(default=None)
     """The timeout of the embedding model in seconds."""
 
-    max_sequence_length: PositiveInt = Field(default=8192)
+    max_sequence_length: Optional[PositiveInt] = Field(default=8192)
     """The maximum sequence length of the embedding model. Default is 8192 as per request."""
 
-    caching: bool = Field(default=False)
+    caching: Optional[bool] = Field(default=False)
     """Whether to cache the embedding. Default is False."""
 
     api_endpoint: Optional[HttpUrl] = None
@@ -232,6 +232,9 @@ class TemplateConfig(BaseModel):
     correct_template: str = Field(default="correct")
     """The name of the correct template which will be used to correct a string."""
 
+    co_validation_template: str = Field(default="co_validation")
+    """The name of the co-validation template which will be used to co-validate a string."""
+
 
 class MagikaConfig(BaseModel):
     """Magika configuration class."""
@@ -272,7 +275,7 @@ class RagConfig(BaseModel):
 
     model_config = ConfigDict(use_attribute_docstrings=True)
 
-    milvus_uri: HttpUrl = Field(default=HttpUrl("http://localhost:19530"))
+    milvus_uri: Optional[HttpUrl] = Field(default=HttpUrl("http://localhost:19530"))
     """The URI of the Milvus server."""
     milvus_timeout: Optional[PositiveFloat] = Field(default=None)
     """The timeout of the Milvus server."""

fabricatio-0.2.6.dev5/python/fabricatio/models/action.py

@@ -0,0 +1,219 @@
+"""Module that contains the classes for actions and workflows.
+
+This module defines the Action and WorkFlow classes, which are used for
+creating and executing sequences of actions in a task-based context.
+"""
+
+import traceback
+from abc import abstractmethod
+from asyncio import Queue, create_task
+from typing import Any, Dict, Self, Tuple, Type, Union, final
+
+from fabricatio.capabilities.correct import Correct
+from fabricatio.capabilities.covalidate import CoValidate
+from fabricatio.capabilities.task import HandleTask, ProposeTask
+from fabricatio.journal import logger
+from fabricatio.models.generic import WithBriefing
+from fabricatio.models.task import Task
+from fabricatio.models.usages import ToolBoxUsage
+from pydantic import Field, PrivateAttr
+
+
+class Action(HandleTask, ProposeTask, Correct, CoValidate):
+    """Class that represents an action to be executed in a workflow.
+
+    Actions are the atomic units of work in a workflow. Each action performs
+    a specific operation and can modify the shared context data.
+    """
+
+    name: str = Field(default="")
+    """The name of the action."""
+
+    description: str = Field(default="")
+    """The description of the action."""
+
+    personality: str = Field(default="")
+    """The personality traits or context for the action executor."""
+
+    output_key: str = Field(default="")
+    """The key used to store this action's output in the context dictionary."""
+
+    @final
+    def model_post_init(self, __context: Any) -> None:
+        """Initialize the action by setting default name and description if not provided.
+
+        Args:
+            __context: The context to be used for initialization.
+        """
+        self.name = self.name or self.__class__.__name__
+        self.description = self.description or self.__class__.__doc__ or ""
+
+    @abstractmethod
+    async def _execute(self, **cxt) -> Any:
+        """Execute the action logic with the provided context arguments.
+
+        This method must be implemented by subclasses to define the actual behavior.
+
+        Args:
+            **cxt: The context dictionary containing input and output data.
+
+        Returns:
+            Any: The result of the action execution.
+        """
+        pass
+
+    @final
+    async def act(self, cxt: Dict[str, Any]) -> Dict[str, Any]:
+        """Perform the action and update the context with results.
+
+        Args:
+            cxt: The context dictionary containing input and output data.
+
+        Returns:
+            Dict[str, Any]: The updated context dictionary.
+        """
+        ret = await self._execute(**cxt)
+
+        if self.output_key:
+            logger.debug(f"Setting output: {self.output_key}")
+            cxt[self.output_key] = ret
+
+        return cxt
+
+    @property
+    def briefing(self) -> str:
+        """Return a formatted description of the action including personality context if available.
+
+        Returns:
+            str: Formatted briefing text with personality and action description.
+        """
+        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(WithBriefing, ToolBoxUsage):
+    """Class that represents a sequence of actions to be executed for a task.
+
+    A workflow manages the execution of multiple actions in sequence, passing
+    a shared context between them and handling task lifecycle events.
+    """
+
+    _context: Queue[Dict[str, Any]] = PrivateAttr(default_factory=lambda: Queue(maxsize=1))
+    """Queue for storing the workflow execution context."""
+
+    _instances: Tuple[Action, ...] = PrivateAttr(default_factory=tuple)
+    """Instantiated action objects to be executed in this workflow."""
+
+    steps: Tuple[Union[Type[Action], Action], ...] = Field(...)
+    """The sequence of actions to be executed, can be action classes or instances."""
+
+    task_input_key: str = Field(default="task_input")
+    """Key used to store the input task in the context dictionary."""
+
+    task_output_key: str = Field(default="task_output")
+    """Key used to extract the final result from the context dictionary."""
+
+    extra_init_context: Dict[str, Any] = Field(default_factory=dict, frozen=True)
+    """Additional initial context values to be included at workflow start."""
+
+    def model_post_init(self, __context: Any) -> None:
+        """Initialize the workflow by instantiating any action classes.
+
+        Args:
+            __context: The context to be used for initialization.
+        """
+        # Convert any action classes to instances
+        self._instances = tuple(step if isinstance(step, Action) else step() for step in self.steps)
+
+    def inject_personality(self, personality: str) -> Self:
+        """Set the personality for all actions that don't have one defined.
+
+        Args:
+            personality: The personality text to inject.
+
+        Returns:
+            Self: The workflow instance for method chaining.
+        """
+        for action in filter(lambda a: not a.personality, self._instances):
+            action.personality = personality
+        return self
+
+    async def serve(self, task: Task) -> None:
+        """Execute the workflow to fulfill the given task.
+
+        This method manages the complete lifecycle of processing a task through
+        the workflow's sequence of actions.
+
+        Args:
+            task: The task to be processed.
+        """
+        await task.start()
+        await self._init_context(task)
+
+        current_action = None
+        try:
+            # Process each action in sequence
+            for step in self._instances:
+                current_action = step.name
+                logger.debug(f"Executing step: {current_action}")
+
+                # Get current context and execute action
+                context = await self._context.get()
+                act_task = create_task(step.act(context))
+
+                # Handle task cancellation
+                if task.is_cancelled():
+                    act_task.cancel(f"Cancelled by task: {task.name}")
+                    break
+
+                # Update context with modified values
+                modified_ctx = await act_task
+                await self._context.put(modified_ctx)
+
+            logger.info(f"Finished executing workflow: {self.name}")
+
+            # Get final context and extract result
+            final_ctx = await self._context.get()
+            result = final_ctx.get(self.task_output_key)
+
+            if self.task_output_key not in final_ctx:
+                logger.warning(
+                    f"Task output key: {self.task_output_key} not found in the context, None will be returned. "
+                    f"You can check if `Action.output_key` is set the same as `WorkFlow.task_output_key`."
+                )
+
+            await task.finish(result)
+
+        except RuntimeError as e:
+            logger.error(f"Error during task: {current_action} execution: {e}")
+            logger.error(traceback.format_exc())
+            await task.fail()
+
+    async def _init_context[T](self, task: Task[T]) -> None:
+        """Initialize the context dictionary for workflow execution.
+
+        Args:
+            task: The task being served by this workflow.
+        """
+        logger.debug(f"Initializing context for workflow: {self.name}")
+        initial_context = {self.task_input_key: task, **dict(self.extra_init_context)}
+        await self._context.put(initial_context)
+
+    def steps_fallback_to_self(self) -> Self:
+        """Configure all steps to use this workflow's configuration as fallback.
+
+        Returns:
+            Self: The workflow instance for method chaining.
+        """
+        self.hold_to(self._instances)
+        return self
+
+    def steps_supply_tools_from_self(self) -> Self:
+        """Provide this workflow's tools to all steps in the workflow.
+
+        Returns:
+            Self: The workflow instance for method chaining.
+        """
+        self.provide_tools_to(self._instances)
+        return self

{fabricatio-0.2.6.dev4 → fabricatio-0.2.6.dev5}/python/fabricatio/models/extra.py

@@ -26,7 +26,7 @@ class Figure(Base):
     """The caption accompanying the figure, summarizing its main points and academic value."""
 
     figure_path: str
-    """The file path to the figure"""
+    """The exact path to the figure file, must exist in the file system, SHALL never be a PLACEHOLDER."""
 
 
 class Highlightings(Base):

{fabricatio-0.2.6.dev4 → fabricatio-0.2.6.dev5}/python/fabricatio/models/role.py

@@ -1,8 +1,9 @@
-"""Module that contains the Role class."""
+"""Module that contains the Role class for managing workflows and their event registrations."""
 
 from typing import Any, Self, Set
 
 from fabricatio.capabilities.correct import Correct
+from fabricatio.capabilities.covalidate import CoValidate
 from fabricatio.capabilities.task import HandleTask, ProposeTask
 from fabricatio.core import env
 from fabricatio.journal import logger
@@ -12,20 +13,37 @@ from fabricatio.models.tool import ToolBox
 from pydantic import Field
 
 
-class Role(ProposeTask, HandleTask, Correct):
-    """Class that represents a role with a registry of events and workflows."""
+class Role(ProposeTask, HandleTask, Correct, CoValidate):
+    """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.
+
+    Attributes:
+        registry: Mapping of events to workflows that handle them
+        toolboxes: Set of toolboxes available to this role and its workflows
+    """
 
     registry: dict[Event | str, WorkFlow] = Field(default_factory=dict)
-    """ The registry of events and workflows."""
+    """The registry of events and workflows."""
 
     toolboxes: Set[ToolBox] = Field(default_factory=set)
+    """Collection of tools available to this role."""
 
     def model_post_init(self, __context: Any) -> None:
-        """Register the workflows in the role to the event bus."""
+        """Initialize the role by resolving configurations and registering workflows.
+
+        Args:
+            __context: The context used for initialization
+        """
         self.resolve_configuration().register_workflows()
 
     def register_workflows(self) -> Self:
-        """Register the workflows in the role to the event bus."""
+        """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.instantiate_from(event).collapse()}`"
@@ -34,7 +52,14 @@ class Role(ProposeTask, HandleTask, Correct):
         return self
 
     def resolve_configuration(self) -> Self:
-        """Resolve the configuration of the role."""
+        """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}`")
             (

{fabricatio-0.2.6.dev4 → fabricatio-0.2.6.dev5}/python/fabricatio/models/usages.py

@@ -213,7 +213,7 @@ class LLMUsage(ScopedConfig):
         self,
         question: str,
         validator: Callable[[str], T | None],
-        default: T,
+        default: T = ...,
         max_validations: PositiveInt = 2,
         **kwargs: Unpack[GenerateKwargs],
     ) -> T: ...
@@ -222,7 +222,7 @@ class LLMUsage(ScopedConfig):
         self,
         question: List[str],
         validator: Callable[[str], T | None],
-        default: T,
+        default: T = ...,
         max_validations: PositiveInt = 2,
         **kwargs: Unpack[GenerateKwargs],
     ) -> List[T]: ...
@@ -277,8 +277,9 @@ class LLMUsage(ScopedConfig):
                 except Exception as e:  # noqa: BLE001
                     logger.error(f"Error during validation: \n{e}")
                     break
-                kwargs["no_cache"] = True
-                logger.debug("Closed the cache for the next attempt")
+                if not kwargs.get("no_cache"):
+                    kwargs["no_cache"] = True
+                    logger.debug("Closed the cache for the next attempt")
             if default is None:
                 logger.error(f"Failed to validate the response after {max_validations} attempts.")
             return default

fabricatio-0.2.6.dev5/templates/built-in/co_validation.hbs

@@ -0,0 +1,26 @@
+{{!-- Co-validation template to help improve responses that failed validation --}}
+--- VALIDATION TASK ---
+
+You are an expert validation assistant. Your task is to improve a response that failed to meet validation requirements.
+
+--- ORIGINAL QUESTION ---
+
+{{original_q}}
+
+--- FAILED RESPONSE ---
+
+{{original_a}}
+
+--- INSTRUCTIONS ---
+
+Create a new response that will pass validation by:
+- Following all instructions in the original question precisely
+- Using correct formatting (especially for structured data/JSON/code)
+- Fixing logical errors or inconsistencies from the previous response
+- Ensuring completeness and accuracy
+
+--- IMPORTANT NOTES ---
+- Provide ONLY the improved response, which **MUST** fit the Original question's Validation requirements
+- Do NOT include explanations or commentary
+- Do NOT add headers or prefixes to your response
+

{fabricatio-0.2.6.dev4 → fabricatio-0.2.6.dev5}/uv.lock

@@ -216,7 +216,7 @@ wheels = [
 
 [[package]]
 name = "fabricatio"
-version = "0.2.6.dev4"
+version = "0.2.6.dev5"
 source = { editable = "." }
 dependencies = [
     { name = "appdirs" },