fabricatio 0.2.8.dev2__cp312-cp312-win_amd64.whl → 0.2.8.dev3__cp312-cp312-win_amd64.whl

fabricatio/_rust.pyi

@@ -171,4 +171,4 @@ class BibManager:
 
         Returns:
             Field value if found, None otherwise
-        """
+        """

fabricatio/actions/article.py

@@ -15,7 +15,8 @@ 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.task import Task
-from fabricatio.models.utils import ok
+from fabricatio.utils import ok
+from more_itertools import filter_map
 
 
 class ExtractArticleEssence(Action):
@@ -32,36 +33,62 @@ class ExtractArticleEssence(Action):
     async def _execute(
         self,
         task_input: Task,
-        reader: Callable[[str], str] = lambda p: Path(p).read_text(encoding="utf-8"),
+        reader: Callable[[str], Optional[str]] = lambda p: Path(p).read_text(encoding="utf-8"),
         **_,
-    ) -> Optional[List[ArticleEssence]]:
+    ) -> List[ArticleEssence]:
         if not task_input.dependencies:
             logger.info(err := "Task not approved, since no dependencies are provided.")
             raise RuntimeError(err)
-
+        logger.info(f"Extracting article essence from {len(task_input.dependencies)} files.")
         # trim the references
-        contents = ["References".join(c.split("References")[:-1]) for c in map(reader, task_input.dependencies)]
-        return await self.propose(ArticleEssence, contents, **self.prepend_sys_msg())
+        contents = list(filter_map(reader, task_input.dependencies))
+        logger.info(f"Read {len(task_input.dependencies)} to get {len(contents)} contents.")
+
+        out = []
+
+        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."
+                    for c in contents
+                ],
+        ):
+            if ess is None:
+                logger.warning("Could not extract article essence")
+            else:
+                out.append(ess)
+        logger.info(f"Extracted {len(out)} article essence from {len(task_input.dependencies)} files.")
+        return out
 
 
 class FixArticleEssence(Action):
     """Fix the article essence based on the bibtex key."""
 
+    output_key: str = "fixed_article_essence"
+    """The key of the output data."""
+
     async def _execute(
         self,
         bib_mgr: BibManager,
         article_essence: List[ArticleEssence],
         **_,
-    ) -> None:
+    ) -> List[ArticleEssence]:
+        out = []
+        count = 0
         for a in article_essence:
             if key := (bib_mgr.get_cite_key(a.title) or bib_mgr.get_cite_key_fuzzy(a.title)):
                 a.title = bib_mgr.get_title_by_key(key) or a.title
                 a.authors = bib_mgr.get_author_by_key(key) or a.authors
                 a.publication_year = bib_mgr.get_year_by_key(key) or a.publication_year
                 a.bibtex_cite_key = key
-                logger.info(f'Updated {a.title} with {key}')
+                logger.info(f"Updated {a.title} with {key}")
+                out.append(a)
             else:
                 logger.warning(f"No key found for {a.title}")
+                count += 1
+        if count:
+            logger.warning(f"{count} articles have no key")
+        return out
 
 
 class GenerateArticleProposal(Action):
@@ -97,7 +124,6 @@ class GenerateArticleProposal(Action):
                         )
                     )
                 ),
-                **self.prepend_sys_msg(),
             ),
             "Could not generate the proposal.",
         ).update_ref(briefing)
@@ -122,7 +148,6 @@ class GenerateInitialOutline(Action):
             await self.propose(
                 ArticleOutline,
                 article_proposal.as_prompt(),
-                **self.prepend_sys_msg(),
             ),
             "Could not generate the initial outline.",
         ).update_ref(article_proposal)
@@ -190,90 +215,81 @@ class FixIllegalReferences(Action):
             "Could not generate the rating manual.",
         )
 
-        while pack := article_outline.find_illegal_ref():
-            ref, err = ok(pack)
+        while pack := article_outline.find_illegal_ref(gather_identical=True):
+            refs, err = ok(pack)
             logger.warning(f"Found illegal referring error: {err}")
