fabricatio 0.2.13.dev0__cp312-cp312-win_amd64.whl → 0.2.13.dev2__cp312-cp312-win_amd64.whl

fabricatio/actions/article.py

@@ -8,10 +8,12 @@ from more_itertools import filter_map
 from pydantic import Field
 from rich import print as r_print
 
+from fabricatio import TEMPLATE_MANAGER
 from fabricatio.capabilities.censor import Censor
 from fabricatio.capabilities.extract import Extract
 from fabricatio.capabilities.propose import Propose
-from fabricatio.fs import safe_text_read
+from fabricatio.config import configs
+from fabricatio.fs import dump_text, safe_text_read
 from fabricatio.journal import logger
 from fabricatio.models.action import Action
 from fabricatio.models.extra.article_essence import ArticleEssence
@@ -21,6 +23,7 @@ from fabricatio.models.extra.article_proposal import ArticleProposal
 from fabricatio.models.extra.rule import RuleSet
 from fabricatio.models.kwargs_types import ValidateKwargs
 from fabricatio.models.task import Task
+from fabricatio.models.usages import LLMUsage
 from fabricatio.rust import BibManager, detect_language
 from fabricatio.utils import ok, wrapp_in_block
 
@@ -271,3 +274,48 @@ class LoadArticle(Action):
 
     async def _execute(self, article_outline: ArticleOutline, typst_code: str, **cxt) -> Article:
         return Article.from_mixed_source(article_outline, typst_code)
+
+
+class WriteChapterSummary(Action, LLMUsage):
+    """Write the chapter summary."""
+
+    output_key: str = "chapter_summaries"
+
+    paragraph_count: int = 1
+
+    summary_word_count: int = 200
+
+    summary_title: str = "Chapter Summary"
+    write_to: Optional[Path] = None
+
+    async def _execute(self, article: Article, write_to: Optional[Path] = None, **cxt) -> List[str]:
+        logger.info(";".join(a.title for a in article.chapters))
+
+        ret = [
+            f"== {self.summary_title}\n{raw}"
+            for raw in (
+                await self.aask(
+                    TEMPLATE_MANAGER.render_template(
+                        configs.templates.chap_summary_template,
+                        [
+                            {
+                                "chapter": a.to_typst_code(),
+                                "title": a.title,
+                                "language": a.language,
+                                "summary_word_count": self.summary_word_count,
+                                "paragraph_count": self.paragraph_count,
+                            }
+                            for a in article.chapters
+                        ],
+                    )
+                )
+            )
+        ]
+
+        if (to := (self.write_to or write_to)) is not None:
+            dump_text(
+                to,
+                "\n\n\n".join(f"//{a.title}\n\n{s}" for a, s in zip(article.chapters, ret, strict=True)),
+            )
+
+        return ret

fabricatio/actions/article_rag.py

@@ -2,7 +2,7 @@
 
 from asyncio import gather
 from pathlib import Path
-from typing import List, Optional
+from typing import ClassVar, List, Optional
 
 from pydantic import Field, PositiveInt
 
@@ -21,17 +21,17 @@ from fabricatio.models.extra.article_outline import ArticleOutline
 from fabricatio.models.extra.rule import RuleSet
 from fabricatio.models.kwargs_types import ChooseKwargs, LLMKwargs
 from fabricatio.rust import convert_to_block_formula, convert_to_inline_formula
