fabricatio 0.2.9.dev3__tar.gz → 0.2.10.dev0__tar.gz

{fabricatio-0.2.9.dev3 → fabricatio-0.2.10.dev0}/PKG-INFO

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

fabricatio-0.2.10.dev0/examples/write_article/write_article.py

@@ -0,0 +1,241 @@
+"""Example of using the library."""
+
+import asyncio
+from pathlib import Path
+from typing import List
+
+from fabricatio import Event, Role, WorkFlow, logger
+from fabricatio.actions.article import (
+    FixIntrospectedErrors,
+    GenerateArticle,
+    GenerateArticleProposal,
+    GenerateInitialOutline,
+)
+from fabricatio.actions.article_rag import TweakArticleRAG
+from fabricatio.actions.output import DumpFinalizedOutput, GatherAsList, PersistentAll, RetrieveFromLatest
+from fabricatio.actions.rules import DraftRuleSet, GatherRuleset
+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_proposal import ArticleProposal
+from fabricatio.models.extra.rule import RuleSet
+from fabricatio.models.task import Task
+from fabricatio.utils import ok
+
+
+class Connect(Action):
+    """Connect the article with the article_outline and article_proposal."""
+
+    output_key: str = "article"
+    """Connect the article with the article_outline and article_proposal."""
+
+    async def _execute(
+        self,
+        article_briefing: str,
+        article_proposal: ArticleProposal,
+        article_outline: ArticleOutline,
+        article: Article,
+        **cxt,
+    ) -> Article:
+        """Connect the article with the article_outline and article_proposal."""
+        return article.update_ref(article_outline.update_ref(article_proposal.update_ref(article_briefing)))
+
+
+async def main(article: bool, rule: bool = False, fintune: bool = False) -> None:
+    """Main function."""
+    Role(
+        name="Undergraduate Researcher",
+        description="Write an outline for an article in typst format.",
+        llm_model="openai/deepseek-v3-250324",
+        llm_temperature=1.3,
+        llm_top_p=1.0,
+        llm_max_tokens=8191,
+        llm_rpm=1000,
+        llm_tpm=5000000,
+        registry={
+            Event.quick_instantiate(ns := "article"): WorkFlow(
+                name="Generate Article Outline",
+                description="Generate an outline for an article. dump the outline to the given path. in typst format.",
+                steps=(
+                    RetrieveFromLatest(
+                        retrieve_cls=RuleSet,
+                        load_path="persistent_ruleset/outline_ruleset",
+                        output_key="outline_ruleset",
+                    ),
+                    RetrieveFromLatest(
+                        retrieve_cls=RuleSet,
+                        load_path="persistent_ruleset/dep_ref_ruleset",
+                        output_key="dep_ref_ruleset",
+                    ),
+                    RetrieveFromLatest(
+                        retrieve_cls=RuleSet,
+                        load_path="persistent_ruleset/rev_dep_ref_ruleset",
+                        output_key="rev_dep_ref_ruleset",
+                    ),
+                    RetrieveFromLatest(
+                        retrieve_cls=RuleSet, load_path="persistent_ruleset/cite_ruleset", output_key="cite_ruleset"
+                    ),
+                    RetrieveFromLatest(
+                        retrieve_cls=RuleSet, load_path="persistent_ruleset/para_ruleset", output_key="para_ruleset"
+                    ),
+                    RetrieveFromLatest(
+                        retrieve_cls=RuleSet, load_path="persistent_ruleset/ref_ruleset", output_key="ref_ruleset"
+                    ),
+                    RetrieveFromLatest(
+                        retrieve_cls=RuleSet, load_path="persistent_ruleset/lang_ruleset", output_key="lang_ruleset"
+                    ),
+                    GenerateArticleProposal(llm_temperature=1.3),
+                    GenerateInitialOutline(
+                        output_key="article_outline",
+                    ),
+                    GatherRuleset(output_key="intro_fix_ruleset", to_gather=["para_ruleset"]),
+                    FixIntrospectedErrors(
+                        output_key="article_outline",
+                    ),
+                    PersistentAll,
+                    GatherRuleset(output_key="ref_fix_ruleset", to_gather=["ref_ruleset"]),
+                    GatherRuleset(output_key="ref_twk_ruleset", to_gather=["dep_ref_ruleset", "ref_ruleset"]),
+                    GatherRuleset(output_key="article_gen_ruleset", to_gather=["para_ruleset"]),
+                    GenerateArticle(
+                        output_key="article",
+                    ),
+                    PersistentAll,
+                    GatherRuleset(
+                        output_key="twk_rag_ruleset", to_gather=["para_ruleset", "cite_ruleset", "lang_ruleset"]
+                    ),
+                    TweakArticleRAG(output_key="to_dump"),
+                    DumpFinalizedOutput(output_key="task_output"),
+                    PersistentAll,
+                ),
+            ).update_init_context(
+                article_briefing=Path("./article_briefing.txt").read_text(),
+                dump_path="out.typ",
+                persist_dir="persistent",
+                collection_name="article_essence_0324",
+            ),
+            Event.quick_instantiate(finetune := "article_finetune"): WorkFlow(
+                name="Generate Article Outline",
+                description="Generate an outline for an article. dump the outline to the given path. in typst format.",
+                steps=(
+                    RetrieveFromLatest(
+                        retrieve_cls=RuleSet,
+                        load_path="persistent_ruleset/outline_ruleset",
+                        output_key="outline_ruleset",
+                    ),
+                    RetrieveFromLatest(
+                        retrieve_cls=RuleSet,
+                        load_path="persistent_ruleset/dep_ref_ruleset",
+                        output_key="dep_ref_ruleset",
+                    ),
+                    RetrieveFromLatest(
+                        retrieve_cls=RuleSet,
+                        load_path="persistent_ruleset/rev_dep_ref_ruleset",
+                        output_key="rev_dep_ref_ruleset",
+                    ),
+                    RetrieveFromLatest(
+                        retrieve_cls=RuleSet, load_path="persistent_ruleset/cite_ruleset", output_key="cite_ruleset"
+                    ),
+                    RetrieveFromLatest(
+                        retrieve_cls=RuleSet, load_path="persistent_ruleset/para_ruleset", output_key="para_ruleset"
+                    ),
+                    RetrieveFromLatest(
+                        retrieve_cls=RuleSet, load_path="persistent_ruleset/ref_ruleset", output_key="ref_ruleset"
+                    ),
+                    RetrieveFromLatest(
+                        retrieve_cls=ArticleProposal,
+                        load_path="persistent/article_proposal",
+                        output_key="article_proposal",
+                    ),
+                    RetrieveFromLatest(
+                        retrieve_cls=ArticleOutline,
+                        load_path="persistent/article_outline",
+                        output_key="article_outline",
+                    ),
+                    RetrieveFromLatest(retrieve_cls=Article, load_path="persistent/article", output_key="article"),
+                    Connect,
+                    GatherRuleset(output_key="intro_fix_ruleset", to_gather=["para_ruleset"]),
+                    GatherRuleset(output_key="ref_fix_ruleset", to_gather=["ref_ruleset"]),
+                    GatherRuleset(output_key="article_gen_ruleset", to_gather=["para_ruleset"]),
+                    GatherRuleset(output_key="twk_rag_ruleset", to_gather=["para_ruleset", "cite_ruleset"]),
+                    TweakArticleRAG(
+                        output_key="to_dump",
+                    ),
+                    DumpFinalizedOutput(output_key="task_output"),
+                    PersistentAll,
+                ),
+            ).update_init_context(
+                article_briefing=Path("./article_briefing.txt").read_text(),
+                dump_path="out_fix.typ",
+                persist_dir="persistent_fix",
+                collection_name="article_essence_0324",
+            ),
+            Event.quick_instantiate(rule_ns := "rule"): WorkFlow(
+                name="Generate Draft Rule Set",
+                description="Generate a draft rule set for the article.",
+                llm_model="openai/deepseek-v3-250324",
+                llm_stream=False,
+                steps=(
+                    # 精简后的para_ruleset规则
+                    DraftRuleSet(
+                        ruleset_requirement="如果`paragraphs`字段为空列表，那么你就需要按照`expected_word_count`来为章节补充内容",
+                        output_key="para_ruleset",
+                        rule_count=1,
+                    ),
+                    # 精简后的cite_ruleset规则
+                    DraftRuleSet(
+                        ruleset_requirement="1. 参考文献引用格式：(作者等, 年份)#cite(<bibtex_key>)\n"
+                        "2. #cite()必须用尖括号包裹单个BibTeX键，多引用需重复使用",
+                        output_key="cite_ruleset",
+                        rule_count=1,
+                    ),
+                    # 新增中文检测规则集
+                    DraftRuleSet(
+                        ruleset_requirement="1. 所有标题和正文内容必须使用中文,如果不为中文你需要翻译过来\n"
+                        "2. 术语和专业词汇需使用中文表述,英文缩写第一次出现的时候需要在其后面‘()’来辅助说明",
+                        output_key="lang_ruleset",
+                        rule_count=1,
+                    ),
+                    # 其他规则集保持原有结构但简化内容
+                    DraftRuleSet(
+                        ruleset_requirement="章节的`depend_on`字段的`ArticleRef`只能引用当前章节之前的元素。\n",
+                        output_key="dep_ref_ruleset",
+                        rule_count=1,
+                    ),
+                    DraftRuleSet(
+                        ruleset_requirement="章节的`support_to`字段的`ArticleRef`只能引用当前章节之后的元素。\n",
+                        output_key="rev_dep_ref_ruleset",
+                        rule_count=1,
+                    ),
+                    DraftRuleSet(
+                        ruleset_requirement="ArticleRef必须指向已定义元素",
+                        output_key="ref_ruleset",
+                        rule_count=1,
+                    ),
+                    DraftRuleSet(
+                        ruleset_requirement="标题使用学术术语",
+                        output_key="outline_ruleset",
+                        rule_count=1,
+                    ),
+                    GatherAsList(gather_suffix="ruleset").to_task_output(),
+                    PersistentAll(persist_dir="persistent_ruleset"),
+                ),
+            ),
+        },
+    )
+
+    if rule:
+        draft_rule_task: Task[List[RuleSet]] = Task(name="draft a rule set")
+        rule_set = ok(await draft_rule_task.delegate(rule_ns), "Failed to generate ruleset")
+        logger.success(f"Ruleset:\n{len(rule_set)}")
+    if article:
+        proposed_task = Task(name="write an article")
+        path = ok(await proposed_task.delegate(ns), "Failed to generate ruleset")
+        logger.success(f"The outline is saved in:\n{path}")
+    if fintune:
+        proposed_task = Task(name="finetune an article")
+        path = ok(await proposed_task.delegate(finetune), "Failed to generate ruleset")
+        logger.success(f"The outline is saved in:\n{path}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main(True, False, False))

{fabricatio-0.2.9.dev3 → fabricatio-0.2.10.dev0}/pyproject.toml

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

{fabricatio-0.2.9.dev3 → fabricatio-0.2.10.dev0}/python/fabricatio/actions/article.py

@@ -11,7 +11,6 @@ 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 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
@@ -105,7 +104,6 @@ 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:
@@ -122,17 +120,14 @@ class GenerateArticleProposal(Action, Propose):
             )
         )
 
