fabricatio 0.2.6.dev4__tar.gz → 0.2.6.dev6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.6.dev4
+Version: 0.2.6.dev6
 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.dev6}/examples/extract_and_review/extract_and_review.py

@@ -2,12 +2,15 @@
 
 import asyncio
 from pathlib import Path
-from typing import List
+from typing import TYPE_CHECKING, List
 
-from fabricatio import ArticleEssence, Event, Role, Task, WorkFlow, logger
+from fabricatio import Event, Role, Task, WorkFlow, logger
 from fabricatio.actions.article import ExtractArticleEssence
 from fabricatio.fs.curd import dump_text, gather_files
 
+if TYPE_CHECKING:
+    from fabricatio.models.extra import ArticleEssence
+
 
 async def main() -> None:
     """Main function."""

{fabricatio-0.2.6.dev4 → fabricatio-0.2.6.dev6}/examples/extract_article/extract.py

@@ -1,11 +1,14 @@
 """Example of proposing a task to a role."""
 
 import asyncio
-from typing import List
+from typing import TYPE_CHECKING, List
 
-from fabricatio import ArticleEssence, Event, Role, Task, WorkFlow, logger
+from fabricatio import Event, Role, Task, WorkFlow, logger
 from fabricatio.actions.article import ExtractArticleEssence
 
+if TYPE_CHECKING:
+    from fabricatio.models.extra import ArticleEssence
+
 
 async def main() -> None:
     """Main function."""

{fabricatio-0.2.6.dev4 → fabricatio-0.2.6.dev6}/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.dev6}/pyproject.toml

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

{fabricatio-0.2.6.dev4 → fabricatio-0.2.6.dev6}/python/fabricatio/actions/article.py

@@ -93,10 +93,11 @@ class CorrectProposal(Action):
             f"{task_input.briefing}\nExtract the path of file, which contains the article briefing that I need to read."
         )
 
-        rprint(article_proposal.display())
         ret = None
         while await confirm("Do you want to correct the Proposal?").ask_async():
-            topic = await text("What is the topic of the proposal?").ask_async()
+            rprint(article_proposal.display())
+            while not (topic := await text("What is the topic of the proposal reviewing?").ask_async()):
+                ...
             ret = await self.correct_obj(
                 article_proposal,
                 safe_text_read(input_path),
@@ -115,11 +116,13 @@ class CorrectOutline(Action):
         self,
         article_outline: ArticleOutline,
         article_proposal: ArticleProposal,
+
         **_,
     ) -> Optional[str]:
-        rprint(article_outline.finalized_dump())
         ret = None
         while await confirm("Do you want to correct the outline?").ask_async():
-            topic = await text("What is the topic of the outline?").ask_async()
+            rprint(article_outline.finalized_dump())
+            while not (topic := await text("What is the topic of the outline reviewing?").ask_async()):
+                ...
             ret = await self.correct_obj(article_outline, article_proposal.display(), topic=topic)
         return ret or article_outline

{fabricatio-0.2.6.dev4 → fabricatio-0.2.6.dev6}/python/fabricatio/capabilities/rag.py

@@ -21,7 +21,7 @@ from fabricatio.models.kwargs_types import (
     LLMKwargs,
 )
 from fabricatio.models.usages import EmbeddingUsage
-from fabricatio.models.utils import MilvusData
+from fabricatio.models.utils import MilvusData, ok
 from more_itertools.recipes import flatten, unique
 from pydantic import Field, PrivateAttr
 
@@ -60,7 +60,7 @@ class RAG(EmbeddingUsage):
     ) -> Self:
         """Initialize the Milvus client."""
         self._client = create_client(
-            uri=milvus_uri or (self.milvus_uri or configs.rag.milvus_uri).unicode_string(),
+            uri=milvus_uri or ok(self.milvus_uri or configs.rag.milvus_uri).unicode_string(),
             token=milvus_token
             or (token.get_secret_value() if (token := (self.milvus_token or configs.rag.milvus_token)) else ""),
             timeout=milvus_timeout or self.milvus_timeout,
@@ -315,7 +315,7 @@ class RAG(EmbeddingUsage):
             **kwargs,
         )
 
-    async def arefined_query(self, question: List[str] | str, **kwargs: Unpack[ChooseKwargs]) -> List[str]:
+    async def arefined_query(self, question: List[str] | str, **kwargs: Unpack[ChooseKwargs]) -> Optional[List[str]]:
         """Refines the given question using a template.
 
         Args:

{fabricatio-0.2.6.dev4 → fabricatio-0.2.6.dev6}/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.dev6}/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=None)
     """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=None)
     """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
@@ -148,13 +148,13 @@ class DebugConfig(BaseModel):
     log_level: Literal["DEBUG", "INFO", "SUCCESS", "WARNING", "ERROR", "CRITICAL"] = Field(default="INFO")
     """The log level of the application."""
 
-    log_file: FilePath = Field(default=Path(rf"{ROAMING_DIR}\fabricatio.log"))
+    log_file: FilePath = Field(default=Path(rf"{ROAMING_DIR}\fabricatio.log"), frozen=True)
     """The log file of the application."""
 
-    rotation: int = Field(default=1)
+    rotation: int = Field(default=1, frozen=True)
     """The rotation of the log file. in weeks."""
 
-    retention: int = Field(default=2)
+    retention: int = Field(default=2, frozen=True)
     """The retention of the log file. in weeks."""
 
     streaming_visible: bool = Field(default=False)
@@ -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.dev6/python/fabricatio/models/action.py

@@ -0,0 +1,218 @@
+"""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.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):
+    """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