fabricatio 0.2.9.dev2__cp312-cp312-win_amd64.whl → 0.2.9.dev4__cp312-cp312-win_amd64.whl

fabricatio/actions/article.py

@@ -2,24 +2,23 @@
 
 from asyncio import gather
 from pathlib import Path
-from typing import Any, Callable, List, Optional
+from typing import Callable, List, Optional
 
 from more_itertools import filter_map
 
 from fabricatio.capabilities.censor import Censor
-from fabricatio.capabilities.correct import Correct
 from fabricatio.capabilities.propose import Propose
 from fabricatio.fs import safe_text_read
 from fabricatio.journal import logger
 from fabricatio.models.action import Action
-from fabricatio.models.extra.article_base import ArticleRefSequencePatch
+from fabricatio.models.extra.article_base import SubSectionBase
 from fabricatio.models.extra.article_essence import ArticleEssence
 from fabricatio.models.extra.article_main import Article
 from fabricatio.models.extra.article_outline import ArticleOutline
 from fabricatio.models.extra.article_proposal import ArticleProposal
 from fabricatio.models.extra.rule import RuleSet
 from fabricatio.models.task import Task
-from fabricatio.rust import BibManager
+from fabricatio.rust import BibManager, detect_language
 from fabricatio.utils import ok
 
 
@@ -53,7 +52,7 @@ class ExtractArticleEssence(Action, Propose):
         for ess in await self.propose(
             ArticleEssence,
             [
-                f"{c}\n\n\nBased the provided academic article above, you need to extract the essence from it."
+                f"{c}\n\n\nBased the provided academic article above, you need to extract the essence from it.\n\nWrite the value string using `{detect_language(c)}`"
                 for c in contents
             ],
         ):
@@ -106,35 +105,30 @@ class GenerateArticleProposal(Action, Propose):
         task_input: Optional[Task] = None,
         article_briefing: Optional[str] = None,
         article_briefing_path: Optional[str] = None,
-        langauge: 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
 
