fabricatio 0.2.11.dev3__cp312-cp312-win_amd64.whl → 0.2.12__cp312-cp312-win_amd64.whl

fabricatio/models/extra/aricle_rag.py

@@ -9,7 +9,7 @@ from fabricatio.journal import logger
 from fabricatio.models.extra.rag import MilvusDataBase
 from fabricatio.models.generic import AsPrompt
 from fabricatio.models.kwargs_types import ChunkKwargs
-from fabricatio.rust import BibManager, is_chinese, split_into_chunks
+from fabricatio.rust import BibManager, blake3_hash, split_into_chunks
 from fabricatio.utils import ok
 from more_itertools.recipes import flatten, unique
 from pydantic import Field
@@ -53,7 +53,7 @@ class ArticleChunk(MilvusDataBase, AsPrompt):
 
     def _as_prompt_inner(self) -> Dict[str, str]:
         return {
-            f"[[{ok(self._cite_number, 'You need to update cite number first.')}]] reference `{self.article_title}`": self.chunk
+            f"[[{ok(self._cite_number, 'You need to update cite number first.')}]] reference `{self.article_title}` from {self.as_auther_seq()}": self.chunk
         }
 
     @property
@@ -139,15 +139,9 @@ class ArticleChunk(MilvusDataBase, AsPrompt):
         return re.sub(r"\[[\d\s,\\~–-]+]", "", string)
 
     @property
-    def auther_firstnames(self) -> List[str]:
-        """Get the first name of the authors."""
-        ret = []
-        for n in self.authors:
-            if is_chinese(n):
-                ret.append(n[0])
-            else:
-                ret.append(n.split()[-1])
-        return ret
+    def auther_lastnames(self) -> List[str]:
+        """Get the last name of the authors."""
+        return [n.split()[-1] for n in self.authors]
 
     def as_auther_seq(self) -> str:
         """Get the auther sequence."""
@@ -155,13 +149,13 @@ class ArticleChunk(MilvusDataBase, AsPrompt):
             case 0:
                 raise ValueError("No authors found")
             case 1:
-                return f"（{self.auther_firstnames[0]}，{self.year}）{self.as_typst_cite()}"
+                return f"（{self.auther_lastnames[0]}，{self.year}）{self.as_typst_cite()}"
             case 2:
-                return f"（{self.auther_firstnames[0]}{self.and_word}{self.auther_firstnames[1]}，{self.year}）{self.as_typst_cite()}"
+                return f"（{self.auther_lastnames[0]}{self.and_word}{self.auther_lastnames[1]}，{self.year}）{self.as_typst_cite()}"
             case 3:
-                return f"（{self.auther_firstnames[0]}，{self.auther_firstnames[1]}{self.and_word}{self.auther_firstnames[2]}，{self.year}）{self.as_typst_cite()}"
+                return f"（{self.auther_lastnames[0]}，{self.auther_lastnames[1]}{self.and_word}{self.auther_lastnames[2]}，{self.year}）{self.as_typst_cite()}"
             case _:
-                return f"（{self.auther_firstnames[0]}，{self.auther_firstnames[1]}{self.and_word}{self.auther_firstnames[2]}{self.etc_word}，{self.year}）{self.as_typst_cite()}"
+                return f"（{self.auther_lastnames[0]}，{self.auther_lastnames[1]}{self.and_word}{self.auther_lastnames[2]}{self.etc_word}，{self.year}）{self.as_typst_cite()}"
 
     def update_cite_number(self, cite_number: int) -> Self:
         """Update the cite number."""
@@ -182,20 +176,32 @@ class CitationManager(AsPrompt):
     abbr_sep: str = "-"
     """Separator for abbreviated citation numbers."""
 
-    def update_chunks(self, article_chunks: List[ArticleChunk], set_cite_number: bool = True) -> Self:
+    def update_chunks(
+        self, article_chunks: List[ArticleChunk], set_cite_number: bool = True, dedup: bool = True
+    ) -> Self:
         """Update article chunks."""
         self.article_chunks.clear()
         self.article_chunks.extend(article_chunks)