-from fabricatio.utils import ask_retain, ok
+from fabricatio.utils import ok
 
 TYPST_CITE_USAGE = (
-    "citation number is REQUIRED to cite any reference!,for example in Auther Pattern: 'Doe et al.[[1]], Jack et al.[[2]]' or in Sentence Suffix Sattern: 'Global requirement is incresing[[1]].'\n"
-    "Everything is build upon the typst language, which is similar to latex, \n"
+    "citation number is REQUIRED to cite any reference!'\n"
     "Legal citing syntax examples(seperated by |): [[1]]|[[1,2]]|[[1-3]]|[[12,13-15]]|[[1-3,5-7]]\n"
     "Illegal citing syntax examples(seperated by |): [[1],[2],[3]]|[[1],[1-2]]\n"
+    "You SHALL not cite a single reference more than once!"
     "Those reference mark shall not be omitted during the extraction\n"
     "It's recommended to cite multiple references that supports your conclusion at a time.\n"
     "Wrap inline expression with '\\(' and '\\)',like '\\(>5m\\)' '\\(89%\\)', and wrap block equation with '\\[' and '\\]'.\n"
-    "In addition to that, you can add a label outside the block equation which can be used as a cross reference identifier, the label is a string wrapped in `<` and `>` like `<energy-release-rate-equation>`.Note that the label string should be a summarizing title for the equation being labeled.\n"
+    "In addition to that, you can add a label outside the block equation which can be used as a cross reference identifier, the label is a string wrapped in `<` and `>` like `<energy-release-rate-equation>`.Note that the label string should be a summarizing title for the equation being labeled and should never be written within the formula block.\n"
     "you can refer to that label by using the syntax with prefix of `@eqt:`, which indicate that this notation is citing a label from the equations. For example ' @eqt:energy-release-rate-equation ' DO remember that the notation shall have both suffixed and prefixed space char which enable the compiler to distinguish the notation from the plaintext."
     "Below is two usage example:\n"
     "```typst\n"
@@ -47,6 +47,7 @@ TYPST_CITE_USAGE = (
 class WriteArticleContentRAG(Action, RAG, Extract):
     """Write an article based on the provided outline."""
 
+    ctx_override: ClassVar[bool] = True
     search_increment_multiplier: float = 1.6
     """The increment multiplier of the search increment."""
     ref_limit: int = 35
@@ -63,6 +64,7 @@ class WriteArticleContentRAG(Action, RAG, Extract):
     """The number of results to be returned per query."""
     req: str = TYPST_CITE_USAGE
     """The req of the write article content."""
+    tei_endpoint: Optional[str] = None
 
     async def _execute(
         self,
@@ -108,16 +110,7 @@ class WriteArticleContentRAG(Action, RAG, Extract):
 
         while not await confirm("Accept this version and continue?").ask_async():
             if inst := await text("Search for more refs for additional spec.").ask_async():
-                await self.search_database(
-                    article,
-                    article_outline,
-                    chap,
-                    sec,
-                    subsec,
-                    cm,
-                    supervisor=True,
-                    extra_instruction=inst,
-                )
+                await self.search_database(article, article_outline, chap, sec, subsec, cm, extra_instruction=inst)
 
             if instruction := await text("Enter the instructions to improve").ask_async():
                 raw = await self.write_raw(article, article_outline, chap, sec, subsec, cm, instruction)
@@ -200,7 +193,6 @@ class WriteArticleContentRAG(Action, RAG, Extract):
         subsec: ArticleSubsection,
         cm: CitationManager,
         extra_instruction: str = "",
-        supervisor: bool = False,
     ) -> None:
         """Search database for related references."""
         search_req = (
@@ -208,61 +200,31 @@ class WriteArticleContentRAG(Action, RAG, Extract):
             f"More specifically, i m witting the Chapter `{chap.title}` >> Section `{sec.title}` >> Subsection `{subsec.title}`.\n"
             f"I need to search related references to build up the content of the subsec mentioned above, which is `{subsec.title}`.\n"
             f"provide 10~16 queries as possible, to get best result!\n"
-            f"You should provide both English version and chinese version of the refined queries!\n{extra_instruction}\n"
+            f"You should provide both English version and chinese version of the refined queries!\n{extra_instruction}"
         )
 
-        ref_q = ok(
-            await self.arefined_query(
-                search_req,
-                **self.query_model,
-            ),
-            "Failed to refine query.",
-        )
-
-        if supervisor:
-            ref_q = await ask_retain(ref_q)
-        ret = await self.aretrieve(
-            ref_q,
-            ArticleChunk,
-            max_accepted=self.ref_limit,
-            result_per_query=self.result_per_query,
-            similarity_threshold=self.threshold,
-        )
-
-        cm.add_chunks(ok(ret))
-        ref_q = await self.arefined_query(
-            f"{cm.as_prompt()}\n\nAbove is the retrieved references in the first RAG, now we need to perform the second RAG.\n\n{search_req}",
-            **self.query_model,
-        )
-
-        if ref_q is None:
-            logger.warning("Second refine query is None, skipping.")
-            return
-        if supervisor:
-            ref_q = await ask_retain(ref_q)
-
-        ret = await self.aretrieve(
-            ref_q,
-            ArticleChunk,
-            max_accepted=int(self.ref_limit * self.search_increment_multiplier),
-            result_per_query=int(self.result_per_query * self.search_increment_multiplier),
-            similarity_threshold=self.threshold,
+        await self.clued_search(
+            search_req,
+            cm,
+            refinery_kwargs=self.ref_q_model,
+            expand_multiplier=self.search_increment_multiplier,
+            base_accepted=self.ref_limit,
+            result_per_query=self.ref_per_q,
+            similarity_threshold=self.similarity_threshold,
+            tei_endpoint=self.tei_endpoint,
         )
-        if ret is None:
-            logger.warning("Second retrieve is None, skipping.")
-            return
-        cm.add_chunks(ret)
 
 
 class ArticleConsultRAG(Action, AdvancedRAG):
     """Write an article based on the provided outline."""
 
+    ctx_override: ClassVar[bool] = True
     output_key: str = "consult_count"
     search_increment_multiplier: float = 1.6
     """The multiplier to increase the limit of references to retrieve per query."""
-    ref_limit: int = 20
+    ref_limit: int = 26
     """The final limit of references."""
-    ref_per_q: int = 3
+    ref_per_q: int = 13
     """The limit of references to retrieve per query."""
     similarity_threshold: float = 0.62
     """The similarity threshold of references to retrieve."""
@@ -270,6 +232,7 @@ class ArticleConsultRAG(Action, AdvancedRAG):
     """The model to use for refining query."""
     req: str = TYPST_CITE_USAGE
     """The request for the rag model."""
+    tei_endpoint: Optional[str] = None
 
     @precheck_package(
         "questionary", "`questionary` is required for supervisor mode, please install it by `fabricatio[qa]`"
@@ -300,6 +263,7 @@ class ArticleConsultRAG(Action, AdvancedRAG):
                 base_accepted=self.ref_limit,
                 result_per_query=self.ref_per_q,
                 similarity_threshold=self.similarity_threshold,
+                tei_endpoint=self.tei_endpoint,
             )
 
             ret = await self.aask(f"{cm.as_prompt()}\n{self.req}\n{req}")

fabricatio/capabilities/advanced_rag.py

@@ -7,6 +7,7 @@ from fabricatio.journal import logger
 from fabricatio.models.adv_kwargs_types import FetchKwargs
 from fabricatio.models.extra.aricle_rag import ArticleChunk, CitationManager
 from fabricatio.models.kwargs_types import ChooseKwargs
+from fabricatio.utils import fallback_kwargs
 
 
 class AdvancedRAG(RAG):
@@ -40,10 +41,13 @@ class AdvancedRAG(RAG):
                 f"\n\n{requirement}",
                 **refinery_kwargs,
             )
+
             if ref_q is None:
                 logger.error(f"At round [{i}/{max_round}] search, failed to refine the query, exit.")
                 return cm
-            refs = await self.aretrieve(ref_q, ArticleChunk, base_accepted, **kwargs)
+            refs = await self.aretrieve(
+                ref_q, ArticleChunk, base_accepted, **fallback_kwargs(kwargs, filter_expr=cm.as_milvus_filter_expr())
+            )
 
             if (max_capacity := max_capacity - len(refs)) < 0:
                 cm.add_chunks(refs[0:max_capacity])

fabricatio/capabilities/rag.py

@@ -143,21 +143,27 @@ class RAG(EmbeddingUsage):
 
     async def afetch_document[D: MilvusDataBase](
         self,
-        vecs: List[List[float]],
+        query: List[str],
         document_model: Type[D],
         collection_name: Optional[str] = None,
         similarity_threshold: float = 0.37,
         result_per_query: int = 10,
+        tei_endpoint: Optional[str] = None,
+        reranker_threshold: float = 0.7,
+        filter_expr: str = "",
     ) -> List[D]:
         """Asynchronously fetches documents from a Milvus database based on input vectors.
 
         Args:
-           vecs (List[List[float]]): A list of vectors to search for in the database.
+           query (List[str]): A list of vectors to search for in the database.
            document_model (Type[D]): The model class used to convert fetched data into document objects.
            collection_name (Optional[str]): The name of the collection to search within.
                                              If None, the currently viewed collection is used.
            similarity_threshold (float): The similarity threshold for vector search. Defaults to 0.37.
            result_per_query (int): The maximum number of results to return per query. Defaults to 10.
+           tei_endpoint (str): the endpoint of the TEI api.
+           reranker_threshold (float): The threshold used to filtered low relativity document.
+            filter_expr (str): filter_expression parsed into pymilvus search.
 
         Returns:
            List[D]: A list of document objects created from the fetched data.
@@ -165,15 +171,38 @@ class RAG(EmbeddingUsage):
         # Step 1: Search for vectors
         search_results = self.check_client().client.search(
             collection_name or self.safe_target_collection,
-            vecs,
+            await self.vectorize(query),
             search_params={"radius": similarity_threshold},
             output_fields=list(document_model.model_fields),
+            filter=filter_expr,
             limit=result_per_query,
         )
+        if tei_endpoint is not None:
+            from fabricatio.utils import RerankerAPI
+
+            reranker = RerankerAPI(base_url=tei_endpoint)
+
+            retrieved_id = set()
+            raw_result = []
+
+            for q, g in zip(query, search_results, strict=True):
+                models = document_model.from_sequence([res["entity"] for res in g if res["id"] not in retrieved_id])
+                logger.debug(f"Retrived {len(g)} raw document, filtered out {len(models)}.")
+                retrieved_id.update(res["id"] for res in g)
+                if not models:
+                    continue
+                rank_scores = await reranker.arerank(q, [m.prepare_vectorization() for m in models], truncate=True)
+                raw_result.extend(
+                    (models[s["index"]], s["score"]) for s in rank_scores if s["score"] > reranker_threshold
+                )
+
+            raw_result_sorted = sorted(raw_result, key=lambda x: x[1], reverse=True)
+            return [r[0] for r in raw_result_sorted]
 
         # 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(unique_results, key=itemgetter("distance"), reverse=True)
 
@@ -205,15 +234,18 @@ class RAG(EmbeddingUsage):
         """
         if isinstance(query, str):
             query = [query]
+
         return (
             await self.afetch_document(
-                vecs=(await self.vectorize(query)),
+                query=query,
                 document_model=document_model,
                 **kwargs,
             )
         )[:max_accepted]
 
-    async def arefined_query(self, question: List[str] | str, **kwargs: Unpack[ChooseKwargs[Optional[List[str]]]]) -> Optional[List[str]]:
+    async def arefined_query(
+        self, question: List[str] | str, **kwargs: Unpack[ChooseKwargs[Optional[List[str]]]]
+    ) -> Optional[List[str]]:
         """Refines the given question using a template.
 
         Args:

fabricatio/config.py

@@ -86,10 +86,12 @@ class LLMConfig(BaseModel):
 
     tpm: Optional[PositiveInt] = Field(default=1000000)
     """The rate limit of the LLM model in tokens per minute. None means not checked."""
-    presence_penalty:Optional[PositiveFloat]=None
+    presence_penalty: Optional[PositiveFloat] = None
     """The presence penalty of the LLM model."""
-    frequency_penalty:Optional[PositiveFloat]=None
+    frequency_penalty: Optional[PositiveFloat] = None
     """The frequency penalty of the LLM model."""
+
+
 class EmbeddingConfig(BaseModel):
     """Embedding configuration class."""
 
@@ -252,10 +254,13 @@ class TemplateConfig(BaseModel):
     rule_requirement_template: str = Field(default="rule_requirement")
     """The name of the rule requirement template which will be used to generate a rule requirement."""
 
-
     extract_template: str = Field(default="extract")
     """The name of the extract template which will be used to extract model from string."""
 
+    chap_summary_template: str = Field(default="chap_summary")
+    """The name of the chap summary template which will be used to generate a chapter summary."""
+
+
 class MagikaConfig(BaseModel):
     """Magika configuration class."""
 

fabricatio/models/action.py

@@ -12,7 +12,7 @@ Classes:
 import traceback
 from abc import abstractmethod
 from asyncio import Queue, create_task
-from typing import Any, Dict, Self, Sequence, Tuple, Type, Union, final
+from typing import Any, ClassVar, Dict, Self, Sequence, Tuple, Type, Union, final
 
 from fabricatio.journal import logger
 from fabricatio.models.generic import WithBriefing
@@ -33,6 +33,9 @@ class Action(WithBriefing):
     a specific operation and can modify the shared context data.
     """
 
+    ctx_override: ClassVar[bool] = False
+    """Whether to override the instance attr by the context variable."""
+
     name: str = Field(default="")
     """The name of the action."""
 
@@ -157,6 +160,15 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
             action.personality = personality
         return self
 
+    def override_action_variable(self, action: Action, ctx: Dict[str, Any]) -> Self:
+        """Override action variable with context values."""
+        if action.ctx_override:
+            for k, v in ctx.items():
+                if hasattr(action, k):
+                    setattr(action, k, v)
+
+        return self
+
     async def serve(self, task: Task) -> None:
         """Execute workflow to complete given task.
 
@@ -178,11 +190,12 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
         try:
             # Process each action in sequence
             for i, step in enumerate(self._instances):
-                current_action = step.name
-                logger.info(f"Executing step [{i}] >> {current_action}")
+                logger.info(f"Executing step [{i}] >> {(current_action := step.name)}")
 
                 # Get current context and execute action
                 context = await self._context.get()
+
+                self.override_action_variable(step, context)
                 act_task = create_task(step.act(context))
                 # Handle task cancellation
                 if task.is_cancelled():

fabricatio/models/adv_kwargs_types.py

@@ -1,7 +1,7 @@
 """A module containing kwargs types for content correction and checking operations."""
 
 from importlib.util import find_spec
-from typing import NotRequired, TypedDict
+from typing import NotRequired, Optional, TypedDict
 
 from fabricatio.models.extra.problem import Improvement
 from fabricatio.models.extra.rule import RuleSet
@@ -58,3 +58,6 @@ if find_spec("pymilvus"):
         collection_name: NotRequired[str | None]
         similarity_threshold: NotRequired[float]
         result_per_query: NotRequired[int]
+        tei_endpoint: NotRequired[Optional[str]]
+        reranker_threshold: NotRequired[float]
+        filter_expr: NotRequired[str]

fabricatio/models/extra/aricle_rag.py

@@ -1,6 +1,7 @@
 """A Module containing the article rag models."""
 
 import re
+from itertools import groupby
 from pathlib import Path
 from typing import ClassVar, Dict, List, Optional, Self, Unpack
 
@@ -10,12 +11,13 @@ from fabricatio.models.extra.rag import MilvusDataBase
 from fabricatio.models.generic import AsPrompt
 from fabricatio.models.kwargs_types import ChunkKwargs
 from fabricatio.rust import BibManager, blake3_hash, split_into_chunks
-from fabricatio.utils import ok
+from fabricatio.utils import ok, wrapp_in_block
+from more_itertools.more import first
 from more_itertools.recipes import flatten, unique
 from pydantic import Field
 
 
-class ArticleChunk(MilvusDataBase, AsPrompt):
+class ArticleChunk(MilvusDataBase):
     """The chunk of an article."""
 
     etc_word: ClassVar[str] = "等"
@@ -51,10 +53,9 @@ class ArticleChunk(MilvusDataBase, AsPrompt):
     bibtex_cite_key: str
     """The bibtex cite key of the article"""
 
-    def _as_prompt_inner(self) -> Dict[str, str]:
-        return {
-            f"[[{ok(self._cite_number, 'You need to update cite number first.')}]] reference `{self.article_title}` from {self.as_auther_seq()}": self.chunk
-        }
+    @property
+    def reference_header(self) -> str:
+        return f"[[{ok(self._cite_number, 'You need to update cite number first.')}]] reference `{self.article_title}` from {self.as_auther_seq()}"
 
     @property
     def cite_number(self) -> int:
@@ -204,13 +205,23 @@ class CitationManager(AsPrompt):
 
     def set_cite_number_all(self) -> Self:
         """Set citation numbers for all article chunks."""
-        for i, a in enumerate(self.article_chunks, 1):
-            a.update_cite_number(i)
+        number_mapping = {a.bibtex_cite_key: 0 for a in self.article_chunks}
+
+        for i, k in enumerate(number_mapping.keys()):
+            number_mapping[k] = i
+
+        for a in self.article_chunks:
+            a.update_cite_number(number_mapping[a.bibtex_cite_key])
         return self
 
     def _as_prompt_inner(self) -> Dict[str, str]:
         """Generate prompt inner representation."""
-        return {"References": "\n".join(r.as_prompt() for r in self.article_chunks)}
+        seg = []
+        for k, g in groupby(self.article_chunks, key=lambda a: a.bibtex_cite_key):
+            g = list(g)
+            logger.debug(f"Group [{k}]: {len(g)}")
+            seg.append(wrapp_in_block("\n\n".join(a.chunk for a in g), first(g).reference_header))
+        return {"References": "\n".join(seg)}
 
     def apply(self, string: str) -> str:
         """Apply citation replacements to the input string."""
@@ -261,5 +272,9 @@ class CitationManager(AsPrompt):
 
     def unpack_cite_seq(self, citation_seq: List[int]) -> str:
         """Unpack citation sequence into a string."""
-        chunk_seq = [a for a in self.article_chunks if a.cite_number in citation_seq]
-        return "".join(a.as_typst_cite() for a in chunk_seq)
+        chunk_seq = {a.bibtex_cite_key: a for a in self.article_chunks if a.cite_number in citation_seq}
+        return "".join(a.as_typst_cite() for a in chunk_seq.values())
+
+    def as_milvus_filter_expr(self, blacklist: bool = True) -> str:
+        if blacklist:
+            return " and ".join(f'bibtex_cite_key != "{a.bibtex_cite_key}"' for a in self.article_chunks)

fabricatio/models/extra/article_base.py

@@ -2,8 +2,9 @@
 
 from abc import ABC
 from enum import StrEnum
-from typing import Generator, List, Optional, Self, Tuple
+from typing import ClassVar, Generator, List, Optional, Self, Tuple, Type
 
+from fabricatio.fs.readers import extract_sections
 from fabricatio.models.generic import (
     AsPrompt,
     Described,
@@ -105,12 +106,6 @@ class ArticleOutlineBase(
         self.description = other.description
         return self
 
-    def display_metadata(self) -> str:
-        """Displays the metadata of the current instance."""
-        return self.model_dump_json(
-            indent=1, include={"title", "writing_aim", "description", "support_to", "depend_on"}
-        )
-
     def update_from_inner(self, other: Self) -> Self:
         """Updates the current instance with the attributes of another instance."""
         return self.update_metadata(other)
@@ -140,6 +135,8 @@ class SectionBase[T: SubSectionBase](ArticleOutlineBase):
     subsections: List[T]
     """Subsections of the section. Contains at least one subsection. You can also add more as needed."""
 
+    child_type: ClassVar[Type[SubSectionBase]]
+
     def to_typst_code(self) -> str:
         """Converts the section into a Typst formatted code snippet.
 
@@ -148,6 +145,17 @@ class SectionBase[T: SubSectionBase](ArticleOutlineBase):
         """
         return f"== {super().to_typst_code()}" + "\n\n".join(subsec.to_typst_code() for subsec in self.subsections)
 
+    @classmethod
+    def from_typst_code(cls, title: str, body: str, **kwargs) -> Self:
+        """Creates an Article object from the given Typst code."""
+        return super().from_typst_code(
+            title,
+            body,
+            subsections=[
+                cls.child_type.from_typst_code(*pack) for pack in extract_sections(body, level=3, section_char="=")
+            ],
+        )
+
     def resolve_update_conflict(self, other: Self) -> str:
         """Resolve update errors in the article outline."""
         out = ""
@@ -186,11 +194,23 @@ class ChapterBase[T: SectionBase](ArticleOutlineBase):
 
     sections: List[T]
     """Sections of the chapter. Contains at least one section. You can also add more as needed."""
+    child_type: ClassVar[Type[SectionBase]]
 
     def to_typst_code(self) -> str:
         """Converts the chapter into a Typst formatted code snippet for rendering."""
         return f"= {super().to_typst_code()}" + "\n\n".join(sec.to_typst_code() for sec in self.sections)
 
+    @classmethod
+    def from_typst_code(cls, title: str, body: str, **kwargs) -> Self:
+        """Creates an Article object from the given Typst code."""
+        return super().from_typst_code(
+            title,
+            body,
+            sections=[
+                cls.child_type.from_typst_code(*pack) for pack in extract_sections(body, level=2, section_char="=")
+            ],
+        )
+
     def resolve_update_conflict(self, other: Self) -> str:
         """Resolve update errors in the article outline."""
         out = ""
@@ -238,6 +258,19 @@ class ArticleBase[T: ChapterBase](FinalizedDumpAble, AsPrompt, FromTypstCode, To
     chapters: List[T]
     """Chapters of the article. Contains at least one chapter. You can also add more as needed."""
 
+    child_type: ClassVar[Type[ChapterBase]]
+
+    @classmethod
+    def from_typst_code(cls, title: str, body: str, **kwargs) -> Self:
+        """Generates an article from the given Typst code."""
+        return super().from_typst_code(
+            title,
+            body,
+            chapters=[
+                cls.child_type.from_typst_code(*pack) for pack in extract_sections(body, level=1, section_char="=")
+            ],
+        )
+
     def iter_dfs_rev(
         self,
     ) -> Generator[ArticleOutlineBase, None, None]:

fabricatio/models/extra/article_main.py

@@ -1,9 +1,8 @@
 """ArticleBase and ArticleSubsection classes for managing hierarchical document components."""
 
-from typing import Dict, Generator, List, Self, Tuple, override
+from typing import ClassVar, Dict, Generator, List, Self, Tuple, Type, override
 
 from fabricatio.decorators import precheck_package
-from fabricatio.fs.readers import extract_sections
 from fabricatio.journal import logger
 from fabricatio.models.extra.article_base import (
     ArticleBase,
@@ -52,6 +51,11 @@ class Paragraph(SketchedAble, WordCount, Described):
         """Create a Paragraph object from the given content."""
         return cls(elaboration="", aims=[], expected_word_count=word_count(content), content=content)
 
+    @property
+    def exact_wordcount(self) -> int:
+        """Calculates the exact word count of the content."""
+        return word_count(self.content)
+
 
 class ArticleParagraphSequencePatch(SequencePatch[Paragraph]):
     """Patch for `Paragraph` list of `ArticleSubsection`."""
@@ -115,31 +119,13 @@ class ArticleSubsection(SubSectionBase):
 class ArticleSection(SectionBase[ArticleSubsection]):
     """Atomic argumentative unit with high-level specificity."""
 
-    @classmethod
-    def from_typst_code(cls, title: str, body: str, **kwargs) -> Self:
-        """Creates an Article object from the given Typst code."""
-        return super().from_typst_code(
-            title,
-            body,
-            subsections=[
-                ArticleSubsection.from_typst_code(*pack) for pack in extract_sections(body, level=3, section_char="=")
-            ],
-        )
+    child_type: ClassVar[Type[SubSectionBase]] = ArticleSubsection
 
 
 class ArticleChapter(ChapterBase[ArticleSection]):
     """Thematic progression implementing research function."""
 
-    @classmethod
-    def from_typst_code(cls, title: str, body: str, **kwargs) -> Self:
-        """Creates an Article object from the given Typst code."""
-        return super().from_typst_code(
-            title,
-            body,
-            sections=[
-                ArticleSection.from_typst_code(*pack) for pack in extract_sections(body, level=2, section_char="=")
-            ],
-        )
+    child_type: ClassVar[Type[SectionBase]] = ArticleSection
 
 
 class Article(
@@ -153,6 +139,8 @@ class Article(
     aiming to provide a comprehensive model for academic papers.
     """
 
+    child_type: ClassVar[Type[ChapterBase]] = ArticleChapter
+
     def _as_prompt_inner(self) -> Dict[str, str]:
         return {
             "Original Article Briefing": self.referenced.referenced.referenced,
@@ -261,17 +249,6 @@ class Article(
             article.chapters.append(article_chapter)
         return article
 
-    @classmethod
-    def from_typst_code(cls, title: str, body: str, **kwargs) -> Self:
-        """Generates an article from the given Typst code."""
-        return super().from_typst_code(
-            title,
-            body,
-            chapters=[
-                ArticleChapter.from_typst_code(*pack) for pack in extract_sections(body, level=1, section_char="=")
-            ],
-        )
-
     @classmethod
     def from_mixed_source(cls, article_outline: ArticleOutline, typst_code: str) -> Self:
         """Generates an article from the given outline and Typst code."""
@@ -292,3 +269,15 @@ class Article(
         for a in self.iter_dfs():
             a.title = await text(f"Edit `{a.title}`.", default=a.title).ask_async() or a.title
         return self
+
+    def check_short_paragraphs(self, threshold: int = 60) -> str:
+        """Checks for short paragraphs in the article."""
+        err = []
+        for chap, sec, subsec in self.iter_subsections():
+            for i, p in enumerate(subsec.paragraphs):
+                if p.exact_wordcount <= threshold:
+                    err.append(
+                        f"{chap.title}->{sec.title}->{subsec.title}-> Paragraph [{i}] is too short, {p.exact_wordcount} words."
+                    )
+
+        return "\n".join(err)

fabricatio/models/extra/article_outline.py

@@ -19,6 +19,7 @@ class ArticleSubsectionOutline(SubSectionBase):
 
 class ArticleSectionOutline(SectionBase[ArticleSubsectionOutline]):
     """A slightly more detailed research component specification for academic paper generation, Must contain subsections."""
+
     @classmethod
     def from_typst_code(cls, title: str, body: str, **kwargs) -> Self:
         """Parse the given Typst code into an ArticleSectionOutline instance."""
@@ -32,7 +33,6 @@ class ArticleSectionOutline(SectionBase[ArticleSubsectionOutline]):
         )
 
 
-
 class ArticleChapterOutline(ChapterBase[ArticleSectionOutline]):
     """Macro-structural unit implementing standard academic paper organization. Must contain sections."""
 
@@ -46,11 +46,9 @@ class ArticleChapterOutline(ChapterBase[ArticleSectionOutline]):
                 ArticleSectionOutline.from_typst_code(*pack)
                 for pack in extract_sections(body, level=2, section_char="=")
             ],
-
         )
 
 
-
 class ArticleOutline(
     WithRef[ArticleProposal],
     PersistentAble,

fabricatio/models/generic.py

@@ -312,11 +312,11 @@ class Language(Base):
     @property
     def language(self) -> str:
         """Get the language of the object."""
-        if isinstance(self, Described):
+        if isinstance(self, Described) and self.description:
             return detect_language(self.description)
-        if isinstance(self, Titled):
+        if isinstance(self, Titled) and self.title:
             return detect_language(self.title)
-        if isinstance(self, Named):
+        if isinstance(self, Named) and self.name:
             return detect_language(self.name)
 
         return detect_language(self.model_dump_json(by_alias=True))

fabricatio/models/kwargs_types.py

@@ -1,6 +1,6 @@
 """This module contains the types for the keyword arguments of the methods in the models module."""
 
-from typing import Any, Dict, List, NotRequired, Optional, Required, TypedDict
+from typing import Any, Dict, List, Literal, NotRequired, Optional, Required, TypedDict
 
 from litellm.caching.caching import CacheMode
 from litellm.types.caching import CachingSupportedCallTypes
@@ -164,3 +164,11 @@ class CacheKwargs(TypedDict, total=False):
     qdrant_collection_name: str
     qdrant_quantization_config: str
     qdrant_semantic_cache_embedding_model: str
+
+
+class RerankOptions(TypedDict, total=False):
+    """Optional keyword arguments for the rerank method."""
+
+    raw_scores: bool
+    truncate: bool
+    truncation_direction: Literal["Left", "Right"]

fabricatio/utils.py

@@ -1,8 +1,13 @@
 """A collection of utility functions for the fabricatio package."""
 
-from typing import Any, Dict, List, Mapping, Optional, overload
+from typing import Any, Dict, List, Mapping, Optional, TypedDict, Unpack, overload
+
+import aiohttp
+import requests
 
 from fabricatio.decorators import precheck_package
+from fabricatio.journal import logger
+from fabricatio.models.kwargs_types import RerankOptions
 
 
 @precheck_package(
@@ -92,3 +97,159 @@ def wrapp_in_block(string: str, title: str, style: str = "-") -> str:
         str: The wrapped string.
     """
     return f"--- Start of {title} ---\n{string}\n--- End of {title} ---".replace("-", style)
+
+
+class RerankResult(TypedDict):
+    """The rerank result."""
+
+    index: int
+    score: float
+
+
+class RerankerAPI:
+    """A class to interact with the /rerank API for text reranking."""
+
+    def __init__(self, base_url: str) -> None:
+        """Initialize the RerankerAPI instance.
+
+        Args:
+            base_url (str): The base URL of the TEI-deployed reranker model API.
+                Example: "http://localhost:8000".
+        """
+        self.base_url = base_url.rstrip("/")  # Ensure no trailing slashes
+
+    @staticmethod
+    def _map_error_code(status_code: int, error_data: Dict[str, str]) -> Exception:
+        """Map HTTP status codes and error data to specific exceptions.
+
+        Args:
+            status_code (int): The HTTP status code returned by the API.
+            error_data (Dict[str, str]): The error details returned by the API.
+
+        Returns:
+            Exception: A specific exception based on the error code and message.
+        """
+        error_message = error_data.get("error", "Unknown error")
+
+        if status_code == 400:
+            return ValueError(f"Bad request: {error_message}")
+        if status_code == 413:
+            return ValueError(f"Batch size error: {error_message}")
+        if status_code == 422:
+            return RuntimeError(f"Tokenization error: {error_message}")
+        if status_code == 424:
+            return RuntimeError(f"Rerank error: {error_message}")
+        if status_code == 429:
+            return RuntimeError(f"Model overloaded: {error_message}")
+        return RuntimeError(f"Unexpected error ({status_code}): {error_message}")
+
+    def rerank(self, query: str, texts: List[str], **kwargs: Unpack[RerankOptions]) -> List[RerankResult]:
+        """Call the /rerank API to rerank a list of texts based on a query (synchronous).
+
+        Args:
+            query (str): The query string used for matching with the texts.
+            texts (List[str]): A list of texts to be reranked.
+            **kwargs (Unpack[RerankOptions]): Optional keyword arguments:
+                - raw_scores (bool, optional): Whether to return raw scores. Defaults to False.
+                - truncate (bool, optional): Whether to truncate the texts. Defaults to False.
+                - truncation_direction (Literal["left", "right"], optional): Direction of truncation. Defaults to "right".
+
+        Returns:
+            List[RerankResult]: A list of dictionaries containing the reranked results.
+                Each dictionary includes:
+                - "index" (int): The original index of the text.
+                - "score" (float): The relevance score.
+
+        Raises:
+            ValueError: If input parameters are invalid or the API returns a client-side error.
+            RuntimeError: If the API call fails or returns a server-side error.
+        """
+        # Validate inputs
+        if not isinstance(query, str) or not query.strip():
+            raise ValueError("Query must be a non-empty string.")
+        if not isinstance(texts, list) or not all(isinstance(text, str) for text in texts):
+            raise ValueError("Texts must be a list of strings.")
+
+        # Construct the request payload
+        payload = {
+            "query": query,
+            "texts": texts,
+            **kwargs,
+        }
+
+        try:
+            # Send POST request to the API
+            response = requests.post(f"{self.base_url}/rerank", json=payload)
+
+            # Handle non-200 status codes
+            if not response.ok:
+                error_data = None
+                if "application/json" in response.headers.get("Content-Type", ""):
+                    error_data = response.json()
+                else:
+                    error_data = {"error": response.text, "error_type": "unexpected_mimetype"}
+                raise self._map_error_code(response.status_code, error_data)
+
+            # Parse the JSON response
+            data: List[RerankResult] = response.json()
+            logger.debug(f"Rerank for `{query}` get {[s['score'] for s in data]}")
+            return data
+
+        except requests.exceptions.RequestException as e:
+            raise RuntimeError(f"Failed to connect to the API: {e}") from e
+
+    async def arerank(self, query: str, texts: List[str], **kwargs: Unpack[RerankOptions]) -> List[RerankResult]:
+        """Call the /rerank API to rerank a list of texts based on a query (asynchronous).
+
+        Args:
+            query (str): The query string used for matching with the texts.
+            texts (List[str]): A list of texts to be reranked.
+            **kwargs (Unpack[RerankOptions]): Optional keyword arguments:
+                - raw_scores (bool, optional): Whether to return raw scores. Defaults to False.
+                - truncate (bool, optional): Whether to truncate the texts. Defaults to False.
+                - truncation_direction (Literal["left", "right"], optional): Direction of truncation. Defaults to "right".
+
+        Returns:
+            List[RerankResult]: A list of dictionaries containing the reranked results.
+                Each dictionary includes:
+                - "index" (int): The original index of the text.
+                - "score" (float): The relevance score.
+
+        Raises:
+            ValueError: If input parameters are invalid or the API returns a client-side error.
+            RuntimeError: If the API call fails or returns a server-side error.
+        """
+        # Validate inputs
+        if not isinstance(query, str) or not query.strip():
+            raise ValueError("Query must be a non-empty string.")
+        if not isinstance(texts, list) or not all(isinstance(text, str) for text in texts):
+            raise ValueError("Texts must be a list of strings.")
+
+        # Construct the request payload
+        payload = {
+            "query": query,
+            "texts": texts,
+            **kwargs,
+        }
+
+        try:
+            # Send POST request to the API using aiohttp
+            async with (
+                aiohttp.ClientSession() as session,
+                session.post(f"{self.base_url}/rerank", json=payload) as response,
+            ):
+                # Handle non-200 status codes
+                if not response.ok:
+                    if "application/json" in response.headers.get("Content-Type", ""):
+                        error_data = await response.json()
+                    else:
+                        error_data = {"error": await response.text(), "error_type": "unexpected_mimetype"}
+                    raise self._map_error_code(response.status, error_data)
+
+                # Parse the JSON response
+                data: List[RerankResult] = await response.json()
+                logger.debug(f"Rerank for `{query}` get {[s['score'] for s in data]}")
+                return data
+
+        except aiohttp.ClientError as e:
+            raise RuntimeError(f"Failed to connect to the API: {e}") from e

{fabricatio-0.2.13.dev0.dist-info → fabricatio-0.2.13.dev2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.13.dev0
+Version: 0.2.13.dev2
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12
@@ -165,6 +165,10 @@ max_tokens = 8192
     ```bash
     make test
     ```
+## TODO
+
+- Add an element based format strategy
+
 
 ## Contributing
 

{fabricatio-0.2.13.dev0.dist-info → fabricatio-0.2.13.dev2.dist-info}/RECORD

@@ -1,26 +1,26 @@
-fabricatio-0.2.13.dev0.dist-info/METADATA,sha256=VF_2f3NYiTYQ_AT0DvnBy42fBBaDCjV-t1XzZn5ts2E,5263
-fabricatio-0.2.13.dev0.dist-info/WHEEL,sha256=jABKVkLC9kJr8mi_er5jOqpiQUjARSLXDUIIxDqsS50,96
-fabricatio-0.2.13.dev0.dist-info/licenses/LICENSE,sha256=do7J7EiCGbq0QPbMAL_FqLYufXpHnCnXBOuqVPwSV8Y,1088
-fabricatio/actions/article.py,sha256=SFl1zc0hz9vW2sW4VJm9-w8E7kLEty-2LzXi9wgWMmE,10905
-fabricatio/actions/article_rag.py,sha256=1VlTFLrtsNfIrfHLEiR0u7eAuZjnIMNtdcj4HbTYMy0,18960
+fabricatio-0.2.13.dev2.dist-info/METADATA,sha256=-Wa7FaGztQxqO0dcMsIB6FNH6w5r4jQi5URaPkevk60,5316
+fabricatio-0.2.13.dev2.dist-info/WHEEL,sha256=jABKVkLC9kJr8mi_er5jOqpiQUjARSLXDUIIxDqsS50,96
+fabricatio-0.2.13.dev2.dist-info/licenses/LICENSE,sha256=do7J7EiCGbq0QPbMAL_FqLYufXpHnCnXBOuqVPwSV8Y,1088
+fabricatio/actions/article.py,sha256=c9HfLM1p0kkdEcQrl8w6Qa5p8riPnkEO--QbNZj88HQ,12562
+fabricatio/actions/article_rag.py,sha256=0J5aeTyHS30bDaQBnxxc8p16oB87hRK_fOgijShWJPA,17797
 fabricatio/actions/fs.py,sha256=gJR14U4ln35nt8Z7OWLVAZpqGaLnED-r1Yi-lX22tkI,959
 fabricatio/actions/output.py,sha256=lX0HkDse3ypCzZgeF-8Dr-EnNFdBiE-WQ1iLPFlGM1g,8302
 fabricatio/actions/rag.py,sha256=KN-OWgcQjGmNgSZ-s5B8m4LpYKSGFJR8eq72mo2CP9k,3592
 fabricatio/actions/rules.py,sha256=dkvCgNDjt2KSO1VgPRsxT4YBmIIMeetZb5tiz-slYkU,3640
 fabricatio/actions/__init__.py,sha256=wVENCFtpVb1rLFxoOFJt9-8smLWXuJV7IwA8P3EfFz4,48
 fabricatio/capabilities/advanced_judge.py,sha256=selB0Gwf1F4gGJlwBiRo6gI4KOUROgh3WnzO3mZFEls,706
-fabricatio/capabilities/advanced_rag.py,sha256=1LAAaCgVnZllNzLH3yW9MNwguUNPB7NMOJbD83VLdAo,2376
+fabricatio/capabilities/advanced_rag.py,sha256=FaXHGOqS4VleGSLsnC5qm4S4EBcHZLZbj8TjXRieKBs,2513
 fabricatio/capabilities/censor.py,sha256=bBT5qy-kp7fh8g4Lz3labSwxwJ60gGd_vrkc6k1cZ1U,4719
 fabricatio/capabilities/check.py,sha256=kYqzohhv2bZfl1aKSUt7a8snT8YEl2zgha_ZdAdMMfQ,8622
 fabricatio/capabilities/correct.py,sha256=W_cInqlciNEhyMK0YI53jk4EvW9uAdge90IO9OElUmA,10420
 fabricatio/capabilities/extract.py,sha256=PMjkWvbsv57IYT7zzd_xbIu4eQqQjpcmBtJzqlWZhHY,2495
 fabricatio/capabilities/propose.py,sha256=hkBeSlmcTdfYWT-ph6nlbtHXBozi_JXqXlWcnBy3W78,2007
-fabricatio/capabilities/rag.py,sha256=a48dEaWE-sniwLhNtGz4xlSmRi_-PdOgDzNaDwnam_g,9619
+fabricatio/capabilities/rag.py,sha256=icJgFwEX4eOlZdtchDaITjFRBrAON6xezyFfPmzehI8,11058
 fabricatio/capabilities/rating.py,sha256=iMtQs3H6vCjuEjiuuz4SRKMVaX7yff7MHWz-slYvi5g,17835
 fabricatio/capabilities/review.py,sha256=-EMZe0ADFPT6fPGmra16UPjJC1M3rAs6dPFdTZ88Fgg,5060
 fabricatio/capabilities/task.py,sha256=uks1U-4LNCUdwdRxAbJJjMc31hOw6jlrcYriuQQfb04,4475
 fabricatio/capabilities/__init__.py,sha256=v1cHRHIJ2gxyqMLNCs6ERVcCakSasZNYzmMI4lqAcls,57
-fabricatio/config.py,sha256=ckm55Oq0IhG1ztwHbKOG-7Mg7uWE1fb_-DxeKZyc8DQ,17951
+fabricatio/config.py,sha256=XoGU5PMqVNW8p_5VD2qE3_g3UpjpSBHUzvjXlgNS0lM,18126
 fabricatio/constants.py,sha256=thfDuF6JEtJ5CHOnAJLfqvn5834n8ep6DH2jc6XGzQM,577
 fabricatio/core.py,sha256=VQ_JKgUGIy2gZ8xsTBZCdr_IP7wC5aPg0_bsOmjQ588,6458
 fabricatio/decorators.py,sha256=RFMYUlQPf561-BIHetpMd7fPig5bZ2brzWiQTgoLOlY,8966
@@ -28,23 +28,23 @@ fabricatio/fs/curd.py,sha256=652nHulbJ3gwt0Z3nywtPMmjhEyglDvEfc3p7ieJNNA,4777
 fabricatio/fs/readers.py,sha256=UXvcJO3UCsxHu9PPkg34Yh55Zi-miv61jD_wZQJgKRs,1751
 fabricatio/fs/__init__.py,sha256=FydmlEY_3QY74r1BpGDc5lFLhE6g6gkwOAtE30Fo-aI,786
 fabricatio/journal.py,sha256=stnEP88aUBA_GmU9gfTF2EZI8FS2OyMLGaMSTgK4QgA,476
-fabricatio/models/action.py,sha256=X7xbun7SyIEpC3-kbJgAagquJGkOBlxhBxbC_sHZX2w,10120
-fabricatio/models/adv_kwargs_types.py,sha256=kUO-SiZtFuz5cZCmMLnJJ9tjQ4-Zd_foo6R8HQMlM5A,1950
+fabricatio/models/action.py,sha256=qxPeOD_nYNN94MzOhCzRDhySZFvM8uoZb_hhA7d_yn4,10609
+fabricatio/models/adv_kwargs_types.py,sha256=IBV3ZcsNLvvEjO_2hBpYg_wLSpNKaMx6Ndam3qXJCw8,2097
 fabricatio/models/events.py,sha256=wiirk_ASg3iXDOZU_gIimci1VZVzWE1nDmxy-hQVJ9M,4150
 fabricatio/models/extra/advanced_judge.py,sha256=INUl_41C8jkausDekkjnEmTwNfLCJ23TwFjq2cM23Cw,1092
-fabricatio/models/extra/aricle_rag.py,sha256=p91JI8FmFSrHVg5KbhJq4w8vQdx4VUW75SrtQUi9ju4,10987
-fabricatio/models/extra/article_base.py,sha256=R8EOlQBs7hadjP9cxG_uc24DJDpiVpJW9Wb9DA6XmXE,14516
+fabricatio/models/extra/aricle_rag.py,sha256=6mkuxNZD_8cdWINmxP8ajmTwdwSH45jcdUSBmY6ZZfQ,11685
+fabricatio/models/extra/article_base.py,sha256=qBkRYAOdrtTnO02G0W1zDDtQWYrQIKot_XyyDaaCLp8,15697
 fabricatio/models/extra/article_essence.py,sha256=mlIkkRMR3I1RtqiiOnmIE3Vy623L4eECumkRzryE1pw,2749
-fabricatio/models/extra/article_main.py,sha256=pwY2bTYlnz8nh8y3nb_8nnYcYCmoed7ejK-ZSD8ocYc,11584
-fabricatio/models/extra/article_outline.py,sha256=C9WNZNSz6gyuw9lDp29qidPvHBTENaeqcHfCoE_Y7F4,2793
+fabricatio/models/extra/article_main.py,sha256=zUkFQRLv6cLoPBbo7H21rrRScjgGv_SzhFd0Y514FsA,11211
+fabricatio/models/extra/article_outline.py,sha256=M4TSrhQ7zGaOcGN91Z-zrhm_IKr8GrPM6uOpK_0JfFI,2789
 fabricatio/models/extra/article_proposal.py,sha256=NbyjW-7UiFPtnVD9nte75re4xL2pD4qL29PpNV4Cg_M,1870
 fabricatio/models/extra/patches.py,sha256=_WNCxtYzzsVfUxI16vu4IqsLahLYRHdbQN9er9tqhC0,997
 fabricatio/models/extra/problem.py,sha256=8tTU-3giFHOi5j7NJsvH__JJyYcaGrcfsRnkzQNm0Ew,7216
 fabricatio/models/extra/rag.py,sha256=RMi8vhEPB0I5mVmjRLRLxYHUnm9pFhvVwysaIwmW2s0,3955
 fabricatio/models/extra/rule.py,sha256=KQQELVhCLUXhEZ35jU3WGYqKHuCYEAkn0p6pxAE-hOU,2625
 fabricatio/models/extra/__init__.py,sha256=XlYnS_2B9nhLhtQkjE7rvvfPmAAtXVdNi9bSDAR-Ge8,54
-fabricatio/models/generic.py,sha256=yXaVyUd3MK0lFUgsT0diMWtgD9s5rM9yKTH44eE58jM,31314
-fabricatio/models/kwargs_types.py,sha256=BPqZUgxz4WJaB7hmvrhNxHXp-O7O4SiAdn6UguBRij8,4784
+fabricatio/models/generic.py,sha256=xk2Q_dADxUIGUuaqahCPTnZ4HwBRD67HCs13ZA5_LnE,31364
+fabricatio/models/kwargs_types.py,sha256=gIvLSof3XE-B0cGE5d1BrOQB1HO8Pd666_scd-9JaF4,5000
 fabricatio/models/role.py,sha256=b8FDRF4VjMMt93Uh5yiAufFbsoH7RcUaaFJAjVmq2l0,2931
 fabricatio/models/task.py,sha256=bLYSKjlRAlb4jMYyF12RTnm_8pVXysSmX8CYLrEmbQ8,11096
 fabricatio/models/tool.py,sha256=jQ51g4lwTPfsMF1nbreDJtBczbxIHoXcPuLSOqHliq8,12506
@@ -56,12 +56,12 @@ fabricatio/rust_instances.py,sha256=Byeo8KHW_dJiXujJq7YPGDLBX5bHNDYbBc4sY3uubVY,
 fabricatio/toolboxes/arithmetic.py,sha256=WLqhY-Pikv11Y_0SGajwZx3WhsLNpHKf9drzAqOf_nY,1369
 fabricatio/toolboxes/fs.py,sha256=l4L1CVxJmjw9Ld2XUpIlWfV0_Fu_2Og6d3E13I-S4aE,736
 fabricatio/toolboxes/__init__.py,sha256=KBJi5OG_pExscdlM7Bnt_UF43j4I3Lv6G71kPVu4KQU,395
-fabricatio/utils.py,sha256=4aK6bNHCCGEbSkLRKrDBzabuVAow9PrJ6SVGUX1Rt-U,3098
+fabricatio/utils.py,sha256=IBKfs2Rg3bJnazzvj1-Fz1rMWNKhiuQG5_rZ1nxQeMI,10299
 fabricatio/workflows/articles.py,sha256=ObYTFUqLUk_CzdmmnX6S7APfxcGmPFqnFr9pdjU7Z4Y,969
 fabricatio/workflows/rag.py,sha256=-YYp2tlE9Vtfgpg6ROpu6QVO8j8yVSPa6yDzlN3qVxs,520
 fabricatio/workflows/__init__.py,sha256=5ScFSTA-bvhCesj3U9Mnmi6Law6N1fmh5UKyh58L3u8,51
 fabricatio/__init__.py,sha256=Rmvq2VgdS2u68vnOi2i5RbeWbAwrJDbk8D8D883PJWE,1022
-fabricatio/rust.cp312-win_amd64.pyd,sha256=DiAJU6I8WeitBZaYiA5q_YL7VlxDGuQ4LcUgyGMuZ9s,4455936
-fabricatio-0.2.13.dev0.data/scripts/tdown.exe,sha256=8UDdHeKT5n45yYe5UsDmBVm-aPveFi-LNUjpx97DNGs,3350528
-fabricatio-0.2.13.dev0.data/scripts/ttm.exe,sha256=epNQ6JY5Rg2M1sR-Vei7OMthswpV1l2oyWr5TyY2aFw,2555392
-fabricatio-0.2.13.dev0.dist-info/RECORD,,
+fabricatio/rust.cp312-win_amd64.pyd,sha256=wOu3NK1TiWnQPmJd_p7QJgVnP91_xrD4AkIzBFbUBhY,4449280
+fabricatio-0.2.13.dev2.data/scripts/tdown.exe,sha256=e7KGiGIaLTHej3keQvWbFbjQGLGstQWBuQkQp3w0uhM,3359232
+fabricatio-0.2.13.dev2.data/scripts/ttm.exe,sha256=OMXhJIJdSO8HuoWtClyLtllDQ2M_06FzeC2nXi7ryMM,2554880
+fabricatio-0.2.13.dev2.dist-info/RECORD,,