-            ok(
-                await self.correct_obj_inplace(
-                    ref,
+            corrected_ref = ok(
+                await self.correct_obj(
+                    refs[0],  # pyright: ignore [reportIndexIssue]
                     reference=f"# Original Article Outline\n{article_outline.display()}\n# Error Need to be fixed\n{err}",
                     topic=ref_topic,
                     rating_manual=ref_manual,
                     supervisor_check=supervisor_check,
                 )
             )
+            for ref in refs:
+                ref.update_from(corrected_ref)  # pyright: ignore [reportAttributeAccessIssue]
+
         return article_outline.update_ref(article_outline)
 
 
-class TweakOutlineBackwardRef(Action, AdvancedJudge):
-    """Tweak the backward references in the article outline.
+class TweakOutlineForwardRef(Action, AdvancedJudge):
+    """Tweak the forward references in the article outline.
 
-    Ensures that the prerequisites of the current chapter are correctly referenced in the `depend_on` field.
+    Ensures that the conclusions of the current chapter effectively support the analysis of subsequent chapters.
     """
 
-    output_key: str = "article_outline_bw_ref_checked"
+    output_key: str = "article_outline_fw_ref_checked"
 
     async def _execute(self, article_outline: ArticleOutline, supervisor_check: bool = False, **cxt) -> ArticleOutline:
-        tweak_depend_on_manual = ok(
-            await self.draft_rating_manual(
-                topic := "Ensure prerequisites are correctly referenced in the `depend_on` field."
-            ),
-            "Could not generate the rating manual.",
+        return await self._inner(
+            article_outline,
+            supervisor_check,
+            topic="Ensure conclusions support the analysis of subsequent chapters, sections or subsections.",
+            field_name="support_to",
         )
 
+    async def _inner(
+        self, article_outline: ArticleOutline, supervisor_check: bool, topic: str, field_name: str
+    ) -> ArticleOutline:
+        tweak_support_to_manual = ok(
+            await self.draft_rating_manual(topic),
+            "Could not generate the rating manual.",
+        )
         for a in article_outline.iter_dfs():
             if await self.evidently_judge(
                 f"{article_outline.as_prompt()}\n\n{a.display()}\n"
-                f"Does the `{a.__class__.__name__}`'s `depend_on` field need to be extended or tweaked?"
+                f"Does the `{a.__class__.__name__}`'s `{field_name}` field need to be extended or tweaked?"
             ):
                 patch = ArticleRefPatch.default()
-                patch.tweaked = a.depend_on
+                patch.tweaked = getattr(a, field_name)
 
                 await self.correct_obj_inplace(
                     patch,
                     topic=topic,
-                    reference=f"{article_outline.as_prompt()}\nThe Article component whose `depend_on` field needs to be extended or tweaked",
-                    rating_manual=tweak_depend_on_manual,
+                    reference=f"{article_outline.as_prompt()}\nThe Article component whose `{field_name}` field needs to be extended or tweaked",
+                    rating_manual=tweak_support_to_manual,
                     supervisor_check=supervisor_check,
                 )
-
         return article_outline
 
 
-class TweakOutlineForwardRef(Action, AdvancedJudge):
-    """Tweak the forward references in the article outline.
+class TweakOutlineBackwardRef(TweakOutlineForwardRef):
+    """Tweak the backward references in the article outline.
 
-    Ensures that the conclusions of the current chapter effectively support the analysis of subsequent chapters.
+    Ensures that the prerequisites of the current chapter are correctly referenced in the `depend_on` field.
     """
 
-    output_key: str = "article_outline_fw_ref_checked"
+    output_key: str = "article_outline_bw_ref_checked"
 
     async def _execute(self, article_outline: ArticleOutline, supervisor_check: bool = False, **cxt) -> ArticleOutline:
-        tweak_support_to_manual = ok(
-            await self.draft_rating_manual(
-                topic := "Ensure conclusions support the analysis of subsequent chapters, sections or subsections."
-            ),
-            "Could not generate the rating manual.",
+        return await self._inner(
+            article_outline,
+            supervisor_check,
+            topic="Ensure the dependencies of the current chapter are neither abused nor missing.",
+            field_name="depend_on",
         )
 
-        for a in article_outline.iter_dfs():
-            if await self.evidently_judge(
-                f"{article_outline.as_prompt()}\n\n{a.display()}\n"
-                f"Does the `{a.__class__.__name__}`'s `support_to` field need to be extended or tweaked?"
-            ):
-                patch = ArticleRefPatch.default()
-                patch.tweaked = a.support_to
-
-                await self.correct_obj_inplace(
-                    patch,
-                    topic=topic,
-                    reference=f"{article_outline.as_prompt()}\nThe Article component whose `support_to` field needs to be extended or tweaked",
-                    rating_manual=tweak_support_to_manual,
-                    supervisor_check=supervisor_check,
-                )
-
-        return article_outline
-
 
 class GenerateArticle(Action):
     """Generate the article based on the outline."""

fabricatio/actions/article_rag.py

@@ -6,7 +6,7 @@ from typing import Dict, Optional
 from fabricatio.capabilities.rag import RAG
 from fabricatio.models.action import Action
 from fabricatio.models.extra.article_main import Article, ArticleParagraphPatch, ArticleSubsection
-from fabricatio.models.utils import ok
+from fabricatio.utils import ok
 
 
 class TweakArticleRAG(Action, RAG):
@@ -25,7 +25,8 @@ class TweakArticleRAG(Action, RAG):
         "Single author: 'Author1 (YYYY)'"
         "Multiple citations: 'Author1 (YYYY), Author2 (YYYY)'"
         "Prioritize formulas from reference highlights."
-        "Specify authors/years only - no numeric citations"
+        "Specify authors/years only."
+        "You can create numeric citation numbers for article whose `bibtex_cite_key` is 'wangWind2024' by using notation like `#cite(<wangWind2024>)`."
         "Paragraphs must exceed 2-3 sentences",
         supervisor_check: bool = False,
         parallel: bool = False,
@@ -41,9 +42,7 @@ class TweakArticleRAG(Action, RAG):
             criteria_count=13,
         )
 
-        tweak_manual = ok(
-            await self.draft_rating_manual(topic, criteria=criteria, co_extractor={"model": "openai/qwen-max"})
-        )
+        tweak_manual = ok(await self.draft_rating_manual(topic, criteria=criteria))
         self.view(collection_name)
 
         if parallel:

fabricatio/actions/output.py

@@ -7,7 +7,7 @@ from fabricatio.journal import logger
 from fabricatio.models.action import Action
 from fabricatio.models.generic import FinalizedDumpAble, PersistentAble
 from fabricatio.models.task import Task
-from fabricatio.models.utils import ok
+from fabricatio.utils import ok
 
 
 class DumpFinalizedOutput(Action):
@@ -67,17 +67,18 @@ class PersistentAll(Action):
 
         for k, v in cxt.items():
             final_dir = persist_dir.joinpath(k)
-            final_dir.mkdir(parents=True, exist_ok=True)
             if isinstance(v, PersistentAble):
+                final_dir.mkdir(parents=True, exist_ok=True)
                 v.persist(final_dir)
                 count += 1
             if isinstance(v, Iterable) and any(
                 persistent_ables := (pers for pers in v if isinstance(pers, PersistentAble))
             ):
+                final_dir.mkdir(parents=True, exist_ok=True)
                 for per in persistent_ables:
                     per.persist(final_dir)
                     count += 1
-
+        logger.info(f"Persisted {count} objects to {persist_dir}")
         return count
 
 

fabricatio/actions/rag.py

@@ -5,7 +5,7 @@ from typing import List, Optional
 from fabricatio.capabilities.rag import RAG
 from fabricatio.journal import logger
 from fabricatio.models.action import Action
-from fabricatio.models.generic import PrepareVectorization
+from fabricatio.models.generic import Vectorizable
 from fabricatio.models.task import Task
 from questionary import text
 
@@ -15,7 +15,7 @@ class InjectToDB(Action, RAG):
 
     output_key: str = "collection_name"
 
-    async def _execute[T: PrepareVectorization](
+    async def _execute[T: Vectorizable](
         self, to_inject: Optional[T] | List[Optional[T]], collection_name: str = "my_collection",override_inject:bool=False, **_
     ) -> Optional[str]:
         if not isinstance(to_inject, list):
@@ -27,7 +27,7 @@ class InjectToDB(Action, RAG):
             [
                 t.prepare_vectorization(self.embedding_max_sequence_length)
                 for t in to_inject
-                if isinstance(t, PrepareVectorization)
+                if isinstance(t, Vectorizable)
             ],
         )
 

fabricatio/capabilities/check.py

@@ -0,0 +1,97 @@
+"""A class that provides the capability to check strings and objects against rules and guidelines."""
+from typing import Optional, Unpack
+
+from fabricatio import TEMPLATE_MANAGER
+from fabricatio.capabilities.advanced_judge import AdvancedJudge
+from fabricatio.capabilities.propose import Propose
+from fabricatio.config import configs
+from fabricatio.models.extra.problem import Improvement
+from fabricatio.models.extra.rule import Rule, RuleSet
+from fabricatio.models.generic import Display, WithBriefing
+from fabricatio.models.kwargs_types import ValidateKwargs
+from fabricatio.utils import override_kwargs
+
+
+class Check(AdvancedJudge, Propose):
+    """Class that provides the capability to validate strings/objects against predefined rules and guidelines."""
+
+    async def draft_ruleset(
+        self, ruleset_requirement: str, **kwargs: Unpack[ValidateKwargs[RuleSet]]
+    ) -> Optional[RuleSet]:
+        """Generate a rule set based on specified requirements.
+
+        Args:
+            ruleset_requirement (str): Description of desired rule set characteristics
+            **kwargs: Validation configuration parameters
+
+        Returns:
+            Optional[RuleSet]: Generated rule set if successful
+        """
+        return await self.propose(RuleSet, ruleset_requirement, **kwargs)
+
+    async def draft_rule(self, rule_requirement: str, **kwargs: Unpack[ValidateKwargs[Rule]]) -> Optional[Rule]:
+        """Create a specific rule based on given specifications.
+
+        Args:
+            rule_requirement (str): Detailed rule description requirements
+            **kwargs: Validation configuration parameters
+
+        Returns:
+            Optional[Rule]: Generated rule instance if successful
+        """
+        return await self.propose(Rule, rule_requirement, **kwargs)
+
+    async def check_string(
+        self,
+        input_text: str,
+        rule: Rule,
+        **kwargs: Unpack[ValidateKwargs[Improvement]],
+    ) -> Optional[Improvement]:
+        """Evaluate text against a specific rule.
+
+        Args:
+            input_text (str): Text content to be evaluated
+            rule (Rule): Rule instance used for validation
+            **kwargs: Validation configuration parameters
+
+        Returns:
+            Optional[Improvement]: Suggested improvement if violations found, else None
+        """
+        if judge := await self.evidently_judge(
+            f"# Content to exam\n{input_text}\n\n# Rule Must to follow\n{rule.display()}\nDoes `Content to exam` provided above violate the `Rule Must to follow` provided above?",
+            **override_kwargs(kwargs, default=None),
+        ):
+            return await self.propose(
+                Improvement,
+                TEMPLATE_MANAGER.render_template(
+                    configs.templates.check_string_template,
+                    {"to_check": input_text, "rule": rule, "judge": judge.display()},
+                ),
+                **kwargs,
+            )
+        return None
+
+    async def check_obj[M: (Display, WithBriefing)](
+        self,
+        obj: M,
+        rule: Rule,
+        **kwargs: Unpack[ValidateKwargs[Improvement]],
+    ) -> Optional[Improvement]:
+        """Validate an object against specified rule.
+
+        Args:
+            obj (M): Object implementing Display or WithBriefing interface
+            rule (Rule): Validation rule to apply
+            **kwargs: Validation configuration parameters
+
+        Returns:
+            Optional[Improvement]: Improvement suggestion if issues detected
+        """
+        if isinstance(obj, Display):
+            input_text = obj.display()
+        elif isinstance(obj, WithBriefing):
+            input_text = obj.briefing
+        else:
+            raise TypeError("obj must be either Display or WithBriefing")
+
+        return await self.check_string(input_text, rule, **kwargs)

fabricatio/capabilities/correct.py

@@ -8,8 +8,9 @@ based on predefined criteria and templates.
 from typing import Optional, Unpack, cast
 
 from fabricatio._rust_instances import TEMPLATE_MANAGER
-from fabricatio.capabilities.review import Review, ReviewResult
+from fabricatio.capabilities.review import Review
 from fabricatio.config import configs
+from fabricatio.models.extra.problem import Improvement
 from fabricatio.models.generic import CensoredAble, Display, ProposedAble, ProposedUpdateAble, WithBriefing
 from fabricatio.models.kwargs_types import CensoredCorrectKwargs, CorrectKwargs, ReviewKwargs
 from fabricatio.models.task import Task
@@ -31,7 +32,7 @@ class Correct(Review):
         obj: M,
         reference: str = "",
         supervisor_check: bool = True,
-        **kwargs: Unpack[ReviewKwargs[ReviewResult[str]]],
+        **kwargs: Unpack[ReviewKwargs[Improvement]],
     ) -> Optional[M]:
         """Review and correct an object based on defined criteria and templates.
 
@@ -71,7 +72,7 @@ class Correct(Review):
         )
 
     async def correct_string(
-        self, input_text: str, supervisor_check: bool = True, **kwargs: Unpack[ReviewKwargs[ReviewResult[str]]]
+        self, input_text: str, supervisor_check: bool = True, **kwargs: Unpack[ReviewKwargs[Improvement]]
     ) -> Optional[str]:
         """Review and correct a string based on defined criteria and templates.
 
@@ -100,7 +101,7 @@ class Correct(Review):
         )
 
     async def correct_task[T](
-        self, task: Task[T], **kwargs: Unpack[CorrectKwargs[ReviewResult[str]]]
+        self, task: Task[T], **kwargs: Unpack[CorrectKwargs[Improvement]]
     ) -> Optional[Task[T]]:
         """Review and correct a task object based on defined criteria.
 
@@ -117,7 +118,7 @@ class Correct(Review):
         return await self.correct_obj(task, **kwargs)
 
     async def censor_obj[M: CensoredAble](
-        self, obj: M, **kwargs: Unpack[CensoredCorrectKwargs[ReviewResult[str]]]
+        self, obj: M, **kwargs: Unpack[CensoredCorrectKwargs[Improvement]]
     ) -> M:
         """Censor and correct an object based on defined criteria and templates.
 
