fabricatio 0.2.6__cp39-cp39-win_amd64.whl

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/_rust.pyi

@@ -0,0 +1,115 @@
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+class TemplateManager:
+    """Template rendering engine using Handlebars templates.
+
+    This manager handles template discovery, loading, and rendering
+    through a wrapper around the handlebars-rust engine.
+
+    See: https://crates.io/crates/handlebars
+    """
+
+    def __init__(
+            self, template_dirs: List[Path], suffix: Optional[str] = None, active_loading: Optional[bool] = None
+    ) -> None:
+        """Initialize the template manager.
+
+        Args:
+            template_dirs: List of directories containing template files
+            suffix: File extension for templates (defaults to 'hbs')
+            active_loading: Whether to enable dev mode for reloading templates on change
+        """
+
+    @property
+    def template_count(self) -> int:
+        """Returns the number of currently loaded templates."""
+
+    def get_template_source(self, name: str) -> Optional[str]:
+        """Get the filesystem path for a template.
+
+        Args:
+            name: Template name (without extension)
+
+        Returns:
+            Path to the template file if found, None otherwise
+        """
+
+    def discover_templates(self) -> None:
+        """Scan template directories and load available templates.
+
+        This refreshes the template cache, finding any new or modified templates.
+        """
+
+    def render_template(self, name: str, data: Dict[str, Any]) -> str:
+        """Render a template with context data.
+
+        Args:
+            name: Template name (without extension)
+            data: Context dictionary to provide variables to the template
+
+        Returns:
+            Rendered template content as string
+
+        Raises:
+            RuntimeError: If template rendering fails
+        """
+
+
+def blake3_hash(content: bytes) -> str:
+    """Calculate the BLAKE3 cryptographic hash of data.
+
+    Args:
+        content: Bytes to be hashed
+
+    Returns:
+        Hex-encoded BLAKE3 hash string
+    """
+
+
+class BibManager:
+    """BibTeX bibliography manager for parsing and querying citation data."""
+
+    def __init__(self, path: str) -> None:
+        """Initialize the bibliography manager.
+
+        Args:
+            path: Path to BibTeX (.bib) file to load
+
+        Raises:
+            RuntimeError: If file cannot be read or parsed
+        """
+
+    def get_cite_key(self, title: str) -> Optional[str]:
+        """Find citation key by exact title match.
+
+        Args:
+            title: Full title to search for (case-insensitive)
+
+        Returns:
+            Citation key if exact match found, None otherwise
+        """
+
+    def get_cite_key_fuzzy(self, query: str) -> Optional[str]:
+        """Find best matching citation using fuzzy text search.
+
+        Args:
+            query: Search term to find in bibliography entries
+
+        Returns:
+            Citation key of best matching entry, or None if no good match
+
+        Notes:
+            Uses nucleo_matcher for high-quality fuzzy text searching
+            See: https://crates.io/crates/nucleo-matcher
+        """
+
+    def list_titles(self, is_verbatim: Optional[bool] = False) -> List[str]:
+        """List all titles in the bibliography.
+
+        Args:
+            is_verbatim: Whether to return verbatim titles (without formatting)
+
+        Returns:
+            List of all titles in the bibliography
+        """

fabricatio/_rust_instances.py

@@ -0,0 +1,10 @@
+"""Some necessary instances."""
+
+from fabricatio._rust import TemplateManager
+from fabricatio.config import configs
+
+TEMPLATE_MANAGER = TemplateManager(
+    template_dirs=configs.templates.template_dir,
+    suffix=configs.templates.template_suffix,
+    active_loading=configs.templates.active_loading,
+)

fabricatio/actions/article.py

