fabricatio 0.2.8.dev4__cp312-cp312-manylinux_2_34_x86_64.whl → 0.2.9__cp312-cp312-manylinux_2_34_x86_64.whl

fabricatio/__init__.py

@@ -1,10 +1,6 @@
 """Fabricatio is a Python library for building llm app using event-based agent structure."""
 
-from importlib.util import find_spec
-
-from fabricatio import actions, toolboxes, workflows
-from fabricatio._rust import BibManager
-from fabricatio._rust_instances import TEMPLATE_MANAGER
+from fabricatio import actions, capabilities, toolboxes, workflows
 from fabricatio.core import env
 from fabricatio.journal import logger
 from fabricatio.models import extra
@@ -14,6 +10,8 @@ from fabricatio.models.role import Role
 from fabricatio.models.task import Task
 from fabricatio.models.tool import ToolBox
 from fabricatio.parser import Capture, GenericCapture, JsonCapture, PythonCapture
+from fabricatio.rust import BibManager
+from fabricatio.rust_instances import TEMPLATE_MANAGER
 
 __all__ = [
     "TEMPLATE_MANAGER",
@@ -29,15 +27,10 @@ __all__ = [
     "ToolBox",
     "WorkFlow",
     "actions",
+    "capabilities",
     "env",
     "extra",
     "logger",
     "toolboxes",
     "workflows",
 ]
-
-
-if find_spec("pymilvus"):
-    from fabricatio.capabilities.rag import RAG
-
-    __all__ += ["RAG"]

fabricatio/actions/__init__.py

@@ -0,0 +1 @@
+"""A module containing some builtin actins."""

fabricatio/actions/article.py

@@ -2,24 +2,24 @@
 
 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._rust import BibManager
 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 ArticleRef, 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, detect_language
 from fabricatio.utils import ok
-from more_itertools import filter_map
 
 
 class ExtractArticleEssence(Action, Propose):
@@ -52,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
             ],
         ):
@@ -105,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):
@@ -147,10 +142,17 @@ class GenerateInitialOutline(Action, Propose):
         article_proposal: ArticleProposal,
         **_,
     ) -> Optional[ArticleOutline]:
+        raw_outline = await self.aask(
+            f"{(article_proposal.as_prompt())}\n\nNote that you should use `{article_proposal.language}` to write the `ArticleOutline`\n"
+            f"Design each chapter of a proper and academic and ready for release manner.\n"
+            f"You Must make sure every chapter have sections, and every section have subsections.\n"
+            f"Make the chapter and sections and subsections bing divided into a specific enough article component.",
+        )
+
         return ok(
             await self.propose(
                 ArticleOutline,
-                article_proposal.as_prompt(),
+                f'{raw_outline}\n\n\n\noutline provided above is the outline i need to extract to a JSON,'
             ),
             "Could not generate the initial outline.",
         ).update_ref(article_proposal)
@@ -164,25 +166,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.display()}\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
 
@@ -195,27 +205,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]:
-        while pack := article_outline.find_illegal_ref(gather_identical=True):
-            refs, err = ok(pack)
-            logger.warning(f"Found illegal referring error: {err}")
-            corrected_ref = 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}",
-                )
+        counter = 0
+        while pack := article_outline.find_illegal_ref():
+            logger.info(f"Found {counter}th illegal references")
+            cmp, ref, err = ok(pack)
+            logger.warning(f"Found illegal referring error: {err}\n\n{cmp.display()}")
+            new = ok(
+                await self.censor_obj_inplace(
+                    cmp,
+                    ruleset=ok(ref_fix_ruleset or self.ruleset, "No ruleset provided"),
+                    reference=f"{article_outline.as_prompt()}\n# `ArticleRef` usage doc\n{ArticleRef.__doc__}\n# Invalid `ArticleRef`\n```json\n{ref}```\n\n# Some Ref errors found that need to be fixed for the `ArticleRef`\n{err}",
+                ),
+                "Could not correct the component",
             )
-            for ref in refs:
-                ref.update_from(corrected_ref)  # pyright: ignore [reportAttributeAccessIssue]
 
-        return article_outline.update_ref(article_outline)
+            logger.info(f"Applying correction:\n{new.display()}")
+            if self.max_error_count and counter > self.max_error_count:
+                logger.warning("Max error count reached, stopping.")
+                break
+            counter += 1
+
+        return article_outline
 
 
 class TweakOutlineForwardRef(Action, Censor):
@@ -229,32 +248,40 @@ 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 gather(
+            *[self._loop(a[-1], article_outline, field_name, ruleset) for a in article_outline.iter_subsections()],
+        )
 
-                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()}",
-                )
         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"# `ArticleRef` usage doc\n{ArticleRef.__doc__}\n"
+            f"# Ruleset\n{ruleset.display()}\n"
+            f"Does the `{a.__class__.__name__}`'s `{field_name}` field contains inappropriate ref that obviously violated the ruleset provided?\n"
+            f"true for it does violated, false for it does not violated."
+        ):
+            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 tweaked.\n"
+                f"# `ArticleRef` usage doc\n{ArticleRef.__doc__}\n"
+                f"# Judgement\n{judge.display()}",
+            )
+
 
 class TweakOutlineBackwardRef(TweakOutlineForwardRef):
     """Tweak the backward references in the article outline.
@@ -266,11 +293,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",
         )
 
@@ -285,7 +312,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(
@@ -296,51 +323,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# `ArticleRef` usage doc\n{ArticleRef.__doc__}# 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

@@ -1,7 +1,7 @@
 """Dump the finalized output to a file."""
 
 from pathlib import Path
-from typing import Iterable, List, Optional, Type
+from typing import Any, Iterable, List, Optional, Type
 
 from fabricatio.journal import logger
 from fabricatio.models.action import Action
@@ -33,6 +33,7 @@ class DumpFinalizedOutput(Action):
                 "Could not find the path of file to dump the data.",
             )
         )
+        logger.info(f"Saving output to {dump_path.as_posix()}")
         ok(to_dump, "Could not dump the data since the path is not specified.").finalized_dump_to(dump_path)
         return dump_path.as_posix()
 
@@ -41,7 +42,11 @@ class PersistentAll(Action):
     """Persist all the data to a file."""
 
     output_key: str = "persistent_count"
+    """The number of objects persisted."""
     persist_dir: Optional[str] = None
+    """The directory to persist the data."""
+    override: bool = False
+    """Whether to remove the existing dir before dumping."""
 
     async def _execute(
         self,
@@ -64,16 +69,22 @@ class PersistentAll(Action):
         if persist_dir.is_file():
             logger.warning("Dump should be a directory, but it is a file. Skip dumping.")
             return count
-
+        if self.override and persist_dir.is_dir():
+            logger.info(f"Override the existing directory {persist_dir.as_posix()}.")
+            persist_dir.rmdir()
+        logger.info(f"Starting persistence in directory {persist_dir}")
         for k, v in cxt.items():
             final_dir = persist_dir.joinpath(k)
+            logger.debug(f"Checking key {k} for persistence")
             if isinstance(v, PersistentAble):
+                logger.info(f"Persisting object {k} to {final_dir}")
                 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))
             ):
+                logger.info(f"Persisting collection {k} to {final_dir}")
                 final_dir.mkdir(parents=True, exist_ok=True)
                 for per in persistent_ables:
                     per.persist(final_dir)
@@ -92,11 +103,56 @@ class RetrieveFromPersistent[T: PersistentAble](Action):
     retrieve_cls: Type[T]
     """The class of the object to retrieve."""
 
-    async def _execute(self, /, **__) -> Optional[T | List[T]]:
-        logger.info(f"Retrieve `{self.retrieve_cls.__name__}` from persistent file: {self.load_path}")
+    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")
             return None
 
         if p.is_dir():
+            logger.info(f"Found directory with {len(list(p.glob('*')))} items")
             return [self.retrieve_cls.from_persistent(per) for per in p.glob("*")]
         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
+    """Gather the objects from the context as a list."""
+    gather_prefix: Optional[str] = None
+    """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.")
+            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}")
+        return result

fabricatio/actions/rag.py

@@ -2,12 +2,13 @@
 
 from typing import List, Optional
 
+from questionary import text
+
 from fabricatio.capabilities.rag import RAG
 from fabricatio.journal import logger
 from fabricatio.models.action import Action
 from fabricatio.models.generic import Vectorizable
 from fabricatio.models.task import Task
-from questionary import text
 
 
 class InjectToDB(Action, RAG):

fabricatio/actions/rules.py

@@ -0,0 +1,72 @@
+"""A module containing the DraftRuleSet action."""
+
+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
+
+
+class DraftRuleSet(Action, Check):
+    """Action to draft a ruleset based on a given requirement description."""
+
+    output_key: str = "drafted_ruleset"
+    """The key used to store the drafted ruleset in the context dictionary."""
+
+    ruleset_requirement: Optional[str] = None
+    """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,
+        **_,
+    ) -> Optional[RuleSet]:
+        """Draft a ruleset based on the requirement description.
+
+        Args:
+            ruleset_requirement (str): Natural language description of desired ruleset characteristics
+            rule_count (int): Number of rules to generate (0 for no restriction)
+            **kwargs: Validation parameters for rule generation
+
+        Returns:
+            Optional[RuleSet]: Drafted ruleset object or None if generation fails
+        """
+        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/__init__.py

@@ -0,0 +1 @@
+"""A module containing some high level capabilities."""