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

fabricatio/_rust.pyi

@@ -122,3 +122,53 @@ class BibManager:
         Returns:
             List of all titles in the bibliography
         """
+
+    def get_author_by_key(self, key: str) -> Optional[List[str]]:
+        """Retrieve authors by citation key.
+
+        Args:
+            key: Citation key
+
+        Returns:
+            List of authors if found, None otherwise
+        """
+
+    def get_year_by_key(self, key: str) -> Optional[int]:
+        """Retrieve the publication year by citation key.
+
+        Args:
+            key: Citation key
+
+        Returns:
+            Publication year if found, None otherwise
+        """
+
+    def get_abstract_by_key(self, key: str) -> Optional[str]:
+        """Retrieve the abstract by citation key.
+
+        Args:
+            key: Citation key
+
+        Returns:
+            Abstract if found, None otherwise
+        """
+    def get_title_by_key(self, key: str) -> Optional[str]:
+        """Retrieve the title by citation key.
+
+        Args:
+            key: Citation key
+
+        Returns:
+            Title if found, None otherwise
+        """
+
+    def get_field_by_key(self, key: str, field: str)-> Optional[str]:
+        """Retrieve a specific field by citation key.
+
+        Args:
+            key: Citation key
+            field: Field name
+
+        Returns:
+            Field value if found, None otherwise
+        """

fabricatio/actions/article.py

@@ -4,6 +4,7 @@ from asyncio import gather
 from pathlib import Path
 from typing import Any, Callable, List, Optional
 
+from fabricatio._rust import BibManager
 from fabricatio.capabilities.advanced_judge import AdvancedJudge
 from fabricatio.fs import safe_text_read
 from fabricatio.journal import logger
@@ -14,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):
@@ -31,20 +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,
-            system_message=f"# your personal briefing: \n{self.briefing}",
-        )
+        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],
+        **_,
+    ) -> 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}")
+                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):
@@ -80,7 +124,6 @@ class GenerateArticleProposal(Action):
                         )
                     )
                 ),
-                **self.prepend_sys_msg(),
             ),
             "Could not generate the proposal.",
         ).update_ref(briefing)
@@ -105,10 +148,9 @@ 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)
 
 
 class FixIntrospectedErrors(Action):
@@ -120,6 +162,7 @@ class FixIntrospectedErrors(Action):
     async def _execute(
         self,
         article_outline: ArticleOutline,
+        supervisor_check: bool = False,
         **_,
     ) -> Optional[ArticleOutline]:
         introspect_manual = ok(
@@ -141,7 +184,7 @@ class FixIntrospectedErrors(Action):
                     reference=f"# Original Article Outline\n{article_outline.display()}\n# Error Need to be fixed\n{err}",
                     topic=intro_topic,
                     rating_manual=introspect_manual,
-                    supervisor_check=False,
+                    supervisor_check=supervisor_check,
                 ),
                 "Could not correct the component.",
             )
@@ -159,6 +202,7 @@ class FixIllegalReferences(Action):
     async def _execute(
         self,
         article_outline: ArticleOutline,
+        supervisor_check: bool = False,
         **_,
     ) -> Optional[ArticleOutline]:
         ref_manual = ok(
@@ -171,88 +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,
-                    reference=f"# Original Article Outline\n{article_outline.display()}\n# Error Need to be fixed\n{err}\n\n",
+            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=False,
+                    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, **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.",
+    async def _execute(self, article_outline: ArticleOutline, supervisor_check: bool = False, **cxt) -> ArticleOutline:
+        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 = ArticleRefPatch.default()
+                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, **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.",
+    async def _execute(self, article_outline: ArticleOutline, supervisor_check: bool = False, **cxt) -> ArticleOutline:
+        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,
-                )
-
-        return article_outline
-
 
 class GenerateArticle(Action):
     """Generate the article based on the outline."""
@@ -263,6 +300,7 @@ class GenerateArticle(Action):
     async def _execute(
         self,
         article_outline: ArticleOutline,
+        supervisor_check: bool = False,
         **_,
     ) -> Optional[Article]:
         article: Article = Article.from_outline(ok(article_outline, "Article outline not specified.")).update_ref(
@@ -280,7 +318,7 @@ class GenerateArticle(Action):
                     reference=f"# Original Article Outline\n{article_outline.display()}\n# Error Need to be fixed\n{err}",
                     topic=w_topic,
                     rating_manual=write_para_manual,
-                    supervisor_check=False,
+                    supervisor_check=supervisor_check,
                 )
                 for _, __, subsec in article.iter_subsections()
                 if (err := subsec.introspect())

fabricatio/actions/article_rag.py

@@ -1,35 +1,89 @@
 """A module for writing articles using RAG (Retrieval-Augmented Generation) capabilities."""
 
-from typing import Optional
+from asyncio import gather
+from typing import Dict, Optional
 
 from fabricatio.capabilities.rag import RAG
-from fabricatio.journal import logger
 from fabricatio.models.action import Action
-from fabricatio.models.extra.article_main import Article
-from fabricatio.models.extra.article_outline import ArticleOutline
+from fabricatio.models.extra.article_main import Article, ArticleParagraphPatch, ArticleSubsection
+from fabricatio.utils import ok
 
 
-class GenerateArticleRAG(Action, RAG):
+class TweakArticleRAG(Action, RAG):
     """Write an article based on the provided outline."""
 
-    output_key: str = "article"
+    output_key: str = "rag_tweaked_article"
 
-    async def _execute(self, article_outline: ArticleOutline, **cxt) -> Optional[Article]:
+    async def _execute(
+        self,
+        article: Article,
+        collection_name: str = "article_essence",
+        citation_requirement: str = "# Citation Format\n"
+        "Use correct citation format based on author count. Cite using author surnames and year:"
+        "For 3+ authors: 'Author1, Author2 et al. (YYYY)'"
+        "For 2 authors: 'Author1 & Author2 (YYYY)'"
+        "Single author: 'Author1 (YYYY)'"
+        "Multiple citations: 'Author1 (YYYY), Author2 (YYYY)'"
+        "Prioritize formulas from reference highlights."
+        "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,
+        **cxt,
+    ) -> Optional[Article]:
         """Write an article based on the provided outline."""
-        logger.info(f"Writing an article based on the outline:\n{article_outline.title}")
-        refined_q = await self.arefined_query(article_outline.display())
-        return await self.propose(
-            Article,
-            article_outline.display(),
-            **self.prepend_sys_msg(f"{await self.aretrieve_compact(refined_q)}\n{self.briefing}"),
+        criteria = await self.draft_rating_criteria(
+            topic := "choose appropriate reference to insert into the article, "
+            "making conclusions or reasoning based on concrete evidence instead of unreliable guesses."
+            "Extensively use formulas highlighted in reference文献 should be translated to 'references'."
+            "Only specify authors and years without numeric citation numbers (like [1],[2])."
+            "Each paragraph should not end with just 2-3 sentences for better readability.",
+            criteria_count=13,
         )
 
+        tweak_manual = ok(await self.draft_rating_manual(topic, criteria=criteria))
+        self.view(collection_name)
 
-class WriteArticleFineGrind(Action, RAG):
-    """Fine-grind an article based on the provided outline."""
+        if parallel:
+            await gather(
+                *[
+                    self._inner(article, subsec, supervisor_check, citation_requirement, topic, tweak_manual)
+                    for _, __, subsec in article.iter_subsections()
+                ],
+                return_exceptions=True,
+            )
+        else:
+            for _, __, subsec in article.iter_subsections():
+                await self._inner(article, subsec, supervisor_check, citation_requirement, topic, tweak_manual)
 
-    output_key: str = "article"
+        return article
 
-    async def _execute(self, article_outline: ArticleOutline, **cxt) -> Optional[Article]:
-        """Fine-grind an article based on the provided outline."""
-        logger.info(f"Fine-grinding an article based on the outline:\n{article_outline.title}")
+    async def _inner(
+        self,
+        article: Article,
+        subsec: ArticleSubsection,
+        supervisor_check: bool,
+        citation_requirement: str,
+        topic: str,
+        tweak_manual: Dict[str, str],
+    ) -> None:
+        refind_q = ok(
+            await self.arefined_query(
+                f"{article.referenced.as_prompt()}\n"
+                f"# Subsection requiring reference enhancement\n"
+                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",
+            )
+        )
+        patch = ArticleParagraphPatch.default()
+        patch.tweaked = subsec.paragraphs
+        await self.correct_obj_inplace(
+            patch,
+            reference=f"{await self.aretrieve_compact(refind_q, final_limit=50)}\n{citation_requirement}",
+            topic=topic,
+            rating_manual=tweak_manual,
+            supervisor_check=supervisor_check,
+        )

fabricatio/actions/output.py

@@ -1,19 +1,20 @@
 """Dump the finalized output to a file."""
 
 from pathlib import Path
-from typing import Optional
+from typing import Iterable, List, Optional, Type
 
 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):
     """Dump the finalized output to a file."""
 
     output_key: str = "dump_path"
+    dump_path: Optional[str] = None
 
     async def _execute(
         self,
@@ -24,6 +25,7 @@ class DumpFinalizedOutput(Action):
     ) -> str:
         dump_path = Path(
             dump_path
+            or self.dump_path
             or ok(
                 await self.awhich_pathstr(
                     f"{ok(task_input, 'Neither `task_input` and `dump_path` is provided.').briefing}\n\nExtract a single path of the file, to which I will dump the data."
@@ -39,6 +41,7 @@ class PersistentAll(Action):
     """Persist all the data to a file."""
 
     output_key: str = "persistent_count"
+    persist_dir: Optional[str] = None
 
     async def _execute(
         self,
@@ -48,6 +51,7 @@ class PersistentAll(Action):
     ) -> int:
         persist_dir = Path(
             persist_dir
+            or self.persist_dir
             or ok(
                 await self.awhich_pathstr(
                     f"{ok(task_input, 'Neither `task_input` and `dump_path` is provided.').briefing}\n\nExtract a single path of the file, to which I will persist the data."
@@ -60,10 +64,39 @@ class PersistentAll(Action):
         if persist_dir.is_file():
             logger.warning("Dump should be a directory, but it is a file. Skip dumping.")
             return count
-        persist_dir.mkdir(parents=True, exist_ok=True)
-        for v in cxt.values():
+
+        for k, v in cxt.items():
+            final_dir = persist_dir.joinpath(k)
             if isinstance(v, PersistentAble):
-                v.persist(persist_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))
+            ):
+                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
+
+
+class RetrieveFromPersistent[T: PersistentAble](Action):
+    """Retrieve the object from the persistent file."""
+
+    output_key: str = "retrieved_obj"
+    """Retrieve the object from the persistent file."""
+    load_path: str
+    """The path of the persistent file or directory contains multiple file."""
+    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}")
+        if not (p := Path(self.load_path)).exists():
+            return None
+
+        if p.is_dir():
+            return [self.retrieve_cls.from_persistent(per) for per in p.glob("*")]
+        return self.retrieve_cls.from_persistent(self.load_path)

fabricatio/actions/rag.py

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

fabricatio/capabilities/check.py

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