-        proposal = ok(
+        logger.info("Start generating the proposal.")
+        return ok(
             await self.propose(
                 ArticleProposal,
-                f"{briefing}\n\nWrite the value string using `{detect_language(briefing)}`",
+                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):
@@ -146,11 +141,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,
-                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.",
+                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)
@@ -182,7 +183,7 @@ class FixIntrospectedErrors(Action, Censor):
                 await self.censor_obj(
                     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}",
+                    reference=f"{article_outline.display()}\n # Fatal Error of the Original Article Outline\n{pack}",
                 ),
                 "Could not correct the component.",
             ).update_ref(origin)
@@ -195,107 +196,6 @@ class FixIntrospectedErrors(Action, Censor):
         return article_outline
 
 
-class FixIllegalReferences(Action, Censor):
-    """Fix illegal references in the article outline."""
-
-    output_key: str = "illegal_references_fixed_outline"
-    """The key of the output data."""
-
-    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,
-        ref_fix_ruleset: Optional[RuleSet] = None,
-        **_,
-    ) -> Optional[ArticleOutline]:
-        counter = 0
-        while pack := article_outline.find_illegal_ref(gather_identical=True):
-            logger.info(f"Found {counter}th illegal references")
-            ref_seq, err = ok(pack)
-            logger.warning(f"Found illegal referring error: {err}")
-            new = ok(
-                await self.censor_obj(
-                    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 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
-
-
-class TweakOutlineForwardRef(Action, Censor):
-    """Tweak the forward references in the article outline.
-
-    Ensures that the conclusions of the current chapter effectively support the analysis of subsequent chapters.
-    """
-
-    output_key: str = "article_outline_fw_ref_checked"
-    ruleset: Optional[RuleSet] = None
-    """Ruleset to use to fix the illegal references."""
-
-    async def _execute(
-        self, article_outline: ArticleOutline, ref_twk_ruleset: Optional[RuleSet] = None, **cxt
-    ) -> ArticleOutline:
-        return await self._inner(
-            article_outline,
-            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:
-        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.
-
-    Ensures that the prerequisites of the current chapter are correctly referenced in the `depend_on` field.
-    """
-
-    output_key: str = "article_outline_bw_ref_checked"
-    ruleset: Optional[RuleSet] = None
-
-    async def _execute(
-        self, article_outline: ArticleOutline, ref_twk_ruleset: Optional[RuleSet] = None, **cxt
-    ) -> ArticleOutline:
-        return await self._inner(
-            article_outline,
-            ruleset=ok(ref_twk_ruleset or self.ruleset, "No ruleset provided"),
-            field_name="depend_on",
-        )
-
-
 class GenerateArticle(Action, Censor):
     """Generate the article based on the outline."""
 
@@ -318,7 +218,7 @@ class GenerateArticle(Action, Censor):
                 self.censor_obj_inplace(
                     subsec,
                     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}",
+                    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()) and logger.warning(f"Found Introspection Error:\n{err}") is None

{fabricatio-0.2.9.dev3 → fabricatio-0.2.10.dev0}/python/fabricatio/actions/article_rag.py

@@ -29,6 +29,9 @@ 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,
@@ -88,11 +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, which can return multiple candidates.",
+                f"provide queries in both `English` and `{subsec.language}` can get more accurate results.",
             )
         )
         await self.censor_obj_inplace(
             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.dev3 → fabricatio-0.2.10.dev0}/python/fabricatio/capabilities/check.py

@@ -8,7 +8,7 @@ from fabricatio.capabilities.advanced_judge import AdvancedJudge
 from fabricatio.capabilities.propose import Propose
 from fabricatio.config import configs
 from fabricatio.journal import logger
-from fabricatio.models.extra.patches import RuleSetBriefingPatch
+from fabricatio.models.extra.patches import RuleSetMetadata
 from fabricatio.models.extra.problem import Improvement
 from fabricatio.models.extra.rule import Rule, RuleSet
 from fabricatio.models.generic import Display, WithBriefing
@@ -42,12 +42,17 @@ class Check(AdvancedJudge, Propose):
             - Returns None if any step in rule generation fails
             - Uses `alist_str` for requirement breakdown and iterative rule proposal
         """
-        rule_reqs = await self.alist_str(
-            TEMPLATE_MANAGER.render_template(
-                configs.templates.ruleset_requirement_breakdown_template, {"ruleset_requirement": ruleset_requirement}
-            ),
-            rule_count,
-            **override_kwargs(kwargs, default=None),
+        rule_reqs = (
+            await self.alist_str(
+                TEMPLATE_MANAGER.render_template(
+                    configs.templates.ruleset_requirement_breakdown_template,
+                    {"ruleset_requirement": ruleset_requirement},
+                ),
+                rule_count,
+                **override_kwargs(kwargs, default=None),
+            )
+            if rule_count > 1
+            else [ruleset_requirement]
         )
 
         if rule_reqs is None:
@@ -65,7 +70,7 @@ class Check(AdvancedJudge, Propose):
             return None
 
         ruleset_patch = await self.propose(
-            RuleSetBriefingPatch,
+            RuleSetMetadata,
             f"{ruleset_requirement}\n\nYou should use `{detect_language(ruleset_requirement)}`!",
             **override_kwargs(kwargs, default=None),
         )
@@ -99,7 +104,8 @@ class Check(AdvancedJudge, Propose):
             - Proposes Improvement only when violation is confirmed
         """
         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?",
+            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.name}` provided above?"
+            f"should I take some measure to fix that violation? true for I do need, false for I don't need.",
             **override_kwargs(kwargs, default=None),
         ):
             logger.info(f"Rule `{rule.name}` violated: \n{judge.display()}")

{fabricatio-0.2.9.dev3 → fabricatio-0.2.10.dev0}/python/fabricatio/capabilities/correct.py

@@ -57,7 +57,7 @@ class Correct(Rating, Propose):
                     self.decide_solution(
                         ps,
                         **fallback_kwargs(
-                            kwargs, topic=f"which solution is better to deal this problem {ps.problem.compact()}\n\n"
+                            kwargs, topic=f"which solution is better to deal this problem {ps.problem.description}\n\n"
                         ),
                     )
                     for ps in improvement.problem_solutions
@@ -167,13 +167,12 @@ class Correct(Rating, Propose):
             logger.info(f"Improvement {improvement.focused_on} not decided, start deciding...")
             improvement = await self.decide_improvement(improvement, **override_kwargs(kwargs, default=None))
 
-        for ps in improvement.problem_solutions:
-            logger.info(f"Fixing troubling obj {obj.__class__.__name__} when deal with problem: {ps.problem.name}")
+        total = len(improvement.problem_solutions)
+        for idx, ps in enumerate(improvement.problem_solutions):
+            logger.info(f"[{idx + 1}/{total}] Fixing {obj.__class__.__name__} for problem `{ps.problem.name}`")
             fixed_obj = await self.fix_troubled_obj(obj, ps, reference, **kwargs)
             if fixed_obj is None:
-                logger.error(
-                    f"Failed to fix troubling obj {obj.__class__.__name__} when deal with problem: {ps.problem.name}",
-                )
+                logger.error(f"[{idx + 1}/{total}] Failed to fix problem `{ps.problem.name}`")
                 return None
             obj = fixed_obj
         return obj