-        proposal = ok(
+        briefing = article_briefing or safe_text_read(
+            ok(
+                article_briefing_path
+                or await self.awhich_pathstr(
+                    f"{ok(task_input).briefing}\nExtract the path of file which contains the article briefing."
+                ),
+                "Could not find the path of file to read.",
+            )
+        )
+
+        logger.info("Start generating the proposal.")
+        return ok(
             await self.propose(
                 ArticleProposal,
-                briefing := (
-                    article_briefing
-                    or safe_text_read(
-                        ok(
-                            article_briefing_path
-                            or await self.awhich_pathstr(
-                                f"{ok(task_input).briefing}\nExtract the path of file which contains the article briefing."
-                            ),
-                            "Could not find the path of file to read.",
-                        )
-                    )
-                ),
+                f"{briefing}\n\nWrite the value string using `{detect_language(briefing)}` as written language.",
             ),
             "Could not generate the proposal.",
         ).update_ref(briefing)
-        if langauge:
-            proposal.language = langauge
-
-        return proposal
 
 
 class GenerateInitialOutline(Action, Propose):
@@ -151,7 +145,8 @@ class GenerateInitialOutline(Action, Propose):
         return ok(
             await self.propose(
                 ArticleOutline,
-                article_proposal.as_prompt(),
+                f"{(article_proposal.as_prompt())}\n\nNote that you should use `{article_proposal.language}` to write the `ArticleOutline`\n"
+                f"You Must make sure every chapter have sections, and every section have subsections.",
             ),
             "Could not generate the initial outline.",
         ).update_ref(article_proposal)
@@ -165,25 +160,33 @@ class FixIntrospectedErrors(Action, Censor):
 
     ruleset: Optional[RuleSet] = None
     """The ruleset to use to fix the introspected errors."""
+    max_error_count: Optional[int] = None
+    """The maximum number of errors to fix."""
 
     async def _execute(
         self,
         article_outline: ArticleOutline,
-        ruleset: Optional[RuleSet] = None,
+        intro_fix_ruleset: Optional[RuleSet] = None,
         **_,
     ) -> Optional[ArticleOutline]:
-        while pack := article_outline.find_introspected():
-            component, err = ok(pack)
-            logger.warning(f"Found introspected error: {err}")
-            corrected = ok(
+        counter = 0
+        origin = article_outline
+        while pack := article_outline.gather_introspected():
+            logger.info(f"Found {counter}th introspected errors")
+            logger.warning(f"Found introspected error: {pack}")
+            article_outline = ok(
                 await self.censor_obj(
-                    component,
-                    ruleset=ok(ruleset or self.ruleset, "No ruleset provided"),
-                    reference=f"# Original Article Outline\n{article_outline.display()}\n# Some Basic errors found from `{component.title}` that need to be fixed\n{err}",
+                    article_outline,
+                    ruleset=ok(intro_fix_ruleset or self.ruleset, "No ruleset provided"),
+                    reference=f"{article_outline.as_prompt()}\n # Fatal Error of the Original Article Outline\n{pack}",
                 ),
                 "Could not correct the component.",
-            )
-            component.update_from(corrected)
+            ).update_ref(origin)
+
+            if self.max_error_count and counter > self.max_error_count:
+                logger.warning("Max error count reached, stopping.")
+                break
+            counter += 1
 
         return article_outline
 
@@ -196,27 +199,36 @@ class FixIllegalReferences(Action, Censor):
 
     ruleset: Optional[RuleSet] = None
     """Ruleset to use to fix the illegal references."""
+    max_error_count: Optional[int] = None
+    """The maximum number of errors to fix."""
 
     async def _execute(
         self,
         article_outline: ArticleOutline,
-        ruleset: Optional[RuleSet] = None,
+        ref_fix_ruleset: Optional[RuleSet] = None,
         **_,
     ) -> Optional[ArticleOutline]:
+        counter = 0
         while pack := article_outline.find_illegal_ref(gather_identical=True):
-            refs, err = ok(pack)
+            logger.info(f"Found {counter}th illegal references")
+            ref_seq, err = ok(pack)
             logger.warning(f"Found illegal referring error: {err}")
-            corrected_ref = ok(
+            new = ok(
                 await self.censor_obj(
-                    refs[0],  # pyright: ignore [reportIndexIssue]
-                    ruleset=ok(ruleset or self.ruleset, "No ruleset provided"),
-                    reference=f"# Original Article Outline\n{article_outline.display()}\n# Some Basic errors found that need to be fixed\n{err}",
-                )
+                    ref_seq[0],
+                    ruleset=ok(ref_fix_ruleset or self.ruleset, "No ruleset provided"),
+                    reference=f"{article_outline.as_prompt()}\n# Some Basic errors found that need to be fixed\n{err}",
+                ),
+                "Could not correct the component",
             )
-            for ref in refs:
-                ref.update_from(corrected_ref)  # pyright: ignore [reportAttributeAccessIssue]
+            for r in ref_seq:
+                r.update_from(new)
+            if self.max_error_count and counter > self.max_error_count:
+                logger.warning("Max error count reached, stopping.")
+                break
+            counter += 1
 
-        return article_outline.update_ref(article_outline)
+        return article_outline
 
 
 class TweakOutlineForwardRef(Action, Censor):
@@ -230,32 +242,36 @@ class TweakOutlineForwardRef(Action, Censor):
     """Ruleset to use to fix the illegal references."""
 
     async def _execute(
-        self, article_outline: ArticleOutline, ruleset: Optional[RuleSet] = None, **cxt
+        self, article_outline: ArticleOutline, ref_twk_ruleset: Optional[RuleSet] = None, **cxt
     ) -> ArticleOutline:
         return await self._inner(
             article_outline,
-            ruleset=ok(ruleset or self.ruleset, "No ruleset provided"),
+            ruleset=ok(ref_twk_ruleset or self.ruleset, "No ruleset provided"),
             field_name="support_to",
         )
 
     async def _inner(self, article_outline: ArticleOutline, ruleset: RuleSet, field_name: str) -> ArticleOutline:
-        for a in article_outline.iter_dfs():
-            if judge := await self.evidently_judge(
-                f"{article_outline.as_prompt()}\n\n{a.display()}\n"
-                f"Does the `{a.__class__.__name__}`'s `{field_name}` field need to be extended or tweaked?"
-            ):
-                patch = ArticleRefSequencePatch.default()
-                patch.tweaked = getattr(a, field_name)
-
-                await self.censor_obj_inplace(
-                    patch,
-                    ruleset=ruleset,
-                    reference=f"{article_outline.as_prompt()}\n"
-                    f"The Article component titled `{a.title}` whose `{field_name}` field needs to be extended or tweaked.\n"
-                    f"# Judgement\n{judge.display()}",
-                )
+        await gather(
+            *[self._loop(a[-1], article_outline, field_name, ruleset) for a in article_outline.iter_subsections()],
+        )
+
         return article_outline
 
+    async def _loop(
+        self, a: SubSectionBase, article_outline: ArticleOutline, field_name: str, ruleset: RuleSet
+    ) -> None:
+        if judge := await self.evidently_judge(
+            f"{article_outline.as_prompt()}\n\n{a.display()}\n"
+            f"Does the `{a.__class__.__name__}`'s `{field_name}` field need to be extended or tweaked?"
+        ):
+            await self.censor_obj_inplace(
+                a,
+                ruleset=ruleset,
+                reference=f"{article_outline.as_prompt()}\n"
+                f"The Article component titled `{a.title}` whose `{field_name}` field needs to be extended or tweaked.\n"
+                f"# Judgement\n{judge.display()}",
+            )
+
 
 class TweakOutlineBackwardRef(TweakOutlineForwardRef):
     """Tweak the backward references in the article outline.
@@ -267,11 +283,11 @@ class TweakOutlineBackwardRef(TweakOutlineForwardRef):
     ruleset: Optional[RuleSet] = None
 
     async def _execute(
-        self, article_outline: ArticleOutline, ruleset: Optional[RuleSet] = None, **cxt
+        self, article_outline: ArticleOutline, ref_twk_ruleset: Optional[RuleSet] = None, **cxt
     ) -> ArticleOutline:
         return await self._inner(
             article_outline,
-            ruleset=ok(ruleset or self.ruleset, "No ruleset provided"),
+            ruleset=ok(ref_twk_ruleset or self.ruleset, "No ruleset provided"),
             field_name="depend_on",
         )
 
@@ -286,7 +302,7 @@ class GenerateArticle(Action, Censor):
     async def _execute(
         self,
         article_outline: ArticleOutline,
-        ruleset: Optional[RuleSet] = None,
+        article_gen_ruleset: Optional[RuleSet] = None,
         **_,
     ) -> Optional[Article]:
         article: Article = Article.from_outline(ok(article_outline, "Article outline not specified.")).update_ref(
@@ -297,51 +313,12 @@ class GenerateArticle(Action, Censor):
             *[
                 self.censor_obj_inplace(
                     subsec,
-                    ruleset=ok(ruleset or self.ruleset, "No ruleset provided"),
-                    reference=f"# Original Article Outline\n{article_outline.display()}\n# Error Need to be fixed\n{err}",
+                    ruleset=ok(article_gen_ruleset or self.ruleset, "No ruleset provided"),
+                    reference=f"{article_outline.as_prompt()}\n# Error Need to be fixed\n{err}\nYou should use `{subsec.language}` to write the new `Subsection`.",
                 )
-                for _, __, subsec in article.iter_subsections()
-                if (err := subsec.introspect())
+                for _, _, subsec in article.iter_subsections()
+                if (err := subsec.introspect()) and logger.warning(f"Found Introspection Error:\n{err}") is None
             ],
-            return_exceptions=True,
         )
 
         return article
-
-
-class CorrectProposal(Action, Censor):
-    """Correct the proposal of the article."""
-
-    output_key: str = "corrected_proposal"
-
-    async def _execute(self, article_proposal: ArticleProposal, **_) -> Any:
-        raise  NotImplementedError("Not implemented.")
-
-
-class CorrectOutline(Action, Correct):
-    """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:
-        raise NotImplementedError("Not implemented.")
-
-
-class CorrectArticle(Action, Correct):
-    """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:
-        raise NotImplementedError("Not implemented.")

fabricatio/actions/article_rag.py

@@ -6,7 +6,7 @@ from typing import Optional
 from fabricatio.capabilities.censor import Censor
 from fabricatio.capabilities.rag import RAG
 from fabricatio.models.action import Action
-from fabricatio.models.extra.article_main import Article, ArticleParagraphSequencePatch, ArticleSubsection
+from fabricatio.models.extra.article_main import Article, ArticleSubsection
 from fabricatio.models.extra.rule import RuleSet
 from fabricatio.utils import ok
 
@@ -29,11 +29,14 @@ class TweakArticleRAG(Action, RAG, Censor):
     ruleset: Optional[RuleSet] = None
     """The ruleset to be used for censoring the article."""
 
+    ref_limit: int = 30
+    """The limit of references to be retrieved"""
+
     async def _execute(
         self,
         article: Article,
         collection_name: str = "article_essence",
-        ruleset: Optional[RuleSet] = None,
+        twk_rag_ruleset: Optional[RuleSet] = None,
         parallel: bool = False,
         **cxt,
     ) -> Optional[Article]:
@@ -45,7 +48,7 @@ class TweakArticleRAG(Action, RAG, Censor):
         Args:
             article (Article): The article to be processed.
             collection_name (str): The name of the collection to view for processing.
-            ruleset (Optional[RuleSet]): The ruleset to apply for censoring. If not provided, the class's ruleset is used.
+            twk_rag_ruleset (Optional[RuleSet]): The ruleset to apply for censoring. If not provided, the class's ruleset is used.
             parallel (bool): If True, process subsections in parallel. Otherwise, process them sequentially.
             **cxt: Additional context parameters.
 
@@ -57,14 +60,14 @@ class TweakArticleRAG(Action, RAG, Censor):
         if parallel:
             await gather(
                 *[
-                    self._inner(article, subsec, ok(ruleset or self.ruleset, "No ruleset provided!"))
+                    self._inner(article, subsec, ok(twk_rag_ruleset or self.ruleset, "No ruleset provided!"))
                     for _, __, subsec in article.iter_subsections()
                 ],
                 return_exceptions=True,
             )
         else:
             for _, __, subsec in article.iter_subsections():
-                await self._inner(article, subsec, ok(ruleset or self.ruleset, "No ruleset provided!"))
+                await self._inner(article, subsec, ok(twk_rag_ruleset or self.ruleset, "No ruleset provided!"))
         return article
 
     async def _inner(self, article: Article, subsec: ArticleSubsection, ruleset: RuleSet) -> None:
@@ -88,13 +91,15 @@ class TweakArticleRAG(Action, RAG, Censor):
                 f"{subsec.display()}\n"
                 f"# Requirement\n"
                 f"Search related articles in the base to find reference candidates, "
-                f"prioritizing both original article language and English usage",
+                f"provide queries in both `English` and `{subsec.language}` can get more accurate results.",
             )
         )
-        patch = ArticleParagraphSequencePatch.default()
-        patch.tweaked = subsec.paragraphs
         await self.censor_obj_inplace(
-            patch,
+            subsec,
             ruleset=ruleset,
-            reference=await self.aretrieve_compact(refind_q, final_limit=30),
+            reference=f"{await self.aretrieve_compact(refind_q, final_limit=self.ref_limit)}\n\n"
+            f"You can use Reference above to rewrite the `{subsec.__class__.__name__}`.\n"
+            f"You should Always use `{subsec.language}` as written language, "
+            f"which is the original language of the `{subsec.title}`. "
+            f"since rewrite a `{subsec.__class__.__name__}` in a different language is usually a bad choice",
         )

fabricatio/actions/output.py

@@ -103,7 +103,7 @@ class RetrieveFromPersistent[T: PersistentAble](Action):
     retrieve_cls: Type[T]
     """The class of the object to retrieve."""
 
-    async def _execute(self, /, **__) -> Optional[T | List[T]]:
+    async def _execute(self, /, **_) -> Optional[T | List[T]]:
         logger.info(f"Retrieve `{self.retrieve_cls.__name__}` from {self.load_path}")
         if not (p := Path(self.load_path)).exists():
             logger.warning(f"Path {self.load_path} does not exist")
@@ -115,12 +115,29 @@ class RetrieveFromPersistent[T: PersistentAble](Action):
         return self.retrieve_cls.from_persistent(self.load_path)
 
 
+class RetrieveFromLatest[T: PersistentAble](RetrieveFromPersistent[T]):
+    """Retrieve the object from the latest persistent file in the dir at `load_path`."""
+
+    async def _execute(self, /, **_) -> Optional[T]:
+        logger.info(f"Retrieve latest `{self.retrieve_cls.__name__}` from {self.load_path}")
+        if not (p := Path(self.load_path)).exists():
+            logger.warning(f"Path {self.load_path} does not exist")
+            return None
+
+        if p.is_dir():
+            logger.info(f"Found directory with {len(list(p.glob('*')))} items")
+            return self.retrieve_cls.from_latest_persistent(self.load_path)
+        logger.error(f"Path {self.load_path} is not a directory")
+        return None
+
+
 class GatherAsList(Action):
     """Gather the objects from the context as a list.
 
     Notes:
         If both `gather_suffix` and `gather_prefix` are specified, only the objects with the suffix will be gathered.
     """
+
     output_key: str = "gathered"
     """Gather the objects from the context as a list."""
     gather_suffix: Optional[str] = None
@@ -129,13 +146,12 @@ class GatherAsList(Action):
     """Gather the objects from the context as a list."""
 
     async def _execute(self, **cxt) -> List[Any]:
-
         if self.gather_suffix is not None:
             result = [cxt[k] for k in cxt if k.endswith(self.gather_suffix)]
             logger.debug(f"Gathered {len(result)} items with suffix {self.gather_suffix}")
             return result
-        if  self.gather_prefix is None:
-            logger.error(err:="Either `gather_suffix` or `gather_prefix` must be specified.")
+        if self.gather_prefix is None:
+            logger.error(err := "Either `gather_suffix` or `gather_prefix` must be specified.")
             raise ValueError(err)
         result = [cxt[k] for k in cxt if k.startswith(self.gather_prefix)]
         logger.debug(f"Gathered {len(result)} items with prefix {self.gather_prefix}")

fabricatio/actions/rules.py

@@ -1,8 +1,9 @@
 """A module containing the DraftRuleSet action."""
 
-from typing import Optional
+from typing import List, Optional
 
 from fabricatio.capabilities.check import Check
+from fabricatio.journal import logger
 from fabricatio.models.action import Action
 from fabricatio.models.extra.rule import RuleSet
 from fabricatio.utils import ok
@@ -18,9 +19,10 @@ class DraftRuleSet(Action, Check):
     """The natural language description of the desired ruleset characteristics."""
     rule_count: int = 0
     """The number of rules to generate in the ruleset (0 for no restriction)."""
+
     async def _execute(
         self,
-        ruleset_requirement: Optional[str]=None,
+        ruleset_requirement: Optional[str] = None,
         **_,
     ) -> Optional[RuleSet]:
         """Draft a ruleset based on the requirement description.
@@ -33,7 +35,38 @@ class DraftRuleSet(Action, Check):
         Returns:
             Optional[RuleSet]: Drafted ruleset object or None if generation fails
         """
-        return await self.draft_ruleset(
-            ruleset_requirement=ok(ruleset_requirement or self.ruleset_requirement,"No ruleset requirement provided"),
+        ruleset = await self.draft_ruleset(
+            ruleset_requirement=ok(ruleset_requirement or self.ruleset_requirement, "No ruleset requirement provided"),
             rule_count=self.rule_count,
         )
+        if ruleset:
+            logger.info(f"Drafted Ruleset length: {len(ruleset.rules)}\n{ruleset.display()}")
+        else:
+            logger.warning(f"Drafting Rule Failed for:\n{ruleset_requirement}")
+        return ruleset
+
+
+class GatherRuleset(Action):
+    """Action to gather a ruleset from a given requirement description."""
+
+    output_key: str = "gathered_ruleset"
+    """The key used to store the drafted ruleset in the context dictionary."""
+
+    to_gather: List[str]
+    """the cxt name of RuleSet to gather"""
+
+    async def _execute(self, **cxt) -> RuleSet:
+        logger.info(f"Gathering Ruleset from {self.to_gather}")
+        # Fix for not_found
+        not_found = next((t for t in self.to_gather if t not in cxt), None)
+        if not_found:
+            raise ValueError(
+                f"Not all required keys found in context: {self.to_gather}|`{not_found}` not found in context."
+            )
+
+        # Fix for invalid RuleSet check
+        invalid = next((t for t in self.to_gather if not isinstance(cxt[t], RuleSet)), None)
+        if invalid is not None:
+            raise TypeError(f"Invalid RuleSet instance for key `{invalid}`")
+
+        return RuleSet.gather(*[cxt[t] for t in self.to_gather])

fabricatio/capabilities/censor.py

@@ -8,6 +8,8 @@ from typing import Optional, Unpack
 
 from fabricatio.capabilities.check import Check
 from fabricatio.capabilities.correct import Correct
+from fabricatio.journal import logger
+from fabricatio.models.extra.problem import Improvement
 from fabricatio.models.extra.rule import RuleSet
 from fabricatio.models.generic import ProposedUpdateAble, SketchedAble
 from fabricatio.models.kwargs_types import ReferencedKwargs
@@ -41,7 +43,11 @@ class Censor(Correct, Check):
         imp = await self.check_obj(obj, ruleset, **override_kwargs(kwargs, default=None))
         if imp is None:
             return None
-        return await self.correct_obj(obj, imp, **kwargs)
+        if not imp:
+            logger.info(f"No improvement found for `{obj.__class__.__name__}`.")
+            return obj
+        logger.info(f'Generated {len(imp)} improvement(s) for `{obj.__class__.__name__}')
+        return await self.correct_obj(obj, Improvement.gather(*imp), **kwargs)
 
     async def censor_string(
         self, input_text: str, ruleset: RuleSet, **kwargs: Unpack[ReferencedKwargs[str]]
@@ -61,8 +67,13 @@ class Censor(Correct, Check):
         """
         imp = await self.check_string(input_text, ruleset, **override_kwargs(kwargs, default=None))
         if imp is None:
-            return imp
-        return await self.correct_string(input_text, imp, **kwargs)
+            logger.warning(f"Censor failed for string:\n{input_text}")
+            return None
+        if not imp:
+            logger.info("No improvement found for string.")
+            return input_text
+        logger.info(f'Generated {len(imp)} improvement(s) for string.')
+        return await self.correct_string(input_text, Improvement.gather(*imp), **kwargs)
 
     async def censor_obj_inplace[M: ProposedUpdateAble](
         self, obj: M, ruleset: RuleSet, **kwargs: Unpack[ReferencedKwargs[M]]
@@ -84,5 +95,10 @@ class Censor(Correct, Check):
         """
         imp = await self.check_obj(obj, ruleset, **override_kwargs(kwargs, default=None))
         if imp is None:
-            return imp
-        return await self.correct_obj_inplace(obj, improvement=imp, **kwargs)
+            logger.warning(f"Censor failed for `{obj.__class__.__name__}`")
+            return None
+        if not imp:
+            logger.info(f"No improvement found for `{obj.__class__.__name__}`.")
+            return obj
+        logger.info(f'Generated {len(imp)} improvement(s) for `{obj.__class__.__name__}')
+        return await self.correct_obj_inplace(obj, improvement=Improvement.gather(*imp), **kwargs)