fabricatio 0.2.6.dev4__cp312-cp312-manylinux_2_34_x86_64.whl → 0.2.6.dev6__cp312-cp312-manylinux_2_34_x86_64.whl

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/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/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/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/models/action.py

@@ -1,4 +1,8 @@
-"""Module that contains the classes for actions and workflows."""
+"""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
@@ -15,20 +19,27 @@ from pydantic import Field, PrivateAttr
 
 
 class Action(HandleTask, ProposeTask, Correct):
-    """Class that represents an action to be executed in a workflow."""
+    """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 of whom the action belongs to."""
+    """The personality traits or context for the action executor."""
+
     output_key: str = Field(default="")
-    """The key of the output data."""
+    """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 the name if not provided.
+        """Initialize the action by setting default name and description if not provided.
 
         Args:
             __context: The context to be used for initialization.
@@ -38,121 +49,170 @@ class Action(HandleTask, ProposeTask, Correct):
 
     @abstractmethod
     async def _execute(self, **cxt) -> Any:
-        """Execute the action with the provided arguments.
+        """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:
-            The result of the action execution.
+            Any: The result of the action execution.
         """
         pass
 
     @final
     async def act(self, cxt: Dict[str, Any]) -> Dict[str, Any]:
-        """Perform the action by executing it and setting the output data.
+        """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 brief description of the action."""
+        """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 workflow to be executed in a task."""
+    """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))
-    """ The context dictionary to be used for workflow execution."""
+    """Queue for storing the workflow execution context."""
 
     _instances: Tuple[Action, ...] = PrivateAttr(default_factory=tuple)
-    """ The instances of the workflow steps."""
+    """Instantiated action objects to be executed in this workflow."""
 
     steps: Tuple[Union[Type[Action], Action], ...] = Field(...)
-    """ The steps to be executed in the workflow, actions or action classes."""
+    """The sequence of actions to be executed, can be action classes or instances."""
+
     task_input_key: str = Field(default="task_input")
-    """ The key of the task input data."""
+    """Key used to store the input task in the context dictionary."""
+
     task_output_key: str = Field(default="task_output")
-    """ The key of the task output data."""
+    """Key used to extract the final result from the context dictionary."""
+
     extra_init_context: Dict[str, Any] = Field(default_factory=dict, frozen=True)
-    """ The extra context dictionary to be used for workflow initialization."""
+    """Additional initial context values to be included at workflow start."""
 
     def model_post_init(self, __context: Any) -> None:
-        """Initialize the workflow by setting fallbacks for each step.
+        """Initialize the workflow by instantiating any action classes.
 
         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)
+        # 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:
-        """Inject the personality of the workflow.
+        """Set the personality for all actions that don't have one defined.
 
         Args:
-            personality: The personality to be injected.
+            personality: The personality text to inject.
 
         Returns:
-            Self: The instance of the workflow with the injected personality.
+            Self: The workflow instance for method chaining.
         """
-        for a in filter(lambda action: not action.personality, self._instances):
-            a.personality = personality
+        for action in filter(lambda a: not a.personality, self._instances):
+            action.personality = personality
         return self
 
     async def serve(self, task: Task) -> None:
-        """Serve the task by executing the workflow steps.
+        """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 served.
+            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:
-                logger.debug(f"Executing step: {(current_action := step.name)}")
-                act_task = create_task(step.act(await self._context.get()))
+                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}")
 
-            if self.task_output_key not in (final_ctx := await self._context.get()):
+            # 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. You can check if `Action.output_key` is set the same as `WorkFlow.task_output_key`."
+                    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(final_ctx.get(self.task_output_key, None))
+            await task.finish(result)
+
         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
+            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."""
+        """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}")
-        await self._context.put({self.task_input_key: task, **dict(self.extra_init_context)})
+        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:
-        """Set the fallback for each step to the workflow itself."""
+        """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:
-        """Supply the tools from the workflow to each step."""
+        """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