+        if dedup:
+            self.article_chunks = list(unique(self.article_chunks, lambda c: blake3_hash(c.chunk.encode())))
         if set_cite_number:
             self.set_cite_number_all()
         return self
 
-    def add_chunks(self, article_chunks: List[ArticleChunk], set_cite_number: bool = True)-> Self:
+    def empty(self) -> Self:
+        """Empty the article chunks."""
+        self.article_chunks.clear()
+        return self
+
+    def add_chunks(self, article_chunks: List[ArticleChunk], set_cite_number: bool = True, dedup: bool = True) -> Self:
         """Add article chunks."""
         self.article_chunks.extend(article_chunks)
+        if dedup:
+            self.article_chunks = list(unique(self.article_chunks, lambda c: blake3_hash(c.chunk.encode())))
         if set_cite_number:
             self.set_cite_number_all()
         return self
+
     def set_cite_number_all(self) -> Self:
         """Set citation numbers for all article chunks."""
         for i, a in enumerate(self.article_chunks, 1):
@@ -208,7 +214,7 @@ class CitationManager(AsPrompt):
 
     def apply(self, string: str) -> str:
         """Apply citation replacements to the input string."""
-        for origin,m in re.findall(self.pat, string):
+        for origin, m in re.findall(self.pat, string):
             logger.info(f"Matching citation: {m}")
             notations = self.convert_to_numeric_notations(m)
             logger.info(f"Citing Notations: {notations}")
@@ -216,9 +222,26 @@ class CitationManager(AsPrompt):
             logger.info(f"Citation Number Sequence: {citation_number_seq}")
             dedup = self.deduplicate_citation(citation_number_seq)
             logger.info(f"Deduplicated Citation Number Sequence: {dedup}")
-            string=string.replace(origin, self.unpack_cite_seq(dedup))
+            string = string.replace(origin, self.unpack_cite_seq(dedup))
         return string
 
+    def citation_count(self, string: str) -> int:
+        """Get the citation count in the string."""
+        count = 0
+        for _, m in re.findall(self.pat, string):
+            logger.info(f"Matching citation: {m}")
+            notations = self.convert_to_numeric_notations(m)
+            logger.info(f"Citing Notations: {notations}")
+            citation_number_seq = list(flatten(self.decode_expr(n) for n in notations))
+            logger.info(f"Citation Number Sequence: {citation_number_seq}")
+            count += len(dedup := self.deduplicate_citation(citation_number_seq))
+            logger.info(f"Deduplicated Citation Number Sequence: {dedup}")
+        return count
+
+    def citation_coverage(self, string: str) -> float:
+        """Get the citation coverage in the string."""
+        return self.citation_count(string) / len(self.article_chunks)
+
     def decode_expr(self, string: str) -> List[int]:
         """Decode citation expression into a list of integers."""
         if self.abbr_sep in string:

fabricatio/models/extra/article_base.py

@@ -1,6 +1,6 @@
 """A foundation for hierarchical document components with dependency tracking."""
 
-from abc import ABC, abstractmethod
+from abc import ABC
 from enum import StrEnum
 from typing import Generator, List, Optional, Self, Tuple
 
@@ -18,7 +18,8 @@ from fabricatio.models.generic import (
     Titled,
     WordCount,
 )
-from fabricatio.rust import comment
+from fabricatio.rust import split_out_metadata, to_metadata, word_count
+from fabricatio.utils import fallback_kwargs
 from pydantic import Field
 
 
@@ -46,14 +47,49 @@ class ArticleMetaData(SketchedAble, Described, WordCount, Titled, Language):
     aims: List[str]
     """List of writing aims of the research component in academic style."""
 
