fabricatio 0.2.9.dev1__cp312-cp312-manylinux_2_34_x86_64.whl → 0.2.9.dev3__cp312-cp312-manylinux_2_34_x86_64.whl

fabricatio/actions/article.py

@@ -2,24 +2,23 @@
 
 from asyncio import gather
 from pathlib import Path
-from typing import Any, Callable, List, Optional
+from typing import Callable, List, Optional
 
 from more_itertools import filter_map
 
 from fabricatio.capabilities.censor import Censor
-from fabricatio.capabilities.correct import Correct
 from fabricatio.capabilities.propose import Propose
 from fabricatio.fs import safe_text_read
 from fabricatio.journal import logger
 from fabricatio.models.action import Action
-from fabricatio.models.extra.article_base import ArticleRefSequencePatch
+from fabricatio.models.extra.article_base import SubSectionBase
 from fabricatio.models.extra.article_essence import ArticleEssence
 from fabricatio.models.extra.article_main import Article
 from fabricatio.models.extra.article_outline import ArticleOutline
 from fabricatio.models.extra.article_proposal import ArticleProposal
 from fabricatio.models.extra.rule import RuleSet
 from fabricatio.models.task import Task
-from fabricatio.rust import BibManager
+from fabricatio.rust import BibManager, detect_language
 from fabricatio.utils import ok
 
 
@@ -53,7 +52,7 @@ class ExtractArticleEssence(Action, Propose):
         for ess in await self.propose(
             ArticleEssence,
             [
-                f"{c}\n\n\nBased the provided academic article above, you need to extract the essence from it."
+                f"{c}\n\n\nBased the provided academic article above, you need to extract the essence from it.\n\nWrite the value string using `{detect_language(c)}`"
                 for c in contents
             ],
         ):
@@ -113,21 +112,20 @@ class GenerateArticleProposal(Action, Propose):
             logger.error("Task not approved, since all inputs are None.")
             return None
 
+        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.",
+            )
+        )
+
         proposal = 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)}`",
             ),
             "Could not generate the proposal.",
         ).update_ref(briefing)
@@ -151,7 +149,8 @@ class GenerateInitialOutline(Action, Propose):
         return ok(
             await self.propose(
                 ArticleOutline,
-                article_proposal.as_prompt(),
+                f"{(p := article_proposal.as_prompt())}\n\nNote that you should use `{detect_language(p)}` 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 +164,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 +203,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 +246,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 +287,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 +306,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 +317,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}",
                 )
-                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
 
@@ -33,7 +33,7 @@ class TweakArticleRAG(Action, RAG, Censor):
         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 +45,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 +57,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 +88,11 @@ 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"prioritizing both original article language and English usage, which can return multiple candidates.",
             )
         )
-        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),
         )

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/rules.py

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

fabricatio/capabilities/censor.py

@@ -8,6 +8,8 @@ from typing import Optional, Unpack
 
 from fabricatio.capabilities.check import Check
 from fabricatio.capabilities.correct import Correct
+from fabricatio.journal import logger
+from fabricatio.models.extra.problem import Improvement
 from fabricatio.models.extra.rule import RuleSet
 from fabricatio.models.generic import ProposedUpdateAble, SketchedAble
 from fabricatio.models.kwargs_types import ReferencedKwargs
@@ -20,8 +22,6 @@ class Censor(Correct, Check):
     Inherits from both Correct and Check classes.
     Provides methods to censor objects and strings by first checking them against a ruleset and then correcting them if necessary.
 
-    Attributes:
-        ruleset (RuleSet): The ruleset to be used for censoring.
     """
 
     async def censor_obj[M: SketchedAble](
@@ -42,8 +42,12 @@ class Censor(Correct, Check):
         """
         imp = await self.check_obj(obj, ruleset, **override_kwargs(kwargs, default=None))
         if imp is None:
-            return imp
-        return await self.correct_obj(obj, imp, **kwargs)
+            return None
+        if not imp:
+            logger.info(f"No improvement found for `{obj.__class__.__name__}`.")
+            return obj
+        logger.info(f'Generated {len(imp)} improvement(s) for `{obj.__class__.__name__}')
+        return await self.correct_obj(obj, Improvement.gather(*imp), **kwargs)
 
     async def censor_string(
         self, input_text: str, ruleset: RuleSet, **kwargs: Unpack[ReferencedKwargs[str]]
@@ -63,8 +67,13 @@ class Censor(Correct, Check):
         """
         imp = await self.check_string(input_text, ruleset, **override_kwargs(kwargs, default=None))
         if imp is None:
-            return imp
-        return await self.correct_string(input_text, imp, **kwargs)
+            logger.warning(f"Censor failed for string:\n{input_text}")
+            return None
+        if not imp:
+            logger.info("No improvement found for string.")
+            return input_text
+        logger.info(f'Generated {len(imp)} improvement(s) for string.')
+        return await self.correct_string(input_text, Improvement.gather(*imp), **kwargs)
 
     async def censor_obj_inplace[M: ProposedUpdateAble](
         self, obj: M, ruleset: RuleSet, **kwargs: Unpack[ReferencedKwargs[M]]
@@ -86,5 +95,10 @@ class Censor(Correct, Check):
         """
         imp = await self.check_obj(obj, ruleset, **override_kwargs(kwargs, default=None))
         if imp is None:
-            return imp
-        return await self.correct_obj_inplace(obj, improvement=imp, **kwargs)
+            logger.warning(f"Censor failed for `{obj.__class__.__name__}`")
+            return None
+        if not imp:
+            logger.info(f"No improvement found for `{obj.__class__.__name__}`.")
+            return obj
+        logger.info(f'Generated {len(imp)} improvement(s) for `{obj.__class__.__name__}')
+        return await self.correct_obj_inplace(obj, improvement=Improvement.gather(*imp), **kwargs)