fabricatio 0.2.6.dev3__tar.gz → 0.2.6.dev5__tar.gz

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

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

@@ -4,7 +4,8 @@ import asyncio
 from pathlib import Path
 from typing import List
 
-from fabricatio import ArticleEssence, Event, ExtractArticleEssence, Role, Task, WorkFlow, logger
+from fabricatio import ArticleEssence, Event, Role, Task, WorkFlow, logger
+from fabricatio.actions.article import ExtractArticleEssence
 from fabricatio.fs.curd import dump_text, gather_files
 
 

{fabricatio-0.2.6.dev3 → fabricatio-0.2.6.dev5}/examples/extract_article/extract.py

@@ -3,7 +3,8 @@
 import asyncio
 from typing import List
 
-from fabricatio import ArticleEssence, Event, ExtractArticleEssence, Role, Task, WorkFlow, logger
+from fabricatio import ArticleEssence, Event, Role, Task, WorkFlow, logger
+from fabricatio.actions.article import ExtractArticleEssence
 
 
 async def main() -> None:

{fabricatio-0.2.6.dev3 → 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.dev5/examples/search_bibtex/search.py

@@ -0,0 +1,11 @@
+"""Example of using BibManager."""
+from fabricatio import BibManager, logger
+
+b = BibManager("Exported Items.bib")
+logger.success(
+    b.get_cite_key("A Negative Selection Immune System Inspired Methodology for Fault Diagnosis of Wind Turbines"))
+logger.success(
+    b.get_cite_key_fuzzy(
+        "System Inspired Methodology for Fault"
+    )
+)

fabricatio-0.2.6.dev5/examples/write_outline/write_outline_corrected.py

@@ -0,0 +1,44 @@
+"""Example of using the library."""
+
+import asyncio
+
+from fabricatio import Event, Role, WorkFlow, logger
+from fabricatio.actions.article import CorrectOutline, CorrectProposal, GenerateArticleProposal, GenerateOutline
+from fabricatio.actions.output import DumpFinalizedOutput
+
+
+async def main() -> None:
+    """Main function."""
+    role = Role(
+        name="Undergraduate Researcher",
+        description="Write an outline for an article in typst format.",
+        llm_top_p=0.8,
+        llm_temperature=1.15,
+        registry={
+            Event.quick_instantiate(ns := "article"): WorkFlow(
+                name="Generate Article Outline",
+                description="Generate an outline for an article. dump the outline to the given path. in typst format.",
+                steps=(
+                    GenerateArticleProposal(llm_model="deepseek/deepseek-reasoner", llm_temperature=1.3),
+                    CorrectProposal(
+                        output_key="article_proposal",
+                        llm_model="deepseek/deepseek-reasoner",
+                        llm_temperature=1.3,
+                    ),
+                    GenerateOutline(llm_model="deepseek/deepseek-chat", llm_temperature=1.4, llm_top_p=0.5),
+                    CorrectOutline(output_key="to_dump", llm_temperature=1.4, llm_top_p=0.45),
+                    DumpFinalizedOutput(output_key="task_output"),
+                ),
+            )
+        },
+    )
+
+    proposed_task = await role.propose_task(
+        "You need to read the `./article_briefing.txt` file and write an outline for the article in typst format. The outline should be saved in the `./out.typ` file.",
+    )
+    path = await proposed_task.delegate(ns)
+    logger.success(f"The outline is saved in:\n{path}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

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

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

fabricatio-0.2.6.dev5/python/fabricatio/__init__.py

@@ -0,0 +1,43 @@
+"""Fabricatio is a Python library for building llm app using event-based agent structure."""
+
+from importlib.util import find_spec
+
+from fabricatio import actions, toolboxes, workflows
+from fabricatio._rust import BibManager
+from fabricatio._rust_instances import TEMPLATE_MANAGER
+from fabricatio.core import env
+from fabricatio.journal import logger
+from fabricatio.models import extra
+from fabricatio.models.action import Action, WorkFlow
+from fabricatio.models.events import Event
+from fabricatio.models.role import Role
+from fabricatio.models.task import Task
+from fabricatio.models.tool import ToolBox
+from fabricatio.parser import Capture, GenericCapture, JsonCapture, PythonCapture
+
+__all__ = [
+    "TEMPLATE_MANAGER",
+    "Action",
+    "BibManager",
+    "Capture",
+    "Event",
+    "GenericCapture",
+    "JsonCapture",
+    "PythonCapture",
+    "Role",
+    "Task",
+    "ToolBox",
+    "WorkFlow",
+    "actions",
+    "env",
+    "extra",
+    "logger",
+    "toolboxes",
+    "workflows",
+]
+
+
+if find_spec("pymilvus"):
+    from fabricatio.capabilities.rag import RAG
+
+    __all__ += ["RAG"]

{fabricatio-0.2.6.dev3 → fabricatio-0.2.6.dev5}/python/fabricatio/_rust.pyi

@@ -1,7 +1,6 @@
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
-
 class TemplateManager:
     """Template rendering engine using Handlebars templates.
 

{fabricatio-0.2.6.dev3 → fabricatio-0.2.6.dev5}/python/fabricatio/actions/article.py

@@ -2,13 +2,15 @@
 
 from os import PathLike
 from pathlib import Path
-from typing import Callable, List, Optional
+from typing import Any, Callable, List, Optional
 
 from fabricatio.fs import safe_text_read
 from fabricatio.journal import logger
 from fabricatio.models.action import Action
 from fabricatio.models.extra import ArticleEssence, ArticleOutline, ArticleProposal
 from fabricatio.models.task import Task
+from questionary import confirm, text
+from rich import print as rprint
 
 
 class ExtractArticleEssence(Action):
@@ -66,7 +68,7 @@ class GenerateArticleProposal(Action):
 class GenerateOutline(Action):
     """Generate the article based on the outline."""
 
-    output_key: str = "article"
+    output_key: str = "article_outline"
     """The key of the output data."""
 
     async def _execute(
@@ -79,3 +81,45 @@ class GenerateOutline(Action):
             article_proposal.display(),
             system_message=f"# your personal briefing: \n{self.briefing}",
         )
+
+
+class CorrectProposal(Action):
+    """Correct the proposal of the article."""
+
+    output_key: str = "corrected_proposal"
+
+    async def _execute(self, task_input: Task, article_proposal: ArticleProposal, **_) -> Any:
+        input_path = await self.awhich_pathstr(
+            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()
+            ret = await self.correct_obj(
+                article_proposal,
+                safe_text_read(input_path),
+                topic=topic,
+            )
+        return ret or article_proposal
+
+
+class CorrectOutline(Action):
+    """Correct the outline of the article."""
+
+    output_key: str = "corrected_outline"
+    """The key of the output data."""
+
+    async def _execute(
+        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()
+            ret = await self.correct_obj(article_outline, article_proposal.display(), topic=topic)
+        return ret or article_outline

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.dev3 → 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.dev3 → 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."""