fabricatio 0.2.4.dev2__tar.gz → 0.2.5.dev0__tar.gz

{fabricatio-0.2.4.dev2 → fabricatio-0.2.5.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.4.dev2
+Version: 0.2.5.dev0
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12
@@ -9,6 +9,7 @@ Classifier: Framework :: AsyncIO
 Classifier: Framework :: Pydantic :: 2
 Classifier: Typing :: Typed
 Requires-Dist: appdirs>=1.4.4
+Requires-Dist: async-cache>=1.1.1
 Requires-Dist: asyncio>=3.4.3
 Requires-Dist: asyncstdlib>=3.13.0
 Requires-Dist: litellm>=1.60.0

fabricatio-0.2.5.dev0/examples/write_outline/.gitignore

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

fabricatio-0.2.5.dev0/examples/write_outline/write_outline.py

@@ -0,0 +1,24 @@
+"""Example of using the library."""
+
+import asyncio
+
+from fabricatio import Event, Role, WriteOutlineWorkFlow, logger
+
+
+async def main() -> None:
+    """Main function."""
+    role = Role(
+        name="Undergraduate Researcher",
+        description="Write an outline for an article in typst format.",
+        registry={Event.quick_instantiate(ns := "article"): WriteOutlineWorkFlow},
+    )
+
+    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.4.dev2 → fabricatio-0.2.5.dev0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fabricatio"
-version = "0.2.4-dev2"
+version = "0.2.5-dev0"
 description = "A LLM multi-agent framework."
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -28,6 +28,7 @@ keywords = [
 requires-python = ">=3.12,<3.13"
 dependencies = [
     "appdirs>=1.4.4",
+    "async-cache>=1.1.1",
     "asyncio>=3.4.3",
     "asyncstdlib>=3.13.0",
     "litellm>=1.60.0",
@@ -138,6 +139,10 @@ testpaths = [
 asyncio_mode = "auto"
 asyncio_default_fixture_loop_scope = "function"
 
+[[tool.uv.index]]
+url = "https://mirrors.bfsu.edu.cn/pypi/web/simple"
+default = true
+
 [[tool.uv.index]]
 url = "https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple"
 
@@ -147,7 +152,3 @@ url = "https://mirrors.huaweicloud.com/repository/pypi/simple"
 [[tool.uv.index]]
 url = "https://mirrors.aliyun.com/pypi/simple/"
 
-[[tool.uv.index]]
-url = "https://mirrors.bfsu.edu.cn/pypi/web/simple"
-default = true
-

{fabricatio-0.2.4.dev2 → fabricatio-0.2.5.dev0}/python/fabricatio/__init__.py

@@ -3,9 +3,10 @@
 from importlib.util import find_spec
 
 from fabricatio._rust_instances import template_manager
-from fabricatio.actions.article import ExtractArticleEssence
+from fabricatio.actions.article import ExtractArticleEssence, GenerateArticleProposal, GenerateOutline
+from fabricatio.actions.output import DumpFinalizedOutput
 from fabricatio.core import env
-from fabricatio.fs import magika
+from fabricatio.fs import magika, safe_json_read, safe_text_read
 from fabricatio.journal import logger
 from fabricatio.models.action import Action, WorkFlow
 from fabricatio.models.events import Event
@@ -15,15 +16,19 @@ from fabricatio.models.task import Task
 from fabricatio.models.tool import ToolBox
 from fabricatio.models.utils import Message, Messages
 from fabricatio.parser import Capture, CodeBlockCapture, JsonCapture, PythonCapture
-from fabricatio.toolboxes import arithmetic_toolbox, basic_toolboxes, fs_toolbox, task_toolbox
+from fabricatio.toolboxes import arithmetic_toolbox, basic_toolboxes, fs_toolbox
+from fabricatio.workflows.articles import WriteOutlineWorkFlow
 
 __all__ = [
     "Action",
     "ArticleEssence",
     "Capture",
     "CodeBlockCapture",
+    "DumpFinalizedOutput",
     "Event",
     "ExtractArticleEssence",
+    "GenerateArticleProposal",
+    "GenerateOutline",
     "JsonCapture",
     "Message",
     "Messages",
@@ -32,13 +37,15 @@ __all__ = [
     "Task",
     "ToolBox",
     "WorkFlow",
+    "WriteOutlineWorkFlow",
     "arithmetic_toolbox",
     "basic_toolboxes",
     "env",
     "fs_toolbox",
     "logger",
     "magika",
-    "task_toolbox",
+    "safe_json_read",
+    "safe_text_read",
     "template_manager",
 ]
 
@@ -46,6 +53,6 @@ __all__ = [
 if find_spec("pymilvus"):
     from fabricatio.actions.rag import InjectToDB
     from fabricatio.capabilities.rag import RAG
-    from fabricatio.workflows.articles import StoreArticle
+    from fabricatio.workflows.rag import StoreArticle
 
     __all__ += ["RAG", "InjectToDB", "StoreArticle"]

fabricatio-0.2.5.dev0/python/fabricatio/actions/article.py

@@ -0,0 +1,81 @@
+"""Actions for transmitting tasks to targets."""
+
+from os import PathLike
+from pathlib import Path
+from typing import Callable, List
+
+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
+
+
+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"),
+        **_,
+    ) -> 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,
+        **_,
+    ) -> 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"
+    """The key of the output data."""
+
+    async def _execute(
+        self,
+        article_proposal: ArticleProposal,
+        **_,
+    ) -> ArticleOutline:
+        return await self.propose(
+            ArticleOutline,
+            article_proposal.display(),
+            system_message=f"# your personal briefing: \n{self.briefing}",
+        )

fabricatio-0.2.5.dev0/python/fabricatio/actions/output.py

@@ -0,0 +1,21 @@
+"""Dump the finalized output to a file."""
+
+from typing import Unpack
+
+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, **cxt: Unpack) -> 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-0.2.4.dev2 → fabricatio-0.2.5.dev0}/python/fabricatio/capabilities/rag.py

@@ -13,10 +13,16 @@ from typing import Any, Callable, Dict, List, Optional, Self, Union, Unpack, ove
 from fabricatio._rust_instances import template_manager
 from fabricatio.config import configs
 from fabricatio.journal import logger
-from fabricatio.models.kwargs_types import CollectionSimpleConfigKwargs, EmbeddingKwargs, FetchKwargs, LLMKwargs
+from fabricatio.models.kwargs_types import (
+    ChooseKwargs,
+    CollectionSimpleConfigKwargs,
+    EmbeddingKwargs,
+    FetchKwargs,
+    LLMKwargs,
+)
 from fabricatio.models.usages import EmbeddingUsage
 from fabricatio.models.utils import MilvusData
-from more_itertools.recipes import flatten
+from more_itertools.recipes import flatten, unique
 from pydantic import Field, PrivateAttr
 
 
@@ -221,9 +227,9 @@ class RAG(EmbeddingUsage):
 
         # Step 2: Flatten the search results
         flattened_results = flatten(search_results)
-
+        unique_results = unique(flattened_results, key=itemgetter("id"))
         # Step 3: Sort by distance (descending)
-        sorted_results = sorted(flattened_results, key=itemgetter("distance"), reverse=True)
+        sorted_results = sorted(unique_results, key=itemgetter("distance"), reverse=True)
 
         logger.debug(f"Searched similarities: {[t['distance'] for t in sorted_results]}")
         # Step 4: Extract the entities
@@ -236,7 +242,6 @@ class RAG(EmbeddingUsage):
     async def aretrieve(
         self,
         query: List[str] | str,
-        collection_name: Optional[str] = None,
         final_limit: int = 20,
         **kwargs: Unpack[FetchKwargs],
     ) -> List[str]:
@@ -244,7 +249,6 @@ class RAG(EmbeddingUsage):
 
         Args:
             query (List[str] | str): The query to be used for retrieval.
-            collection_name (Optional[str]): The name of the collection. If not provided, the currently viewed collection is used.
             final_limit (int): The final limit on the number of results to return.
             **kwargs (Unpack[FetchKwargs]): Additional keyword arguments for retrieval.
 
@@ -257,15 +261,14 @@ class RAG(EmbeddingUsage):
             await self.afetch_document(
                 vecs=(await self.vectorize(query)),
                 desired_fields="text",
-                collection_name=collection_name,
                 **kwargs,
             )
         )[:final_limit]
 
     async def aask_retrieved(
         self,
-        question: str | List[str],
-        query: List[str] | str,
+        question: str,
+        query: Optional[List[str] | str] = None,
         collection_name: Optional[str] = None,
         extra_system_message: str = "",
         result_per_query: int = 10,
@@ -279,7 +282,7 @@ class RAG(EmbeddingUsage):
         specified question using the retrieved documents as context.
 
         Args:
-            question (str | List[str]): The question or list of questions to be asked.
+            question (str): The question to be asked.
             query (List[str] | str): The query or list of queries used for document retrieval.
             collection_name (Optional[str]): The name of the collection to retrieve documents from.
                                               If not provided, the currently viewed collection is used.
@@ -293,9 +296,9 @@ class RAG(EmbeddingUsage):
             str: A string response generated after asking with the context of retrieved documents.
         """
         docs = await self.aretrieve(
-            query,
-            collection_name,
+            query or question,
             final_limit,
+            collection_name=collection_name,
             result_per_query=result_per_query,
             similarity_threshold=similarity_threshold,
         )
@@ -308,3 +311,56 @@ class RAG(EmbeddingUsage):
             f"{rendered}\n\n{extra_system_message}",
             **kwargs,
         )
+
+    async def arefined_query(self, question: List[str] | str, **kwargs: Unpack[ChooseKwargs]) -> List[str]:
+        """Refines the given question using a template.
+
+        Args:
+            question (List[str] | str): The question to be refined.
+            **kwargs (Unpack[ChooseKwargs]): Additional keyword arguments for the refinement process.
+
+        Returns:
+            List[str]: A list of refined questions.
+        """
+        return await self.aliststr(
+            template_manager.render_template(
+                configs.templates.refined_query_template,
+                {"question": [question] if isinstance(question, str) else question},
+            ),
+            **kwargs,
+        )
+
+    async def aask_refined(
+        self,
+        question: str,
+        collection_name: Optional[str] = None,
+        extra_system_message: str = "",
+        result_per_query: int = 10,
+        final_limit: int = 20,
+        similarity_threshold: float = 0.37,
+        **kwargs: Unpack[LLMKwargs],
+    ) -> str:
+        """Asks a question using a refined query based on the provided question.
+
+        Args:
+            question (str): The question to be asked.
+            collection_name (Optional[str]): The name of the collection to retrieve documents from.
+            extra_system_message (str): An additional system message to be included in the prompt.
+            result_per_query (int): The number of results to return per query. Default is 10.
+            final_limit (int): The maximum number of retrieved documents to consider. Default is 20.
+            similarity_threshold (float): The threshold for similarity, only results above this threshold will be returned.
+            **kwargs (Unpack[LLMKwargs]): Additional keyword arguments passed to the underlying `aask` method.
+
+        Returns:
+            str: A string response generated after asking with the refined question.
+        """
+        return await self.aask_retrieved(
+            question,
+            await self.arefined_query(question, **kwargs),
+            collection_name=collection_name,
+            extra_system_message=extra_system_message,
+            result_per_query=result_per_query,
+            final_limit=final_limit,
+            similarity_threshold=similarity_threshold,
+            **kwargs,
+        )

{fabricatio-0.2.4.dev2 → fabricatio-0.2.5.dev0}/python/fabricatio/capabilities/rating.py

@@ -4,7 +4,7 @@ from asyncio import gather
 from itertools import permutations
 from typing import Dict, List, Set, Tuple, Union, Unpack, overload
 
-import orjson
+from cache import AsyncLRU
 from fabricatio._rust_instances import template_manager
 from fabricatio.config import configs
 from fabricatio.journal import logger
@@ -40,10 +40,8 @@ class GiveRating(WithBriefing, LLMUsage):
 
         def _validator(response: str) -> Dict[str, float] | None:
             if (
-                (json_data := JsonCapture.convert_with(response, orjson.loads)) is not None
-                and isinstance(json_data, dict)
+                (json_data := JsonCapture.validate_with(response, dict, str))
                 and json_data.keys() == rating_manual.keys()
-                and all(isinstance(v, float) for v in json_data.values())
                 and all(score_range[0] <= v <= score_range[1] for v in json_data.values())
             ):
                 return json_data
@@ -115,6 +113,7 @@ class GiveRating(WithBriefing, LLMUsage):
             return await gather(*[self.rate_fine_grind(item, manual, score_range, **kwargs) for item in to_rate])
         raise ValueError("to_rate must be a string or a list of strings")
 
+    @AsyncLRU(maxsize=32)
     async def draft_rating_manual(
         self, topic: str, criteria: Set[str], **kwargs: Unpack[ValidateKwargs]
     ) -> Dict[str, str]:
@@ -169,16 +168,6 @@ class GiveRating(WithBriefing, LLMUsage):
         Returns:
             Set[str]: A set of rating dimensions.
         """
-
-        def _validator(response: str) -> Set[str] | None:
-            if (
-                json_data := JsonCapture.validate_with(
-                    response, target_type=list, elements_type=str, length=criteria_count
-                )
-            ) is not None:
-                return set(json_data)
-            return None
-
         return await self.aask_validate(
             question=(
                 template_manager.render_template(
@@ -189,7 +178,9 @@ class GiveRating(WithBriefing, LLMUsage):
                     },
                 )
             ),
-            validator=_validator,
+            validator=lambda resp: set(out)
+            if (out := JsonCapture.validate_with(resp, list, str, criteria_count))
+            else out,
             system_message=f"# your personal briefing: \n{self.briefing}",
             **kwargs,
         )

fabricatio-0.2.5.dev0/python/fabricatio/capabilities/review.py

@@ -0,0 +1,141 @@
+"""A module that provides functionality to rate tasks based on a rating manual and score range."""
+
+from typing import List, Optional, Set, Unpack
+
+from fabricatio import template_manager
+from fabricatio.capabilities.propose import Propose
+from fabricatio.capabilities.rating import GiveRating
+from fabricatio.config import configs
+from fabricatio.models.generic import Display, ProposedAble, WithBriefing
+from fabricatio.models.kwargs_types import GenerateKwargs, ReviewKwargs
+from fabricatio.models.task import Task
+from pydantic import PrivateAttr
+
+
+class ReviewResult[T](ProposedAble, Display):
+    """Class that represents the result of a review.
+
+    This class holds the problems identified in a review and their proposed solutions,
+    along with a reference to the reviewed object.
+
+    Attributes:
+        existing_problems (List[str]): List of problems identified in the review.
+        proposed_solutions (List[str]): List of proposed solutions to the problems identified in the review.
+
+    Type Parameters:
+        T: The type of the object being reviewed.
+    """
+
+    existing_problems: List[str]
+    """List of problems identified in the review."""
+
+    proposed_solutions: List[str]
+    """List of proposed solutions to the problems identified in the review."""
+
+    _ref: T = PrivateAttr(None)
+    """Reference to the object being reviewed."""
+
+    def update_ref[K](self, ref: K) -> "ReviewResult[K]":
+        """Update the reference to the object being reviewed.
+
+        Args:
+            ref (K): The new reference to the object being reviewed.
+
+        Returns:
+            ReviewResult[K]: The updated instance of the ReviewResult class with the new reference type.
+        """
+        self._ref = ref
+        return self
+
+    def deref(self) -> T:
+        """Dereference the object being reviewed.
+
+        Returns:
+            T: The object being reviewed.
+        """
+        return self._ref
+
+
+class Review(GiveRating, Propose):
+    """Class that provides functionality to review tasks and strings using a language model.
+
+    This class extends GiveRating and Propose capabilities to analyze content,
+    identify problems, and suggest solutions based on specified criteria.
+
+    The review process can be applied to Task objects or plain strings with
+    appropriate topic and criteria.
+    """
+
+    async def review_task[T](self, task: Task[T], **kwargs: Unpack[ReviewKwargs]) -> ReviewResult[Task[T]]:
+        """Review a task using specified review criteria.
+
+        This method analyzes a task object to identify problems and propose solutions
+        based on the criteria provided in kwargs.
+
+        Args:
+            task (Task[T]): The task object to be reviewed.
+            **kwargs (Unpack[ReviewKwargs]): Additional keyword arguments for the review process,
+                including topic and optional criteria.
+
+        Returns:
+            ReviewResult[Task[T]]: A review result containing identified problems and proposed solutions,
+                with a reference to the original task.
+        """
+        return await self.review_obj(task, **kwargs)
+
+    async def review_string(
+        self, text: str, topic: str, criteria: Optional[Set[str]] = None, **kwargs: Unpack[GenerateKwargs]
+    ) -> ReviewResult[str]:
+        """Review a string based on specified topic and criteria.
+
+        This method analyzes a text string to identify problems and propose solutions
+        based on the given topic and criteria.
+
+        Args:
+            text (str): The text content to be reviewed.
+            topic (str): The subject topic for the review criteria.
+            criteria (Optional[Set[str]], optional): A set of criteria for the review.
+                If not provided, criteria will be drafted automatically. Defaults to None.
+            **kwargs (Unpack[GenerateKwargs]): Additional keyword arguments for the LLM usage.
+
+        Returns:
+            ReviewResult[str]: A review result containing identified problems and proposed solutions,
+                with a reference to the original text.
+        """
+        criteria = criteria or (await self.draft_rating_criteria(topic))
+        manual = await self.draft_rating_manual(topic, criteria)
+        res: ReviewResult[str] = await self.propose(
+            ReviewResult,
+            template_manager.render_template(
+                configs.templates.review_string_template, {"text": text, "topic": topic, "criteria_manual": manual}
+            ),
+            **kwargs,
+        )
+        return res.update_ref(text)
+
+    async def review_obj[M: (Display, WithBriefing)](self, obj: M, **kwargs: Unpack[ReviewKwargs]) -> ReviewResult[M]:
+        """Review an object that implements Display or WithBriefing interface.
+
+        This method extracts displayable text from the object and performs a review
+        based on the criteria provided in kwargs.
+
+        Args:
+            obj (M): The object to be reviewed, which must implement either Display or WithBriefing.
+            **kwargs (Unpack[ReviewKwargs]): Additional keyword arguments for the review process,
+                including topic and optional criteria.
+
+        Raises:
+            TypeError: If the object does not implement Display or WithBriefing.
+
+        Returns:
+            ReviewResult[M]: A review result containing identified problems and proposed solutions,
+                with a reference to the original object.
+        """
+        if isinstance(obj, Display):
+            text = obj.display()
+        elif isinstance(obj, WithBriefing):
+            text = obj.briefing
+        else:
+            raise TypeError(f"Unsupported type for review: {type(obj)}")
+
+        return (await self.review_string(text, **kwargs)).update_ref(obj)

{fabricatio-0.2.4.dev2 → fabricatio-0.2.5.dev0}/python/fabricatio/config.py

@@ -209,6 +209,15 @@ class TemplateConfig(BaseModel):
     liststr_template: str = Field(default="liststr")
     """The name of the liststr template which will be used to display a list of strings."""
 
+    refined_query_template: str = Field(default="refined_query")
+    """The name of the refined query template which will be used to refine a query."""
+
+    pathstr_template: str = Field(default="pathstr")
+    """The name of the pathstr template which will be used to acquire a path of strings."""
+
+    review_string_template: str = Field(default="review_string")
+    """The name of the review string template which will be used to review a string."""
+
 
 class MagikaConfig(BaseModel):
     """Magika configuration class."""

{fabricatio-0.2.4.dev2 → fabricatio-0.2.5.dev0}/python/fabricatio/fs/__init__.py

@@ -1,9 +1,19 @@
 """FileSystem manipulation module for Fabricatio."""
 
-from fabricatio.fs.curd import copy_file, create_directory, delete_directory, delete_file, dump_text, move_file, tree
+from fabricatio.fs.curd import (
+    absolute_path,
+    copy_file,
+    create_directory,
+    delete_directory,
+    delete_file,
+    dump_text,
+    move_file,
+    tree,
+)
 from fabricatio.fs.readers import magika, safe_json_read, safe_text_read
 
 __all__ = [
+    "absolute_path",
     "copy_file",
     "create_directory",
     "delete_directory",