@@ -0,0 +1,128 @@
+"""Actions for transmitting tasks to targets."""
+
+from os import PathLike
+from pathlib import Path
+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):
+    """Extract the essence of article(s) in text format from the paths specified in the task dependencies.
+
+    Notes:
+        This action is designed to extract vital information from articles with Markdown format, which is pure text, and
+        which is converted from pdf files using `magic-pdf` from the `MinerU` project, see https://github.com/opendatalab/MinerU
+    """
+
+    output_key: str = "article_essence"
+    """The key of the output data."""
+
+    async def _execute[P: PathLike | str](
+        self,
+        task_input: Task,
+        reader: Callable[[P], str] = lambda p: Path(p).read_text(encoding="utf-8"),
+        **_,
+    ) -> Optional[List[ArticleEssence]]:
+        if not task_input.dependencies:
+            logger.info(err := "Task not approved, since no dependencies are provided.")
+            raise RuntimeError(err)
+
+        # trim the references
+        contents = ["References".join(c.split("References")[:-1]) for c in map(reader, task_input.dependencies)]
+        return await self.propose(
+            ArticleEssence,
+            contents,
+            system_message=f"# your personal briefing: \n{self.briefing}",
+        )
+
+
+class GenerateArticleProposal(Action):
+    """Generate an outline for the article based on the extracted essence."""
+
+    output_key: str = "article_proposal"
+    """The key of the output data."""
+
+    async def _execute(
+        self,
+        task_input: Task,
+        **_,
+    ) -> Optional[ArticleProposal]:
+        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."
+        )
+
+        return await self.propose(
+            ArticleProposal,
+            safe_text_read(input_path),
+            system_message=f"# your personal briefing: \n{self.briefing}",
+        )
+
+
+class GenerateOutline(Action):
+    """Generate the article based on the outline."""
+
+    output_key: str = "article_outline"
+    """The key of the output data."""
+
+    async def _execute(
+        self,
+        article_proposal: ArticleProposal,
+        **_,
+    ) -> Optional[ArticleOutline]:
+        return await self.propose(
+            ArticleOutline,
+            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."
+        )
+
+        ret = None
+        while await confirm("Do you want to correct 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),
+                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]:
+        ret = None
+        while await confirm("Do you want to correct 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/actions/output.py

@@ -0,0 +1,19 @@
+"""Dump the finalized output to a file."""
+
+from fabricatio.models.action import Action
+from fabricatio.models.generic import FinalizedDumpAble
+from fabricatio.models.task import Task
+
+
+class DumpFinalizedOutput(Action):
+    """Dump the finalized output to a file."""
+
+    output_key: str = "dump_path"
+
+    async def _execute(self, task_input: Task, to_dump: FinalizedDumpAble, **_) -> str:
+        dump_path = await self.awhich_pathstr(
+            f"{task_input.briefing}\n\nExtract a single path of the file, to which I will dump the data."
+        )
+
+        to_dump.finalized_dump_to(dump_path)
+        return dump_path

fabricatio/actions/rag.py

@@ -0,0 +1,71 @@
+"""Inject data into the database."""
+
+from typing import List, Optional
+
+from fabricatio.capabilities.rag import RAG
+from fabricatio.journal import logger
+from fabricatio.models.action import Action
+from fabricatio.models.generic import PrepareVectorization
+from fabricatio.models.task import Task
+from questionary import text
+
+
+class InjectToDB(Action, RAG):
+    """Inject data into the database."""
+
+    output_key: str = "collection_name"
+
+    async def _execute[T: PrepareVectorization](
+        self, to_inject: Optional[T] | List[Optional[T]], collection_name: Optional[str] = "my_collection", **_
+    ) -> Optional[str]:
+        if not isinstance(to_inject, list):
+            to_inject = [to_inject]
+        logger.info(f"Injecting {len(to_inject)} items into the collection '{collection_name}'")
+        await self.view(collection_name, create=True).consume_string(
+            [
+                t.prepare_vectorization(self.embedding_max_sequence_length)
+                for t in to_inject
+                if isinstance(t, PrepareVectorization)
+            ],
+        )
+
+        return collection_name
+
+
+class RAGTalk(Action, RAG):
+    """RAG-enabled conversational action that processes user questions based on a given task.
+
+    This action establishes an interactive conversation loop where it retrieves context-relevant
+    information to answer user queries according to the assigned task briefing.
+
+    Notes:
+        task_input: Task briefing that guides how to respond to user questions
+        collection_name: Name of the vector collection to use for retrieval (default: "my_collection")
+
+    Returns:
+        Number of conversation turns completed before termination
+    """
+
+    output_key: str = "task_output"
+
+    async def _execute(self, task_input: Task[str], **kwargs) -> int:
+        collection_name = kwargs.get("collection_name", "my_collection")
+        counter = 0
+
+        self.view(collection_name, create=True)
+
+        try:
+            while True:
+                user_say = await text("User: ").ask_async()
+                if user_say is None:
+                    break
+                gpt_say = await self.aask_retrieved(
+                    user_say,
+                    user_say,
+                    extra_system_message=f"You have to answer to user obeying task assigned to you:\n{task_input.briefing}",
+                )
+                print(f"GPT: {gpt_say}")  # noqa: T201
+                counter += 1
+        except KeyboardInterrupt:
+            logger.info(f"executed talk action {counter} times")
+        return counter

fabricatio/capabilities/correct.py

@@ -0,0 +1,115 @@
+"""Correct capability module providing advanced review and validation functionality.
+
+This module implements the Correct capability, which extends the Review functionality
+to provide mechanisms for reviewing, validating, and correcting various objects and tasks
+based on predefined criteria and templates.
+"""
+
+from typing import Optional, Unpack, cast
+
+from fabricatio._rust_instances import TEMPLATE_MANAGER
+from fabricatio.capabilities.review import Review, ReviewResult
+from fabricatio.config import configs
+from fabricatio.models.generic import Display, ProposedAble, WithBriefing
+from fabricatio.models.kwargs_types import CorrectKwargs, ReviewKwargs
+from fabricatio.models.task import Task
+
+
+class Correct(Review):
+    """Correct capability for reviewing, validating, and improving objects.
+
+    This class enhances the Review capability with specialized functionality for
+    correcting and improving objects based on review feedback. It can process
+    various inputs including tasks, strings, and generic objects that implement
+    the required interfaces, applying corrections based on templated review processes.
+    """
+
+    async def correct_obj[M: ProposedAble](
+        self,
+        obj: M,
+        reference: str = "",
+        supervisor_check: bool = True,
+        **kwargs: Unpack[ReviewKwargs[ReviewResult[str]]],
+    ) -> Optional[M]:
+        """Review and correct an object based on defined criteria and templates.
+
+        This method first conducts a review of the given object, then uses the review results
+        to generate a corrected version of the object using appropriate templates.
+
+        Args:
+            obj (M): The object to be reviewed and corrected. Must implement ProposedAble.
+            reference (str): A reference or contextual information for the object.
+            supervisor_check (bool, optional): Whether to perform a supervisor check on the review results. Defaults to True.
+            **kwargs: Review configuration parameters including criteria and review options.
+
+        Returns:
+            Optional[M]: A corrected version of the input object, or None if correction fails.
+
+        Raises:
+            TypeError: If the provided object doesn't implement Display or WithBriefing interfaces.
+        """
+        if not isinstance(obj, (Display, WithBriefing)):
+            raise TypeError(f"Expected Display or WithBriefing, got {type(obj)}")
+
+        review_res = await self.review_obj(obj, **kwargs)
+        if supervisor_check:
+            await review_res.supervisor_check()
+        if "default" in kwargs:
+            cast(ReviewKwargs[None], kwargs)["default"] = None
+        return await self.propose(
+            obj.__class__,
+            TEMPLATE_MANAGER.render_template(
+                configs.templates.correct_template,
+                {
+                    "content": f"{(reference + '\n\nAbove is referencing material') if reference else ''}{obj.display() if isinstance(obj, Display) else obj.briefing}",
+                    "review": review_res.display(),
+                },
+            ),
+            **kwargs,
+        )
+
+    async def correct_string(
+        self, input_text: str, supervisor_check: bool = True, **kwargs: Unpack[ReviewKwargs[ReviewResult[str]]]
+    ) -> Optional[str]:
+        """Review and correct a string based on defined criteria and templates.
+
+        This method applies the review process to the input text and generates
+        a corrected version based on the review results.
+
+        Args:
+            input_text (str): The text content to be reviewed and corrected.
+            supervisor_check (bool, optional): Whether to perform a supervisor check on the review results. Defaults to True.
+            **kwargs: Review configuration parameters including criteria and review options.
+
+        Returns:
+            Optional[str]: The corrected text content, or None if correction fails.
+        """
+        review_res = await self.review_string(input_text, **kwargs)
+        if supervisor_check:
+            await review_res.supervisor_check()
+
+        if "default" in kwargs:
+            cast(ReviewKwargs[None], kwargs)["default"] = None
+        return await self.ageneric_string(
+            TEMPLATE_MANAGER.render_template(
+                configs.templates.correct_template, {"content": input_text, "review": review_res.display()}
+            ),
+            **kwargs,
+        )
+
+    async def correct_task[T](
+        self, task: Task[T], **kwargs: Unpack[CorrectKwargs[ReviewResult[str]]]
+    ) -> Optional[Task[T]]:
+        """Review and correct a task object based on defined criteria.
+
+        This is a specialized version of correct_obj specifically for Task objects,
+        applying the same review and correction process to task definitions.
+
+        Args:
+            task (Task[T]): The task to be reviewed and corrected.
+            **kwargs: Review configuration parameters including criteria and review options.
+
+        Returns:
+            Optional[Task[T]]: The corrected task, or None if correction fails.
+        """
+        return await self.correct_obj(task, **kwargs)

fabricatio/capabilities/propose.py

@@ -0,0 +1,49 @@
+"""A module for the task capabilities of the Fabricatio library."""
+
+from typing import List, Optional, Type, Unpack, overload
+
+from fabricatio.models.generic import ProposedAble
+from fabricatio.models.kwargs_types import ValidateKwargs
+from fabricatio.models.usages import LLMUsage
+
+
+class Propose(LLMUsage):
+    """A class that proposes an Obj based on a prompt."""
+
+    @overload
+    async def propose[M: ProposedAble](
+        self,
+        cls: Type[M],
+        prompt: List[str],
+        **kwargs: Unpack[ValidateKwargs[M]],
+    ) -> Optional[List[M]]: ...
+
+    @overload
+    async def propose[M: ProposedAble](
+        self,
+        cls: Type[M],
+        prompt: str,
+        **kwargs: Unpack[ValidateKwargs[M]],
+    ) -> Optional[M]: ...
+
+    async def propose[M: ProposedAble](
+        self,
+        cls: Type[M],
+        prompt: List[str] | str,
+        **kwargs: Unpack[ValidateKwargs[M]],
+    ) -> Optional[List[M] | M]:
+        """Asynchronously proposes a task based on a given prompt and parameters.
+
+        Parameters:
+            cls: The class type of the task to be proposed.
+            prompt: The prompt text for proposing a task, which is a string that must be provided.
+            **kwargs: The keyword arguments for the LLM (Large Language Model) usage.
+
+        Returns:
+            A Task object based on the proposal result.
+        """
+        return await self.aask_validate(
+            question=cls.create_json_prompt(prompt),
+            validator=cls.instantiate_from_string,
+            **kwargs,
+        )