@@ -147,7 +148,7 @@ class Correct(Review):
         return modified_obj or last_modified_obj
 
     async def correct_obj_inplace[M: ProposedUpdateAble](
-        self, obj: M, **kwargs: Unpack[CorrectKwargs[ReviewResult[str]]]
+        self, obj: M, **kwargs: Unpack[CorrectKwargs[Improvement]]
     ) -> Optional[M]:
         """Correct an object in place based on defined criteria and templates.
 

fabricatio/capabilities/propose.py

@@ -10,28 +10,43 @@ from fabricatio.models.usages import LLMUsage
 class Propose(LLMUsage):
     """A class that proposes an Obj based on a prompt."""
 
+    @overload
+    async def propose[M: ProposedAble](
+        self,
+        cls: Type[M],
+        prompt: List[str],
+        **kwargs: Unpack[ValidateKwargs[None]],
+    ) -> List[Optional[M]]: ...
+
     @overload
     async def propose[M: ProposedAble](
         self,
         cls: Type[M],
         prompt: List[str],
         **kwargs: Unpack[ValidateKwargs[M]],
-    ) -> Optional[List[M]]: ...
+    ) -> List[M]: ...
 
     @overload
     async def propose[M: ProposedAble](
         self,
         cls: Type[M],
         prompt: str,
-        **kwargs: Unpack[ValidateKwargs[M]],
+        **kwargs: Unpack[ValidateKwargs[None]],
     ) -> Optional[M]: ...
+    @overload
+    async def propose[M: ProposedAble](
+        self,
+        cls: Type[M],
+        prompt: str,
+        **kwargs: Unpack[ValidateKwargs[M]],
+    ) -> M: ...
 
     async def propose[M: ProposedAble](
         self,
         cls: Type[M],
         prompt: List[str] | str,
-        **kwargs: Unpack[ValidateKwargs[M]],
-    ) -> Optional[List[M] | M]:
+        **kwargs: Unpack[ValidateKwargs[Optional[M]]],
+    ) -> Optional[M] | List[Optional[M]] | M | List[M]:
         """Asynchronously proposes a task based on a given prompt and parameters.
 
         Parameters:
