fabricatio 0.2.7.dev0__tar.gz → 0.2.7.dev2__tar.gz

{fabricatio-0.2.7.dev0 → fabricatio-0.2.7.dev2}/.gitignore

@@ -165,3 +165,4 @@ cython_debug/
 
 extra/scripts/*
 output/
+.vscode/

fabricatio-0.2.7.dev2/Makefile

@@ -0,0 +1,27 @@
+DIST:=dist
+DATA:=extra
+PY:=3.12
+
+
+all:bdist
+
+tools:
+	cargo build --all --bins -Z unstable-options --artifact-dir $(DATA)/scripts --release
+	mkdir -p $(DATA)/scripts
+	rm $(DATA)/scripts/*.pdb || true
+	rm $(DATA)/scripts/*.dwarf || true
+
+dev: tools
+	uvx -p $(PY) --project . maturin develop --uv -r
+
+bdist:clean tools
+	uvx -p $(PY) --project . maturin sdist -o $(DIST)
+	uvx -p $(PY) --project . maturin build  -r -o $(DIST)
+
+clean:
+	rm -rf $(DIST) $(DATA)
+
+publish:tools
+	uvx -p $(PY) --project . maturin publish --skip-existing
+	uvx -p $(PY) --project . maturin upload --skip-existing $(DIST)/*
+.PHONY: tools dev bdist clean publish

{fabricatio-0.2.7.dev0 → fabricatio-0.2.7.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.7.dev0
+Version: 0.2.7.dev2
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12
@@ -24,9 +24,13 @@ Requires-Dist: questionary>=2.1.0
 Requires-Dist: regex>=2024.11.6
 Requires-Dist: rich>=13.9.4
 Requires-Dist: pymilvus>=2.5.4 ; extra == 'rag'
-Requires-Dist: fabricatio[rag] ; extra == 'full'
+Requires-Dist: fabricatio[calc,plot,rag] ; extra == 'full'
+Requires-Dist: sympy>=1.13.3 ; extra == 'calc'
+Requires-Dist: matplotlib>=3.10.1 ; extra == 'plot'
 Provides-Extra: rag
 Provides-Extra: full
+Provides-Extra: calc
+Provides-Extra: plot
 License-File: LICENSE
 Summary: A LLM multi-agent framework.
 Keywords: ai,agents,multi-agent,llm,pyo3

fabricatio-0.2.7.dev2/examples/extract_and_inject/ask.py

@@ -0,0 +1,59 @@
+"""Simple chat example."""
+
+import asyncio
+
+from fabricatio import RAG, Action, Role, Task, WorkFlow, logger
+from fabricatio.models.events import Event
+from fabricatio.models.utils import ok
+from questionary import text
+
+
+class Talk(Action, RAG):
+    """Action that says hello to the world."""
+
+    output_key: str = "task_output"
+
+    async def _execute(self, task_input: Task[str], **_) -> int:
+        counter = 0
+
+        self.init_client()
+
+        try:
+            while True:
+                user_say = await text("User: ").ask_async()
+                if user_say is None:
+                    break
+                gpt_say = await self.aask_refined(
+                    user_say,
+                    "article_essence_max",
+                    extra_system_message=f"You have to answer to user obeying task assigned to you:\n{task_input.briefing}\nYou should explicitly say write a label if you draw a conclusion from the references, the label shall contain names.",
+                    result_per_query=16,
+                    final_limit=40,
+                    similarity_threshold=0.31,
+                )
+                print(f"GPT: {gpt_say}")  # noqa: T201
+                counter += 1
+        except KeyboardInterrupt:
+            logger.info(f"executed talk action {counter} times")
+        return counter
+
+
+async def main() -> None:
+    """Main function."""
+    role = Role(
+        name="talker",
+        description="talker role but with rag",
+        registry={Event.instantiate_from("talk").push_wildcard().push("pending"): WorkFlow(name="talk", steps=(Talk,))},
+    )
+
+    task = ok(
+        await role.propose_task(
+            "you have to act as a helpful assistant, answer to all user questions properly and patiently"
+        ),
+        "Failed to propose task",
+    )
+    _ = await task.delegate("talk")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

{fabricatio-0.2.7.dev0 → fabricatio-0.2.7.dev2}/examples/extract_and_inject/extract_and_inject.py

@@ -4,14 +4,13 @@ import asyncio
 from pathlib import Path
 from typing import List, Optional
 
-from pydantic import HttpUrl
-
 from fabricatio import Action, Event, Role, Task, WorkFlow, logger
 from fabricatio.actions.article import ExtractArticleEssence
 from fabricatio.actions.rag import InjectToDB
 from fabricatio.fs.curd import dump_text, gather_files
 from fabricatio.models.extra import ArticleEssence
 from fabricatio.models.utils import ok
+from pydantic import HttpUrl
 
 
 class SaveToFS(Action):

fabricatio-0.2.7.dev2/examples/write_article/write_article.py

@@ -0,0 +1,46 @@
+"""Example of using the library."""
+
+import asyncio
+from pathlib import Path
+
+from fabricatio import Event, Role, WorkFlow, logger
+from fabricatio.actions.article import (
+    GenerateArticle,
+    GenerateArticleProposal,
+    GenerateOutline,
+)
+from fabricatio.actions.output import DumpFinalizedOutput
+from fabricatio.models.task import Task
+
+
+async def main() -> None:
+    """Main function."""
+    Role(
+        name="Undergraduate Researcher",
+        description="Write an outline for an article in typst format.",
+        llm_top_p=0.8,
+        llm_temperature=1.15,
+        llm_max_tokens=8192,
+        llm_model="openai/qwen-max",
+        llm_stream=True,
+        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_temperature=1.18),
+                    GenerateOutline(llm_temperature=1.21, llm_top_p=0.3),
+                    GenerateArticle(output_key="to_dump", llm_temperature=1.2, llm_top_p=0.45),
+                    DumpFinalizedOutput(output_key="task_output"),
+                ),
+            ).update_init_context(article_briefing=Path("./article_briefing.txt").read_text(), dump_path="out.typ")
+        },
+    )
+
+    proposed_task = Task(name="write an article")
+    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.7.dev2/examples/write_outline/.gitignore

@@ -0,0 +1,2 @@
+article_briefing.txt
+out.typ

{fabricatio-0.2.7.dev0 → fabricatio-0.2.7.dev2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fabricatio"
-version = "0.2.7-dev0"
+version = "0.2.7-dev2"
 description = "A LLM multi-agent framework."
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -81,7 +81,13 @@ rag = [
 ]
 
 full = [
-    "fabricatio[rag]",
+    "fabricatio[calc,plot,rag]",
+]
+calc = [
+    "sympy>=1.13.3",
+]
+plot = [
+    "matplotlib>=3.10.1",
 ]
 
 [tool.ruff]
@@ -140,6 +146,9 @@ testpaths = [
 asyncio_mode = "auto"
 asyncio_default_fixture_loop_scope = "function"
 
+[tool.uv.sources]
+fabricatio = { workspace = true }
+
 [[tool.uv.index]]
 url = "https://mirrors.bfsu.edu.cn/pypi/web/simple"
 default = true

{fabricatio-0.2.7.dev0 → fabricatio-0.2.7.dev2}/python/fabricatio/_rust.pyi

@@ -11,7 +11,7 @@ class TemplateManager:
     """
 
     def __init__(
-            self, template_dirs: List[Path], suffix: Optional[str] = None, active_loading: Optional[bool] = None
+        self, template_dirs: List[Path], suffix: Optional[str] = None, active_loading: Optional[bool] = None
     ) -> None:
         """Initialize the template manager.
 
@@ -55,6 +55,16 @@ class TemplateManager:
             RuntimeError: If template rendering fails
         """
 
+    def render_template_raw(self, template: str, data: Dict[str, Any]) -> str:
+        """Render a template with context data.
+
+        Args:
+            template: The template string
+            data: Context dictionary to provide variables to the template
+
+        Returns:
+            Rendered template content as string
+        """
 
 def blake3_hash(content: bytes) -> str:
     """Calculate the BLAKE3 cryptographic hash of data.
@@ -66,7 +76,6 @@ def blake3_hash(content: bytes) -> str:
         Hex-encoded BLAKE3 hash string
     """
 
-
 class BibManager:
     """BibTeX bibliography manager for parsing and querying citation data."""
 

fabricatio-0.2.7.dev2/python/fabricatio/actions/article.py

@@ -0,0 +1,209 @@
+"""Actions for transmitting tasks to targets."""
+
+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 Article, ArticleEssence, ArticleOutline, ArticleProposal
+from fabricatio.models.task import Task
+from fabricatio.models.utils import ok
+
+
+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(
+        self,
+        task_input: Task,
+        reader: Callable[[str], 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: Optional[Task] = None,
+        article_briefing: Optional[str] = None,
+        article_briefing_path: Optional[str] = None,
+        **_,
+    ) -> Optional[ArticleProposal]:
+        if article_briefing is None and article_briefing_path is None and task_input is None:
+            logger.error("Task not approved, since all inputs are None.")
+            return None
+
+        return (
+            await self.propose(
+                ArticleProposal,
+                briefing := (
+                    article_briefing
+                    or safe_text_read(
+                        ok(
+                            article_briefing_path
+                            or await self.awhich_pathstr(
+                                f"{task_input.briefing}\nExtract the path of file which contains the article briefing."
+                            ),
+                            "Could not find the path of file to read.",
+                        )
+                    )
+                ),
+                **self.prepend_sys_msg(),
+            )
+        ).update_ref(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]:
+        out = await self.propose(
+            ArticleOutline,
+            article_proposal.as_prompt(),
+            **self.prepend_sys_msg(),
+        )
+
+        manual = await self.draft_rating_manual(
+            topic=(
+                topic
+                := "Fix the internal referring error, make sure there is no more `ArticleRef` pointing to a non-existing article component."
+            ),
+        )
+        while err := out.resolve_ref_error():
+            logger.warning(f"Found error in the outline: \n{err}")
+            out = await self.correct_obj(
+                out,
+                reference=f"# Referring Error\n{err}",
+                topic=topic,
+                rating_manual=manual,
+                supervisor_check=False,
+            )
+        return out.update_ref(article_proposal)
+
+
+class CorrectProposal(Action):
+    """Correct the proposal of the article."""
+
+    output_key: str = "corrected_proposal"
+
+    async def _execute(self, article_proposal: ArticleProposal, **_) -> Any:
+        return (await self.censor_obj(article_proposal, reference=article_proposal.referenced)).update_ref(
+            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,
+        **_,
+    ) -> ArticleOutline:
+        return (await self.censor_obj(article_outline, reference=article_outline.referenced.as_prompt())).update_ref(
+            article_outline
+        )
+
+
+class GenerateArticle(Action):
+    """Generate the article based on the outline."""
+
+    output_key: str = "article"
+    """The key of the output data."""
+
+    async def _execute(
+        self,
+        article_outline: ArticleOutline,
+        **_,
+    ) -> Optional[Article]:
+        article: Article = Article.from_outline(article_outline).update_ref(article_outline)
+
+        writing_manual = await self.draft_rating_manual(
+            topic=(
+                topic_1
+                := "improve the content of the subsection to fit the outline. SHALL never add or remove any section or subsection, you can only add or delete paragraphs within the subsection."
+            ),
+        )
+        err_resolve_manual = await self.draft_rating_manual(
+            topic=(topic_2 := "this article component has violated the constrain, please correct it.")
+        )
+        for c, deps in article.iter_dfs_with_deps(chapter=False):
+            logger.info(f"Updating the article component: \n{c.display()}")
+
+            out = ok(
+                await self.correct_obj(
+                    c,
+                    reference=(
+                        ref := f"{article_outline.referenced.as_prompt()}\n" + "\n".join(d.display() for d in deps)
+                    ),
+                    topic=topic_1,
+                    rating_manual=writing_manual,
+                    supervisor_check=False,
+                ),
+                "Could not correct the article component.",
+            )
+            while err := c.resolve_update_error(out):
+                logger.warning(f"Found error in the article component: \n{err}")
+                out = ok(
+                    await self.correct_obj(
+                        out,
+                        reference=f"{ref}\n\n# Violated Error\n{err}",
+                        topic=topic_2,
+                        rating_manual=err_resolve_manual,
+                        supervisor_check=False,
+                    ),
+                    "Could not correct the article component.",
+                )
+
+            c.update_from(out)
+        return article
+
+
+class CorrectArticle(Action):
+    """Correct the article based on the outline."""
+
+    output_key: str = "corrected_article"
+    """The key of the output data."""
+
+    async def _execute(
+        self,
+        article: Article,
+        article_outline: ArticleOutline,
+        **_,
+    ) -> Article:
+        return await self.censor_obj(article, reference=article_outline.referenced.as_prompt())

fabricatio-0.2.7.dev2/python/fabricatio/actions/output.py

@@ -0,0 +1,34 @@
+"""Dump the finalized output to a file."""
+
+from pathlib import Path
+from typing import Optional
+
+from fabricatio.models.action import Action
+from fabricatio.models.generic import FinalizedDumpAble
+from fabricatio.models.task import Task
+from fabricatio.models.utils import ok
+
+
+class DumpFinalizedOutput(Action):
+    """Dump the finalized output to a file."""
+
+    output_key: str = "dump_path"
+
+    async def _execute(
+        self,
+        to_dump: FinalizedDumpAble,
+        task_input: Optional[Task] = None,
+        dump_path: Optional[str | Path] = None,
+        **_,
+    ) -> str:
+        dump_path = Path(
+            dump_path
+            or ok(
+                await self.awhich_pathstr(
+                    f"{ok(task_input, 'Neither `task_input` and `dump_path` is provided.').briefing}\n\nExtract a single path of the file, to which I will dump the data."
+                ),
+                "Could not find the path of file to dump the data.",
+            )
+        )
+        ok(to_dump, "Could not dump the data since the path is not specified.").finalized_dump_to(dump_path)
+        return dump_path.as_posix()

{fabricatio-0.2.7.dev0 → fabricatio-0.2.7.dev2}/python/fabricatio/capabilities/correct.py

@@ -10,9 +10,11 @@ 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.generic import CensoredAble, Display, ProposedAble, WithBriefing
+from fabricatio.models.kwargs_types import CensoredCorrectKwargs, CorrectKwargs, ReviewKwargs
 from fabricatio.models.task import Task
+from questionary import confirm, text
+from rich import print as rprint
 
 
 class Correct(Review):
@@ -55,7 +57,7 @@ class Correct(Review):
         if supervisor_check:
             await review_res.supervisor_check()
         if "default" in kwargs:
-            cast('ReviewKwargs[None]', kwargs)["default"] = None
+            cast("ReviewKwargs[None]", kwargs)["default"] = None
         return await self.propose(
             obj.__class__,
             TEMPLATE_MANAGER.render_template(
@@ -89,7 +91,7 @@ class Correct(Review):
             await review_res.supervisor_check()
 
         if "default" in kwargs:
-            cast('ReviewKwargs[None]', kwargs)["default"] = None
+            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()}
@@ -113,3 +115,31 @@ class Correct(Review):
             Optional[Task[T]]: The corrected task, or None if correction fails.
         """
         return await self.correct_obj(task, **kwargs)
+
+    async def censor_obj[M: CensoredAble](
+        self, obj: M, **kwargs: Unpack[CensoredCorrectKwargs[ReviewResult[str]]]
+    ) -> M:
+        """Censor and correct an object based on defined criteria and templates.
+
+        Args:
+            obj (M): The object to be reviewed and corrected.
+            **kwargs (Unpack[CensoredCorrectKwargs]): Additional keyword
+
+        Returns:
+            M: The censored and corrected object.
+        """
+        last_modified_obj = obj
+        modified_obj = None
+        rprint(obj.finalized_dump())
+        while await confirm("Begin to correct obj above with human censorship?").ask_async():
+            while (topic := await text("What is the topic of the obj reviewing?").ask_async()) is not None and topic:
+                ...
+            if (modified_obj := await self.correct_obj(
+                last_modified_obj,
+                topic=topic,
+                **kwargs,
+            )) is None:
+                break
+            last_modified_obj = modified_obj
+            rprint(last_modified_obj.finalized_dump())
+        return modified_obj or last_modified_obj

{fabricatio-0.2.7.dev0 → fabricatio-0.2.7.dev2}/python/fabricatio/capabilities/rag.py

@@ -19,6 +19,7 @@ from fabricatio.models.kwargs_types import (
     EmbeddingKwargs,
     FetchKwargs,
     LLMKwargs,
+    RetrievalKwargs,
 )
 from fabricatio.models.usages import EmbeddingUsage
 from fabricatio.models.utils import MilvusData, ok
@@ -213,6 +214,25 @@ class RAG(EmbeddingUsage):
         self.add_document(await self.pack(text), collection_name or self.safe_target_collection, flush=True)
         return self
 
+    @overload
+    async def afetch_document[V: (int, str, float, bytes)](
+        self,
+        vecs: List[List[float]],
+        desired_fields: List[str],
+        collection_name: Optional[str] = None,
+        similarity_threshold: float = 0.37,
+        result_per_query: int = 10,
+    ) -> List[Dict[str, V]]: ...
+
+    @overload
+    async def afetch_document[V: (int, str, float, bytes)](
+        self,
+        vecs: List[List[float]],
+        desired_fields: str,
+        collection_name: Optional[str] = None,
+        similarity_threshold: float = 0.37,
+        result_per_query: int = 10,
+    ) -> List[V]: ...
     async def afetch_document[V: (int, str, float, bytes)](
         self,
         vecs: List[List[float]],
@@ -275,7 +295,7 @@ class RAG(EmbeddingUsage):
         if isinstance(query, str):
             query = [query]
         return cast(
-            'List[str]',
+            "List[str]",
             await self.afetch_document(
                 vecs=(await self.vectorize(query)),
                 desired_fields="text",
@@ -283,6 +303,24 @@ class RAG(EmbeddingUsage):
             ),
         )[:final_limit]
 
+    async def aretrieve_compact(
+        self,
+        query: List[str] | str,
+        **kwargs: Unpack[RetrievalKwargs],
+    ) -> str:
+        """Retrieve data from the collection and format it for display.
+
+        Args:
+            query (List[str] | str): The query to be used for retrieval.
+            **kwargs (Unpack[RetrievalKwargs]): Additional keyword arguments for retrieval.
+
+        Returns:
+            str: A formatted string containing the retrieved data.
+        """
+        return TEMPLATE_MANAGER.render_template(
+            configs.templates.retrieved_display_template, {"docs": (await self.aretrieve(query, **kwargs))}
+        )
+
     async def aask_retrieved(
         self,
         question: str,
@@ -313,16 +351,14 @@ class RAG(EmbeddingUsage):
         Returns:
             str: A string response generated after asking with the context of retrieved documents.
         """
-        docs = await self.aretrieve(
+        rendered = await self.aretrieve_compact(
             query or question,
-            final_limit,
+            final_limit=final_limit,
             collection_name=collection_name,
             result_per_query=result_per_query,
             similarity_threshold=similarity_threshold,
         )
 
-        rendered = TEMPLATE_MANAGER.render_template(configs.templates.retrieved_display_template, {"docs": docs[::-1]})
-
         logger.debug(f"Retrieved Documents: \n{rendered}")
         return await self.aask(
             question,