fabricatio 0.2.8.dev2__tar.gz → 0.2.8.dev3__tar.gz

{fabricatio-0.2.8.dev2 → fabricatio-0.2.8.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.8.dev2
+Version: 0.2.8.dev3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12
@@ -23,6 +23,7 @@ Requires-Dist: pymitter>=1.0.0
 Requires-Dist: questionary>=2.1.0
 Requires-Dist: regex>=2024.11.6
 Requires-Dist: rich>=13.9.4
+Requires-Dist: rtoml>=0.12.0
 Requires-Dist: pymilvus>=2.5.4 ; extra == 'rag'
 Requires-Dist: fabricatio[calc,plot,rag] ; extra == 'full'
 Requires-Dist: sympy>=1.13.3 ; extra == 'calc'

{fabricatio-0.2.8.dev2 → fabricatio-0.2.8.dev3}/examples/extract_and_inject/ask.py

@@ -4,7 +4,7 @@ import asyncio
 
 from fabricatio import RAG, Action, Role, Task, WorkFlow, logger
 from fabricatio.models.events import Event
-from fabricatio.models.utils import ok
+from fabricatio.utils import ok
 from questionary import text
 
 

fabricatio-0.2.8.dev3/examples/extract_and_inject/extract_and_inject.py

@@ -0,0 +1,66 @@
+"""Example of proposing a task to a role."""
+
+import asyncio
+from typing import Optional
+
+from fabricatio import BibManager, Event, Role, Task, WorkFlow, logger
+from fabricatio.actions.article import ExtractArticleEssence, FixArticleEssence
+from fabricatio.actions.output import PersistentAll
+from fabricatio.actions.rag import InjectToDB
+from fabricatio.fs import safe_text_read
+from fabricatio.fs.curd import gather_files
+from litellm.utils import token_counter
+
+MAX_TOKEN = 64000
+
+
+def _reader(path:str)->Optional[str]:
+    string=safe_text_read(path)
+    string=string.split("References\n")[0]
+    string=string.split("参考文献\n")[0]
+    if (leng:=token_counter(text=string))> MAX_TOKEN:
+        logger.warning(f'{path} is too long, got {leng} tokens, skip.')
+        return None
+    logger.info(f'Read {path} get {leng} tokens.')
+    return string
+async def main() -> None:
+    """Main function."""
+    Role(
+        name="Researcher",
+        description="Extract article essence",
+        llm_model="openai/deepseek-v3-250324",
+        registry={
+            Event.quick_instantiate("article"): WorkFlow(
+                name="extract",
+                steps=(
+                    ExtractArticleEssence(output_key="article_essence"),
+                    FixArticleEssence(output_key="to_inject"),
+                    PersistentAll,
+                    InjectToDB(output_key="task_output"),
+                ),
+            ).update_init_context(
+                override_inject=True,
+                collection_name="article_essence_0324",
+                persist_dir="output_0324",
+                bib_mgr=BibManager("ref.bib"),
+                reader=_reader
+            )
+        },
+    )
+
+    task: Task[str] = Task(
+        name="Extract Article Essence",
+        description="Extract the essence of the article from the files in './bpdf_out'",
+        dependencies=gather_files("bpdf_out", "md"),
+    )
+
+    col_name = await task.delegate("article")
+
+    if col_name is None:
+        logger.error("No essence found")
+        return
+    logger.success(f"Injected to collection: {col_name}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

{fabricatio-0.2.8.dev2 → fabricatio-0.2.8.dev3}/examples/write_article/write_article.py

@@ -25,9 +25,9 @@ async def main() -> None:
         description="Write an outline for an article in typst format.",
         llm_top_p=0.8,
         llm_temperature=1.15,
-        llm_model="openai/qwen-max",
+        llm_model="openai/deepseek-v3-250324",
         llm_rpm=1000,
-        llm_tpm=10000000,
+        llm_tpm=1000000,
         llm_max_tokens=8190,
         registry={
             Event.quick_instantiate(ns := "article"): WorkFlow(
@@ -35,7 +35,7 @@ async def main() -> None:
                 description="Generate an outline for an article. dump the outline to the given path. in typst format.",
                 steps=(
                     GenerateArticleProposal(llm_temperature=1.18),
-                    GenerateInitialOutline(output_key="article_outline",llm_temperature=1.21, llm_top_p=0.3),
+                    GenerateInitialOutline(output_key="article_outline",llm_temperature=1.21, llm_top_p=0.5),
                     FixIntrospectedErrors(output_key="article_outline"),
                     FixIllegalReferences(output_key="article_outline"),
                     TweakOutlineBackwardRef(output_key="article_outline"),

{fabricatio-0.2.8.dev2 → fabricatio-0.2.8.dev3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fabricatio"
-version = "0.2.8-dev2"
+version = "0.2.8-dev3"
 description = "A LLM multi-agent framework."
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -42,6 +42,7 @@ dependencies = [
     "questionary>=2.1.0",
     "regex>=2024.11.6",
     "rich>=13.9.4",
+    "rtoml>=0.12.0",
 ]
 
 [project.urls]

{fabricatio-0.2.8.dev2 → fabricatio-0.2.8.dev3}/python/fabricatio/_rust.pyi

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

{fabricatio-0.2.8.dev2 → fabricatio-0.2.8.dev3}/python/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-0.2.8.dev2 → fabricatio-0.2.8.dev3}/python/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-0.2.8.dev2 → fabricatio-0.2.8.dev3}/python/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-0.2.8.dev2 → fabricatio-0.2.8.dev3}/python/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-0.2.8.dev3/python/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-0.2.8.dev2 → fabricatio-0.2.8.dev3}/python/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-0.2.8.dev2 → fabricatio-0.2.8.dev3}/python/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,
         )
+