@@ -47,3 +62,4 @@ class Propose(LLMUsage):
             validator=cls.instantiate_from_string,
             **kwargs,
         )
+

fabricatio/capabilities/rag.py

@@ -22,7 +22,8 @@ from fabricatio.models.kwargs_types import (
     RetrievalKwargs,
 )
 from fabricatio.models.usages import EmbeddingUsage
-from fabricatio.models.utils import MilvusData, ok
+from fabricatio.models.utils import MilvusData
+from fabricatio.utils import ok
 from more_itertools.recipes import flatten, unique
 from pydantic import Field, PrivateAttr
 
@@ -376,7 +377,7 @@ class RAG(EmbeddingUsage):
         Returns:
             List[str]: A list of refined questions.
         """
-        return await self.aliststr(
+        return await self.alist_str(
             TEMPLATE_MANAGER.render_template(
                 configs.templates.refined_query_template,
                 {"question": [question] if isinstance(question, str) else question},

fabricatio/capabilities/rating.py

@@ -7,16 +7,15 @@ from typing import Dict, List, Optional, Set, Tuple, Union, Unpack, overload
 from fabricatio._rust_instances import TEMPLATE_MANAGER
 from fabricatio.config import configs
 from fabricatio.journal import logger
-from fabricatio.models.generic import WithBriefing
 from fabricatio.models.kwargs_types import ValidateKwargs
 from fabricatio.models.usages import LLMUsage
-from fabricatio.models.utils import override_kwargs
 from fabricatio.parser import JsonCapture
+from fabricatio.utils import override_kwargs
 from more_itertools import flatten, windowed
 from pydantic import NonNegativeInt, PositiveInt
 
 
-class Rating(WithBriefing, LLMUsage):
+class Rating(LLMUsage):
     """A class that provides functionality to rate tasks based on a rating manual and score range.
 
     References:
@@ -149,9 +148,7 @@ class Rating(WithBriefing, LLMUsage):
                 return json_data
             return None
 
-        criteria = criteria or await self.draft_rating_criteria(
-            topic, **self.prepend_sys_msg(override_kwargs(dict(kwargs), default=None))
-        )
+        criteria = criteria or await self.draft_rating_criteria(topic, **override_kwargs(dict(kwargs), default=None))
 
         if criteria is None:
             logger.error(f"Failed to draft rating criteria for topic {topic}")
@@ -168,7 +165,7 @@ class Rating(WithBriefing, LLMUsage):
                 )
             ),
             validator=_validator,
-            **self.prepend_sys_msg(kwargs),
+            **kwargs,
         )
 
     async def draft_rating_criteria(
@@ -200,7 +197,7 @@ class Rating(WithBriefing, LLMUsage):
             validator=lambda resp: set(out)
             if (out := JsonCapture.validate_with(resp, list, str, criteria_count)) is not None
             else out,
-            **self.prepend_sys_msg(kwargs),
+            **kwargs,
         )
 
     async def draft_rating_criteria_from_examples(
@@ -253,7 +250,7 @@ class Rating(WithBriefing, LLMUsage):
                 validator=lambda resp: JsonCapture.validate_with(
                     resp, target_type=list, elements_type=str, length=reasons_count
                 ),
-                **self.prepend_sys_msg(kwargs),
+                **kwargs,
             )
         )
         # extract certain mount of criteria from reasons according to their importance and frequency
@@ -310,7 +307,7 @@ class Rating(WithBriefing, LLMUsage):
                 for pair in windows
             ],
             validator=lambda resp: JsonCapture.validate_with(resp, target_type=float),
-            **self.prepend_sys_msg(kwargs),
+            **kwargs,
         )
         weights = [1]
         for rw in relative_weights: