fabricatio 0.2.9.dev2__tar.gz → 0.2.9.dev4__tar.gz

{fabricatio-0.2.9.dev2 → fabricatio-0.2.9.dev4}/Cargo.lock

@@ -452,6 +452,7 @@ dependencies = [
  "pythonize",
  "rayon",
  "serde_json",
+ "unicode-segmentation",
  "walkdir",
  "whichlang",
 ]

{fabricatio-0.2.9.dev2 → fabricatio-0.2.9.dev4}/Cargo.toml

@@ -14,6 +14,7 @@ pyo3 = { version = "0.23.4", features = ["extension-module"] }
 pythonize = "0.23.0"
 rayon = "1.10.0"
 serde_json = "1.0.138"
+unicode-segmentation = "1.12.0"
 walkdir = "2.5.0"
 whichlang = "0.1.1"
 

{fabricatio-0.2.9.dev2 → fabricatio-0.2.9.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.9.dev2
+Version: 0.2.9.dev4
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12

{fabricatio-0.2.9.dev2 → fabricatio-0.2.9.dev4}/examples/make_a_rating/rating.py

@@ -5,11 +5,12 @@ from typing import Dict, List, Set, Unpack
 
 import orjson
 from fabricatio import Action, JsonCapture, Role, WorkFlow, logger
+from fabricatio.capabilities.rating import Rating
 from fabricatio.models.events import Event
 from fabricatio.models.task import Task
 
 
-class Rate(Action):
+class Rate(Action, Rating):
     """Rate the task."""
 
     output_key: str = "task_output"
@@ -49,7 +50,7 @@ class WhatToRate(Action):
         )
 
 
-class MakeCriteria(Action):
+class MakeCriteria(Action, Rating):
     """Make criteria for rating."""
 
     output_key: str = "criteria"
@@ -60,7 +61,7 @@ class MakeCriteria(Action):
         return set(criteria)
 
 
-class MakeCompositeScore(Action):
+class MakeCompositeScore(Action, Rating):
     """Make a composite score."""
 
     output_key: str = "task_output"
@@ -72,6 +73,15 @@ class MakeCompositeScore(Action):
         )
 
 
+class Best(Action, Rating):
+    """Select the best."""
+
+    output_key: str = "task_output"
+
+    async def _execute(self, rate_topic: str, to_rate: List[str], **cxt: Unpack) -> str:
+        return (await self.best(to_rate, topic=rate_topic)).pop(0)
+
+
 async def main() -> None:
     """Main function."""
     role = Role(
@@ -100,23 +110,32 @@ async def main() -> None:
                     "rate_topic": "if the food is 'good'",
                 },
             ),
+            Event.quick_instantiate("best"): WorkFlow(
+                name="choose the best",
+                steps=(WhatToRate, Best),
+                extra_init_context={"rate_topic": "if the food is 'good'"},
+            ),
         },
     )
     task = await role.propose_task(
         "rate these food, so that i can decide what to eat today. choco cake, strawberry icecream, giga burger, cup of coffee, rotten bread from the trash bin, and a salty of fruit salad",
     )
-    rating = await task.move_to("rate_food").delegate()
+    rating = await task.delegate("rate_food")
 
     logger.success(f"Result: \n{rating}")
 
-    generated_criteria = await task.move_to("make_criteria_for_food").delegate()
+    generated_criteria = await task.delegate("make_criteria_for_food")
 
     logger.success(f"Generated Criteria: \n{generated_criteria}")
 
-    composite_score = await task.move_to("make_composite_score").delegate()
+    composite_score = await task.delegate("make_composite_score")
 
     logger.success(f"Composite Score: \n{composite_score}")
 
+    best = await task.delegate("best")
+
+    logger.success(f"Best: \n{best}")
+
 
 if __name__ == "__main__":
     asyncio.run(main())

fabricatio-0.2.9.dev4/examples/reviewer/censor.py

@@ -0,0 +1,32 @@
+"""Example of review usage."""
+
+import asyncio
+
+from fabricatio import Role, logger
+from fabricatio.capabilities.censor import Censor
+
+
+class Coder(Role, Censor):
+    """Reviewer role."""
+
+
+async def main() -> None:
+    """Main function."""
+    role = Coder(
+        name="Bob",
+        description="A role that reviews the code.",
+    )
+
+    code = await role.aask(
+        "write a cli app using rust with clap which can generate a basic manifest of a standard rust project, output code only,no extra explanation"
+    )
+
+    ruleset = await role.draft_ruleset("should not use clap to write cli.", rule_count=1)
+    logger.success(f"Code: \n{code}")
+    code = await role.censor_string(code, ruleset)
+
+    logger.success(f"Code: \n{code}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

{fabricatio-0.2.9.dev2 → fabricatio-0.2.9.dev4}/examples/reviewer/review.py

@@ -3,11 +3,15 @@
 import asyncio
 
 from fabricatio import Role, logger
+from fabricatio.capabilities.review import Review
 
 
+class Reviewer(Role, Review):
+    """Reviewer role."""
+
 async def main() -> None:
     """Main function."""
-    role = Role(
+    role = Reviewer(
         name="Reviewer",
         description="A role that reviews the code.",
     )

{fabricatio-0.2.9.dev2 → fabricatio-0.2.9.dev4}/examples/write_outline/write_outline_corrected.py

@@ -3,7 +3,7 @@
 import asyncio
 
 from fabricatio import Event, Role, WorkFlow, logger
-from fabricatio.actions.article import CorrectOutline, CorrectProposal, GenerateArticleProposal, GenerateInitialOutline
+from fabricatio.actions.article import GenerateArticleProposal, GenerateInitialOutline
 from fabricatio.actions.output import DumpFinalizedOutput
 
 
@@ -20,13 +20,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_model="deepseek/deepseek-reasoner", llm_temperature=1.3),
-                    CorrectProposal(
-                        output_key="article_proposal",
-                        llm_model="deepseek/deepseek-reasoner",
-                        llm_temperature=1.3,
-                    ),
                     GenerateInitialOutline(llm_model="deepseek/deepseek-chat", llm_temperature=1.4, llm_top_p=0.5),
-                    CorrectOutline(output_key="to_dump", llm_temperature=1.4, llm_top_p=0.45),
                     DumpFinalizedOutput(output_key="task_output"),
                 ),
             )

{fabricatio-0.2.9.dev2 → fabricatio-0.2.9.dev4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fabricatio"
-version = "0.2.9-dev2"
+version = "0.2.9-dev4"
 description = "A LLM multi-agent framework."
 readme = "README.md"
 license = { file = "LICENSE" }

{fabricatio-0.2.9.dev2 → fabricatio-0.2.9.dev4}/python/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-0.2.9.dev2 → fabricatio-0.2.9.dev4}/python/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-0.2.9.dev2 → fabricatio-0.2.9.dev4}/python/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}")