+    @property
+    def typst_metadata_comment(self) -> str:
+        """Generates a comment for the metadata of the article component."""
+        return to_metadata(self.model_dump(include={"description", "aims", "expected_word_count"}, by_alias=True))
+
+
+class FromTypstCode(ArticleMetaData):
+    """Base class for article components that can be created from a Typst code snippet."""
+
+    @classmethod
+    def from_typst_code(cls, title: str, body: str, **kwargs) -> Self:
+        """Converts a Typst code snippet into an article component."""
+        data, body = split_out_metadata(body)
+
+        return cls(
+            heading=title,
+            **fallback_kwargs(
+                data or {},
+                elaboration="",
+                expected_word_count=word_count(body),
+                aims=[],
+            ),
+            **kwargs,
+        )
+
+
+class ToTypstCode(ArticleMetaData):
+    """Base class for article components that can be converted to a Typst code snippet."""
+
+    def to_typst_code(self) -> str:
+        """Converts the component into a Typst code snippet for rendering."""
+        return f"{self.title}\n{self.typst_metadata_comment}\n"
+
 
 class ArticleOutlineBase(
-    ArticleMetaData,
     ResolveUpdateConflict,
     ProposedUpdateAble,
     PersistentAble,
     ModelHash,
     Introspect,
+    FromTypstCode,
+    ToTypstCode,
+    ABC,
 ):
     """Base class for article outlines."""
 
@@ -79,23 +115,13 @@ class ArticleOutlineBase(
         """Updates the current instance with the attributes of another instance."""
         return self.update_metadata(other)
 
-    @abstractmethod
-    def to_typst_code(self) -> str:
-        """Converts the component into a Typst code snippet for rendering."""
-
 
 class SubSectionBase(ArticleOutlineBase):
     """Base class for article sections and subsections."""
 
     def to_typst_code(self) -> str:
         """Converts the component into a Typst code snippet for rendering."""
-        return (
-            f"=== {self.title}\n"
-            f"{comment(f'Desc:\n{self.description}\nAims:\n{"\n".join(self.aims)}')}\n"
-            + f"Expected Word Count:{self.expected_word_count}"
-            if self.expected_word_count
-            else ""
-        )
+        return f"=== {super().to_typst_code()}"
 
     def introspect(self) -> str:
         """Introspects the article subsection outline."""
@@ -120,13 +146,7 @@ class SectionBase[T: SubSectionBase](ArticleOutlineBase):
         Returns:
             str: The formatted Typst code snippet.
         """
-        return (
-            f"== {self.title}\n"
-            f"{comment(f'Desc:\n{self.description}\nAims:\n{"\n".join(self.aims)}')}\n"
-            + f"Expected Word Count:{self.expected_word_count}"
-            if self.expected_word_count
-            else ""
-        ) + "\n\n".join(subsec.to_typst_code() for subsec in self.subsections)
+        return f"== {super().to_typst_code()}" + "\n\n".join(subsec.to_typst_code() for subsec in self.subsections)
 
     def resolve_update_conflict(self, other: Self) -> str:
         """Resolve update errors in the article outline."""
@@ -169,13 +189,7 @@ class ChapterBase[T: SectionBase](ArticleOutlineBase):
 
     def to_typst_code(self) -> str:
         """Converts the chapter into a Typst formatted code snippet for rendering."""
-        return (
-            f"= {self.title}\n"
-            f"{comment(f'Desc:\n{self.description}\nAims:\n{"\n".join(self.aims)}')}\n"
-            + f"Expected Word Count:{self.expected_word_count}"
-            if self.expected_word_count
-            else ""
-        ) + "\n\n".join(sec.to_typst_code() for sec in self.sections)
+        return f"= {super().to_typst_code()}" + "\n\n".join(sec.to_typst_code() for sec in self.sections)
 
     def resolve_update_conflict(self, other: Self) -> str:
         """Resolve update errors in the article outline."""
@@ -207,12 +221,13 @@ class ChapterBase[T: SectionBase](ArticleOutlineBase):
         return ""
 
 
-class ArticleBase[T: ChapterBase](FinalizedDumpAble, AsPrompt, WordCount, Described, Titled, Language, ABC):
+class ArticleBase[T: ChapterBase](FinalizedDumpAble, AsPrompt, FromTypstCode, ToTypstCode, ABC):
     """Base class for article outlines."""
 
-    title: str = Field(alias="heading", description=Titled.model_fields["title"].description)
-    description: str = Field(alias="abstract")
-    """The abstract serves as a concise summary of an academic article, encapsulating its core purpose, methodologies, key results,
+    description: str = Field(
+        alias="elaboration",
+    )
+    """The abstract of this article, which serves as a concise summary of an academic article, encapsulating its core purpose, methodologies, key results,
     and conclusions while enabling readers to rapidly assess the relevance and significance of the study.
     Functioning as the article's distilled essence, it succinctly articulates the research problem, objectives,
     and scope, providing a roadmap for the full text while also facilitating database indexing, literature reviews,
@@ -297,6 +312,10 @@ class ArticleBase[T: ChapterBase](FinalizedDumpAble, AsPrompt, WordCount, Descri
         for _, _, subsec in self.iter_subsections():
             yield subsec.title
 
+    def to_typst_code(self) -> str:
+        """Generates the Typst code representation of the article."""
+        return f"// #{super().to_typst_code()}\n\n" + "\n\n".join(a.to_typst_code() for a in self.chapters)
+
     def finalized_dump(self) -> str:
         """Generates standardized hierarchical markup for academic publishing systems.
 
@@ -317,8 +336,31 @@ class ArticleBase[T: ChapterBase](FinalizedDumpAble, AsPrompt, WordCount, Descri
             === Implementation Details
             == Evaluation Protocol
         """
-        return comment(
-            f"Title:{self.title}\nDesc:\n{self.description}\n" + f"Word Count:{self.expected_word_count}"
-            if self.expected_word_count
-            else ""
-        ) + "\n\n".join(a.to_typst_code() for a in self.chapters)
+        return self.to_typst_code()
+
+    def avg_chap_wordcount[S: "ArticleBase"](self: S) -> S:
+        """Set all chap have same word count sum up to be `self.expected_word_count`."""
+        avg = int(self.expected_word_count / len(self.chapters))
+        for c in self.chapters:
+            c.expected_word_count = avg
+        return self
+
+    def avg_sec_wordcount[S: "ArticleBase"](self: S) -> S:
+        """Set all sec have same word count sum up to be `self.expected_word_count`."""
+        for c in self.chapters:
+            avg = int(c.expected_word_count / len(c.sections))
+            for s in c.sections:
+                s.expected_word_count = avg
+        return self
+
+    def avg_subsec_wordcount[S: "ArticleBase"](self: S) -> S:
+        """Set all subsec have same word count sum up to be `self.expected_word_count`."""
+        for _, s in self.iter_sections():
+            avg = int(s.expected_word_count / len(s.subsections))
+            for ss in s.subsections:
+                ss.expected_word_count = avg
+        return self
+
+    def avg_wordcount_recursive[S: "ArticleBase"](self: S) -> S:
+        """Set all chap, sec, subsec have same word count sum up to be `self.expected_word_count`."""
+        return self.avg_chap_wordcount().avg_sec_wordcount().avg_subsec_wordcount()

fabricatio/models/extra/article_main.py

@@ -12,13 +12,22 @@ from fabricatio.models.extra.article_base import (
     SubSectionBase,
 )
 from fabricatio.models.extra.article_outline import (
+    ArticleChapterOutline,
     ArticleOutline,
+    ArticleSectionOutline,
+    ArticleSubsectionOutline,
 )
 from fabricatio.models.generic import Described, PersistentAble, SequencePatch, SketchedAble, WithRef, WordCount
-from fabricatio.rust import convert_all_block_tex, convert_all_inline_tex, word_count
+from fabricatio.rust import (
+    convert_all_block_tex,
+    convert_all_inline_tex,
+    fix_misplaced_labels,
+    split_out_metadata,
+    word_count,
+)
 from pydantic import Field, NonNegativeInt
 
-PARAGRAPH_SEP = "// - - -"
+PARAGRAPH_SEP = "\n\n// - - -\n\n"
 
 
 class Paragraph(SketchedAble, WordCount, Described):
@@ -89,17 +98,17 @@ class ArticleSubsection(SubSectionBase):
         Returns:
             str: Typst code snippet for rendering.
         """
-        return f"=== {self.title}\n" + f"\n{PARAGRAPH_SEP}\n".join(p.content for p in self.paragraphs)
+        return super().to_typst_code() + PARAGRAPH_SEP.join(p.content for p in self.paragraphs)
 
     @classmethod
-    def from_typst_code(cls, title: str, body: str) -> Self:
+    def from_typst_code(cls, title: str, body: str, **kwargs) -> Self:
         """Creates an Article object from the given Typst code."""
-        return cls(
-            heading=title,
-            elaboration="",
-            paragraphs=[Paragraph.from_content(p) for p in body.split(PARAGRAPH_SEP)],
-            expected_word_count=word_count(body),
-            aims=[],
+        _, para_body = split_out_metadata(body)
+
+        return super().from_typst_code(
+            title,
+            body,
+            paragraphs=[Paragraph.from_content(p) for p in para_body.split(PARAGRAPH_SEP)],
         )
 
 
@@ -107,16 +116,14 @@ class ArticleSection(SectionBase[ArticleSubsection]):
     """Atomic argumentative unit with high-level specificity."""
 
     @classmethod
-    def from_typst_code(cls, title: str, body: str) -> Self:
+    def from_typst_code(cls, title: str, body: str, **kwargs) -> Self:
         """Creates an Article object from the given Typst code."""
-        return cls(
+        return super().from_typst_code(
+            title,
+            body,
             subsections=[
                 ArticleSubsection.from_typst_code(*pack) for pack in extract_sections(body, level=3, section_char="=")
             ],
-            heading=title,
-            elaboration="",
-            expected_word_count=word_count(body),
-            aims=[],
         )
 
 
@@ -124,21 +131,18 @@ class ArticleChapter(ChapterBase[ArticleSection]):
     """Thematic progression implementing research function."""
 
     @classmethod
-    def from_typst_code(cls, title: str, body: str) -> Self:
+    def from_typst_code(cls, title: str, body: str, **kwargs) -> Self:
         """Creates an Article object from the given Typst code."""
-        return cls(
+        return super().from_typst_code(
+            title,
+            body,
             sections=[
                 ArticleSection.from_typst_code(*pack) for pack in extract_sections(body, level=2, section_char="=")
             ],
-            heading=title,
-            elaboration="",
-            expected_word_count=word_count(body),
-            aims=[],
         )
 
 
 class Article(
-    SketchedAble,
     WithRef[ArticleOutline],
     PersistentAble,
     ArticleBase[ArticleChapter],
@@ -157,30 +161,70 @@ class Article(
             "Original Article": self.display(),
         }
 
-    def convert_tex(self) -> Self:
+    def convert_tex(self, paragraphs: bool = True, descriptions: bool = True) -> Self:
         """Convert tex to typst code."""
-        for _, _, subsec in self.iter_subsections():
-            for p in subsec.paragraphs:
-                p.content = convert_all_inline_tex(p.content)
-                p.content = convert_all_block_tex(p.content)
-        return self
-
-    def fix_wrapper(self) -> Self:
-        """Fix wrapper."""
-        for _, _, subsec in self.iter_subsections():
-            for p in subsec.paragraphs:
-                p.content = (
-                    p.content.replace(r" \( ", "$")
-                    .replace(r" \) ", "$")
-                    .replace("\\[\n", "$$\n")
-                    .replace("\n\\]", "\n$$")
-                )
+        if descriptions:
+            for a in self.iter_dfs():
+                a.description = fix_misplaced_labels(a.description)
+                a.description = convert_all_inline_tex(a.description)
+                a.description = convert_all_block_tex(a.description)
+
+        if paragraphs:
+            for _, _, subsec in self.iter_subsections():
+                for p in subsec.paragraphs:
+                    p.content = fix_misplaced_labels(p.content)
+                    p.content = convert_all_inline_tex(p.content)
+                    p.content = convert_all_block_tex(p.content)
         return self
 
     @override
     def iter_subsections(self) -> Generator[Tuple[ArticleChapter, ArticleSection, ArticleSubsection], None, None]:
         return super().iter_subsections()  # pyright: ignore [reportReturnType]
 
+    def extrac_outline(self) -> ArticleOutline:
+        """Extract outline from article."""
+        # Create an empty list to hold chapter outlines
+        chapters = []
+
+        # Iterate through each chapter in the article
+        for chapter in self.chapters:
+            # Create an empty list to hold section outlines
+            sections = []
+
+            # Iterate through each section in the chapter
+            for section in chapter.sections:
+                # Create an empty list to hold subsection outlines
+                subsections = []
+
+                # Iterate through each subsection in the section
+                for subsection in section.subsections:
+                    # Create a subsection outline and add it to the list
+                    subsections.append(
+                        ArticleSubsectionOutline(**subsection.model_dump(exclude={"paragraphs"}, by_alias=True))
+                    )
+
+                # Create a section outline and add it to the list
+                sections.append(
+                    ArticleSectionOutline(
+                        **section.model_dump(exclude={"subsections"}, by_alias=True),
+                        subsections=subsections,
+                    )
+                )
+
+            # Create a chapter outline and add it to the list
+            chapters.append(
+                ArticleChapterOutline(
+                    **chapter.model_dump(exclude={"sections"}, by_alias=True),
+                    sections=sections,
+                )
+            )
+
+        # Create and return the article outline
+        return ArticleOutline(
+            **self.model_dump(exclude={"chapters"}, by_alias=True),
+            chapters=chapters,
+        )
+
     @classmethod
     def from_outline(cls, outline: ArticleOutline) -> "Article":
         """Generates an article from the given outline.
@@ -218,15 +262,14 @@ class Article(
         return article
 
     @classmethod
-    def from_typst_code(cls, title: str, body: str) -> Self:
+    def from_typst_code(cls, title: str, body: str, **kwargs) -> Self:
         """Generates an article from the given Typst code."""
-        return cls(
+        return super().from_typst_code(
+            title,
+            body,
             chapters=[
                 ArticleChapter.from_typst_code(*pack) for pack in extract_sections(body, level=1, section_char="=")
             ],
-            heading=title,
-            expected_word_count=word_count(body),
-            abstract="",
         )
 
     @classmethod
@@ -248,3 +291,4 @@ class Article(
 
         for a in self.iter_dfs():
             a.title = await text(f"Edit `{a.title}`.", default=a.title).ask_async() or a.title
+        return self

fabricatio/models/extra/article_outline.py

@@ -1,7 +1,8 @@
 """A module containing the ArticleOutline class, which represents the outline of an academic paper."""
 
-from typing import Dict
+from typing import Dict, Self
 
+from fabricatio.fs.readers import extract_sections
 from fabricatio.models.extra.article_base import (
     ArticleBase,
     ChapterBase,
@@ -9,7 +10,7 @@ from fabricatio.models.extra.article_base import (
     SubSectionBase,
 )
 from fabricatio.models.extra.article_proposal import ArticleProposal
-from fabricatio.models.generic import PersistentAble, SketchedAble, WithRef
+from fabricatio.models.generic import PersistentAble, WithRef
 
 
 class ArticleSubsectionOutline(SubSectionBase):
@@ -18,14 +19,39 @@ class ArticleSubsectionOutline(SubSectionBase):
 
 class ArticleSectionOutline(SectionBase[ArticleSubsectionOutline]):
     """A slightly more detailed research component specification for academic paper generation, Must contain subsections."""
+    @classmethod
+    def from_typst_code(cls, title: str, body: str, **kwargs) -> Self:
+        """Parse the given Typst code into an ArticleSectionOutline instance."""
+        return super().from_typst_code(
+            title,
+            body,
+            subsections=[
+                ArticleSubsectionOutline.from_typst_code(*pack)
+                for pack in extract_sections(body, level=3, section_char="=")
+            ],
+        )
+
 
 
 class ArticleChapterOutline(ChapterBase[ArticleSectionOutline]):
     """Macro-structural unit implementing standard academic paper organization. Must contain sections."""
 
+    @classmethod
+    def from_typst_code(cls, title: str, body: str, **kwargs) -> Self:
+        """Parse the given Typst code into an ArticleChapterOutline instance."""
+        return super().from_typst_code(
+            title,
+            body,
+            sections=[
+                ArticleSectionOutline.from_typst_code(*pack)
+                for pack in extract_sections(body, level=2, section_char="=")
+            ],
+
+        )
+
+
 
 class ArticleOutline(
-    SketchedAble,
     WithRef[ArticleProposal],
     PersistentAble,
     ArticleBase[ArticleChapterOutline],
@@ -38,3 +64,15 @@ class ArticleOutline(
             "Original Article Proposal": self.referenced.display(),
             "Original Article Outline": self.display(),
         }
+
+    @classmethod
+    def from_typst_code(cls, title: str, body: str, **kwargs) -> Self:
+        """Parse the given Typst code into an ArticleOutline instance."""
+        return super().from_typst_code(
+            title,
+            body,
+            chapters=[
+                ArticleChapterOutline.from_typst_code(*pack)
+                for pack in extract_sections(body, level=1, section_char="=")
+            ],
+        )

fabricatio/models/generic.py

@@ -122,7 +122,7 @@ class FromMapping(Base):
 
     @classmethod
     @abstractmethod
-    def from_mapping(cls, mapping: Mapping[str, Any], **kwargs: Any) -> List[Self]:
+    def from_mapping[S](cls: S, mapping: Mapping[str, Any], **kwargs: Any) -> List[S]:
         """Generate a list of objects from a mapping."""
 
 
@@ -186,7 +186,7 @@ class WithRef[T](Base):
     @overload
     def update_ref[S: WithRef](self: S, reference: None = None) -> S: ...
 
-    def update_ref[S: WithRef](self: S, reference: Union[T, "WithRef[T]", None] = None) -> S:  # noqa: PYI019
+    def update_ref[S: WithRef](self: S, reference: Union[T, "WithRef[T]", None] = None) -> S:
         """Update the reference of the object.
 
         Args:
@@ -201,7 +201,7 @@ class WithRef[T](Base):
             self._reference = reference  # pyright: ignore [reportAttributeAccessIssue]
         return self
 
-    def derive[S: WithRef](self: S, reference: Any) -> S:  # noqa: PYI019
+    def derive[S: WithRef](self: S, reference: Any) -> S:
         """Derive a new object from the current object.
 
         Args:
@@ -789,7 +789,7 @@ class ScopedConfig(Base):
     """The dimensions of the Milvus server."""
 
     @final
-    def fallback_to(self, other: "ScopedConfig") -> Self:
+    def fallback_to(self, other: Union["ScopedConfig", Any]) -> Self:
         """Merge configuration values with fallback priority.
 
         Copies non-null values from 'other' to self where current values are None.
@@ -800,6 +800,9 @@ class ScopedConfig(Base):
         Returns:
             Self: Current instance with merged values
         """
+        if not isinstance(other, ScopedConfig):
+            return self
+
         # Iterate over the attribute names and copy values from 'other' to 'self' where applicable
         # noinspection PydanticTypeChecker,PyTypeChecker
         for attr_name in ScopedConfig.model_fields:
@@ -811,7 +814,7 @@ class ScopedConfig(Base):
         return self
 
     @final
-    def hold_to(self, others: Union["ScopedConfig", Iterable["ScopedConfig"]]) -> Self:
+    def hold_to(self, others: Union[Union["ScopedConfig", Any], Iterable[Union["ScopedConfig", Any]]]) -> Self:
         """Propagate non-null values to other configurations.
 
         Copies current non-null values to target configurations where they are None.
@@ -824,7 +827,8 @@ class ScopedConfig(Base):
         """
         if not isinstance(others, Iterable):
             others = [others]
-        for other in others:
+
+        for other in (o for o in others if isinstance(o, ScopedConfig)):
             # noinspection PyTypeChecker,PydanticTypeChecker
             for attr_name in ScopedConfig.model_fields:
                 if (attr := getattr(self, attr_name)) is not None and getattr(other, attr_name) is None:

fabricatio/models/kwargs_types.py

@@ -33,7 +33,7 @@ class LLMKwargs(TypedDict, total=False):
     including generation parameters and caching options.
     """
 
-    model: str
+    model: Optional[str]
     temperature: float
     stop: str | list[str]
     top_p: float