fabricatio 0.2.7.dev4__cp312-cp312-win_amd64.whl → 0.2.8.dev0__cp312-cp312-win_amd64.whl

fabricatio/models/extra/article_main.py

@@ -1,13 +1,12 @@
 """ArticleBase and ArticleSubsection classes for managing hierarchical document components."""
 
 from itertools import chain
-from typing import Generator, List, Self, Tuple
+from typing import Generator, List, Self, Tuple, override
 
 from fabricatio.journal import logger
 from fabricatio.models.extra.article_base import (
     ArticleBase,
-    ArticleMainBase,
-    ArticleRef,
+    ArticleOutlineBase,
     ChapterBase,
     SectionBase,
     SubSectionBase,
@@ -28,26 +27,28 @@ class Paragraph(CensoredAble):
     writing_aim: List[str]
     """Specific communicative objectives for this paragraph's content."""
 
-    sentences: List[str]
-    """List of sentences forming the paragraph's content."""
+    content: str
+    """The actual content of the paragraph, represented as a string."""
 
 
-class ArticleSubsection(ArticleMainBase, SubSectionBase):
+class ArticleSubsection(SubSectionBase):
     """Atomic argumentative unit with technical specificity."""
 
     paragraphs: List[Paragraph]
     """List of Paragraph objects containing the content of the subsection."""
 
-    def resolve_update_error(self, other: Self) -> str:
-        """Resolve update errors in the article outline."""
-        if self.title != other.title:
-            return f"Title `{other.title}` mismatched, expected `{self.title}`. "
+    def introspect(self) -> str:
+        """Introspects the subsection and returns a message if it has no paragraphs."""
+        if len(self.paragraphs) == 0:
+            return f"`{self.__class__.__name__}` titled `{self.title}` have no paragraphs, to achieve the goal of `{self.writing_aim}`."
         return ""
 
-    def _update_from_inner(self, other: Self) -> Self:
+    def update_from_inner(self, other: Self) -> Self:
         """Updates the current instance with the attributes of another instance."""
         logger.debug(f"Updating SubSection {self.title}")
-        self.paragraphs = other.paragraphs
+        super().update_from_inner(other)
+        self.paragraphs.clear()
+        self.paragraphs.extend(other.paragraphs)
         return self
 
     def to_typst_code(self) -> str:
@@ -56,102 +57,33 @@ class ArticleSubsection(ArticleMainBase, SubSectionBase):
         Returns:
             str: Typst code snippet for rendering.
         """
-        return f"=== {self.title}\n" + "\n\n".join("".join(p.sentences) for p in self.paragraphs)
+        return f"=== {self.title}\n" + "\n\n".join(p.content for p in self.paragraphs)
 
 
-class ArticleSection(ArticleMainBase, SectionBase[ArticleSubsection]):
+class ArticleSection(SectionBase[ArticleSubsection]):
     """Atomic argumentative unit with high-level specificity."""
 
-    def resolve_update_error(self, other: Self) -> str:
-        """Resolve update errors in the article outline."""
-        if (s_len := len(self.subsections)) == 0:
-            return ""
 
-        if s_len != len(other.subsections):
-            return f"Subsections length mismatched, expected {len(self.subsections)}, got {len(other.subsections)}"
-
-        sub_sec_err_seq = [
-            out for s, o in zip(self.subsections, other.subsections, strict=True) if (out := s.resolve_update_error(o))
-        ]
-
-        if sub_sec_err_seq:
-            return "\n".join(sub_sec_err_seq)
-        return ""
-
-    def _update_from_inner(self, other: Self) -> Self:
-        """Updates the current instance with the attributes of another instance."""
-        if len(self.subsections) == 0:
-            self.subsections = other.subsections
-            return self
-
-        for self_subsec, other_subsec in zip(self.subsections, other.subsections, strict=True):
-            self_subsec.update_from(other_subsec)
-        return self
-
-    def to_typst_code(self) -> str:
-        """Converts the section into a Typst formatted code snippet.
-
-        Returns:
-            str: The formatted Typst code snippet.
-        """
-        return f"== {self.title}\n" + "\n\n".join(subsec.to_typst_code() for subsec in self.subsections)
-
-
-class ArticleChapter(ArticleMainBase, ChapterBase[ArticleSection]):
+class ArticleChapter(ChapterBase[ArticleSection]):
     """Thematic progression implementing research function."""
 
-    def resolve_update_error(self, other: Self) -> str:
-        """Resolve update errors in the article outline."""
-        if (s_len := len(self.sections)) == 0:
-            return ""
-
-        if s_len != len(other.sections):
-            return f"Sections length mismatched, expected {len(self.sections)}, got {len(other.sections)}"
-        sec_err_seq = [
-            out for s, o in zip(self.sections, other.sections, strict=True) if (out := s.resolve_update_error(o))
-        ]
-        if sec_err_seq:
-            return "\n".join(sec_err_seq)
-        return ""
-
-    def _update_from_inner(self, other: Self) -> Self:
-        """Updates the current instance with the attributes of another instance."""
-        if len(self.sections) == 0:
-            self.sections = other.sections
-            return self
-
-        for self_sec, other_sec in zip(self.sections, other.sections, strict=True):
-            self_sec.update_from(other_sec)
-        return self
-
-    def to_typst_code(self) -> str:
-        """Converts the chapter into a Typst formatted code snippet for rendering."""
-        return f"= {self.title}\n" + "\n\n".join(sec.to_typst_code() for sec in self.sections)
-
 
-class Article(Display, CensoredAble, WithRef[ArticleOutline], PersistentAble, ArticleBase[ArticleChapter]):
+class Article(
+    Display,
+    CensoredAble,
+    WithRef[ArticleOutline],
+    PersistentAble,
+    ArticleBase[ArticleChapter],
+):
     """Represents a complete academic paper specification, incorporating validation constraints.
 
     This class integrates display, censorship processing, article structure referencing, and persistence capabilities,
     aiming to provide a comprehensive model for academic papers.
     """
 
-    abstract: str
-    """Contains a summary of the academic paper."""
-
-    title: str
-    """Represents the title of the academic paper."""
-
-    language: str
-    """Written language of the article. SHALL be aligned to the language of the article outline provided."""
-
-    def finalized_dump(self) -> str:
-        """Exports the article in `typst` format.
-
-        Returns:
-                str: Strictly formatted outline with typst formatting.
-        """
-        return "\n\n".join(c.to_typst_code() for c in self.chapters)
+    @override
+    def iter_subsections(self) -> Generator[Tuple[ArticleChapter, ArticleSection, ArticleSubsection], None, None]:
+        return super().iter_subsections()
 
     @classmethod
     def from_outline(cls, outline: ArticleOutline) -> "Article":
@@ -164,7 +96,7 @@ class Article(Display, CensoredAble, WithRef[ArticleOutline], PersistentAble, Ar
             Article: The generated article.
         """
         # Set the title from the outline
-        article = Article(**outline.model_dump(include={"title", "abstract"}), chapters=[])
+        article = Article(**outline.model_dump(exclude={"chapters"}), chapters=[])
 
         for chapter in outline.chapters:
             # Create a new chapter
@@ -189,48 +121,25 @@ class Article(Display, CensoredAble, WithRef[ArticleOutline], PersistentAble, Ar
             article.chapters.append(article_chapter)
         return article
 
-    def iter_dfs(self) -> Generator[ArticleMainBase, None, None]:
-        """Performs a depth-first search (DFS) through the article structure.
-
-        Returns:
-            Generator[ArticleMainBase]: Each component in the article structure.
-        """
-        for chap in self.chapters:
-            for sec in chap.sections:
-                yield from sec.subsections
-                yield sec
-            yield chap
-
-    def deref(self, ref: ArticleRef) -> ArticleMainBase:
-        """Resolves a reference to the corresponding section or subsection in the article.
-
-        Args:
-            ref (ArticleRef): The reference to resolve.
-
-        Returns:
-            ArticleMainBase: The corresponding section or subsection.
-        """
-        return ok(ref.deref(self), f"{ref} not found in {self.title}")
-
-    def gather_dependencies(self, article: ArticleMainBase) -> List[ArticleMainBase]:
+    def gather_dependencies(self, article: ArticleOutlineBase) -> List[ArticleOutlineBase]:
         """Gathers dependencies for all sections and subsections in the article.
 
         This method should be called after the article is fully constructed.
         """
-        depends = [self.deref(a) for a in article.depend_on]
+        depends = [ok(a.deref(self)) for a in article.depend_on]
 
         supports = []
-        for a in self.iter_dfs():
-            if article in {self.deref(b) for b in a.support_to}:
+        for a in self.iter_dfs_rev():
+            if article in {ok(b.deref(self)) for b in a.support_to}:
                 supports.append(a)
 
         return list(set(depends + supports))
 
-    def gather_dependencies_recursive(self, article: ArticleMainBase) -> List[ArticleMainBase]:
+    def gather_dependencies_recursive(self, article: ArticleOutlineBase) -> List[ArticleOutlineBase]:
         """Gathers all dependencies recursively for the given article.
 
         Args:
-            article (ArticleMainBase): The article to gather dependencies for.
+            article (ArticleOutlineBase): The article to gather dependencies for.
 
         Returns:
             List[ArticleBase]: A list of all dependencies for the given article.
@@ -269,7 +178,7 @@ class Article(Display, CensoredAble, WithRef[ArticleOutline], PersistentAble, Ar
 
     def iter_dfs_with_deps(
         self, chapter: bool = True, section: bool = True, subsection: bool = True
-    ) -> Generator[Tuple[ArticleMainBase, List[ArticleMainBase]], None, None]:
+    ) -> Generator[Tuple[ArticleOutlineBase, List[ArticleOutlineBase]], None, None]:
         """Iterates through the article in a depth-first manner, yielding each component and its dependencies.
 
         Args:
@@ -283,7 +192,7 @@ class Article(Display, CensoredAble, WithRef[ArticleOutline], PersistentAble, Ar
         if all((not chapter, not section, not subsection)):
             raise ValueError("At least one of chapter, section, or subsection must be True.")
 
-        for component in self.iter_dfs():
+        for component in self.iter_dfs_rev():
             if not chapter and isinstance(component, ArticleChapter):
                 continue
             if not section and isinstance(component, ArticleSection):

fabricatio/models/extra/article_outline.py

@@ -1,30 +1,25 @@
 """A module containing the ArticleOutline class, which represents the outline of an academic paper."""
 
-from typing import Generator, List, Optional, Tuple, Union
-
-import regex
 from fabricatio.models.extra.article_base import (
     ArticleBase,
-    ArticleOutlineBase,
     ChapterBase,
     SectionBase,
     SubSectionBase,
 )
 from fabricatio.models.extra.article_proposal import ArticleProposal
 from fabricatio.models.generic import CensoredAble, Display, PersistentAble, WithRef
-from fabricatio.models.utils import ok
 
 
-class ArticleSubsectionOutline(ArticleOutlineBase, SubSectionBase):
+class ArticleSubsectionOutline(SubSectionBase):
     """Atomic research component specification for academic paper generation."""
 
 
-class ArticleSectionOutline(ArticleOutlineBase, SectionBase[ArticleSubsectionOutline]):
-    """A slightly more detailed research component specification for academic paper generation."""
+class ArticleSectionOutline(SectionBase[ArticleSubsectionOutline]):
+    """A slightly more detailed research component specification for academic paper generation, Must contain subsections."""
 
 
-class ArticleChapterOutline(ArticleOutlineBase, ChapterBase[ArticleSectionOutline]):
-    """Macro-structural unit implementing standard academic paper organization."""
+class ArticleChapterOutline(ChapterBase[ArticleSectionOutline]):
+    """Macro-structural unit implementing standard academic paper organization. Must contain sections."""
 
 
 class ArticleOutline(
@@ -34,148 +29,4 @@ class ArticleOutline(
     PersistentAble,
     ArticleBase[ArticleChapterOutline],
 ):
-    """Complete academic paper blueprint with hierarchical validation."""
-
-    abstract: str
-    """The abstract is a concise summary of the academic paper's main findings."""
-
-    prospect: str
-    """Consolidated research statement with four pillars:
-    1. Problem Identification: Current limitations
-    2. Methodological Response: Technical approach
-    3. Empirical Validation: Evaluation strategy
-    4. Scholarly Impact: Field contributions
-    """
-
-    title: str
-    """Title of the academic paper."""
-
-    language: str
-    """Written language of the article. SHALL be aligned to the language of the article proposal provided."""
-
-    def finalized_dump(self) -> str:
-        """Generates standardized hierarchical markup for academic publishing systems.
-
-        Implements ACL 2024 outline conventions with four-level structure:
-        = Chapter Title (Level 1)
-        == Section Title (Level 2)
-        === Subsection Title (Level 3)
-        ==== Subsubsection Title (Level 4)
-
-        Returns:
-            str: Strictly formatted outline with academic sectioning
-
-        Example:
-            = Methodology
-            == Neural Architecture Search Framework
-            === Differentiable Search Space
-            ==== Constrained Optimization Parameters
-            === Implementation Details
-            == Evaluation Protocol
-        """
-        lines: List[str] = []
-        for i, chapter in enumerate(self.chapters, 1):
-            lines.append(f"= Chapter {i}: {chapter.title}")
-            for j, section in enumerate(chapter.sections, 1):
-                lines.append(f"== {i}.{j} {section.title}")
-                for k, subsection in enumerate(section.subsections, 1):
-                    lines.append(f"=== {i}.{j}.{k} {subsection.title}")
-        return "\n".join(lines)
-
-    def iter_dfs(self) -> Generator[ArticleOutlineBase, None, None]:
-        """Iterates through the article outline in a depth-first manner.
-
-        Returns:
-            ArticleOutlineBase: Each component in the article outline.
-        """
-        for chapter in self.chapters:
-            for section in chapter.sections:
-                yield from section.subsections
-                yield section
-            yield chapter
-
-    def resolve_ref_error(self) -> str:
-        """Resolve reference errors in the article outline.
-
-        Returns:
-            str: Error message indicating reference errors in the article outline.
-
-        Notes:
-            This function is designed to find all invalid `ArticleRef` objs in `depend_on` and `support_to` fields, which will be added to the final error summary.
-        """
-        summary = ""
-        for component in self.iter_dfs():
-            for ref in component.depend_on:
-                if not ref.deref(self):
-                    summary += f"Invalid internal reference in {component.__class__.__name__} titled `{component.title}` at `depend_on` field, because the referred {ref.referring_type} is not exists within the article, see the original obj dump: {ref.model_dump()}\n"
-            for ref in component.support_to:
-                if not ref.deref(self):
-                    summary += f"Invalid internal reference in {component.__class__.__name__} titled `{component.title}` at `support_to` field, because the referred {ref.referring_type} is not exists within the article, see the original obj dump: {ref.model_dump()}\n"
-
-        return summary
-
-    @classmethod
-    def from_typst_code(
-        cls, typst_code: str, title: str = "", article_language: str = "en", prospect: str = "", abstract: str = ""
-    ) -> "ArticleOutline":
-        """Parses a Typst code string and creates an ArticleOutline instance."""
-        self = cls(language=article_language, prospect=prospect, abstract=abstract, chapters=[], title=title)
-        stack = [self]  # 根节点为ArticleOutline实例
-
-        for line in typst_code.splitlines():
-            parsed = cls._parse_line(line)
-            if not parsed:
-                continue
-            level, title = parsed
-            cls._adjust_stack(stack, level)
-            parent = stack[-1]
-            component = cls._create_component(level, title)
-            cls._add_to_parent(parent, component, level)
-            stack.append(component)
-
-        return self
-
-    @classmethod
-    def _parse_line(cls, line: str) -> Optional[Tuple[int, str]]:
-        stripped = line.strip()
-        if not stripped.startswith("="):
-            return None
-        match = regex.match(r"^(\=+)(.*)", stripped)
-        if not match:
-            return None
-        eqs, title_part = match.groups()
-        return len(eqs), title_part.strip()
-
-    @classmethod
-    def _adjust_stack(cls, stack: List[object], target_level: int) -> None:
-        while len(stack) > target_level:
-            stack.pop()
-
-    @classmethod
-    def _create_component(cls, level: int, title: str) -> ArticleOutlineBase:
-        default_kwargs = {
-            "writing_aim": [],
-            "depend_on": [],
-            "support_to": [],
-            "description": [],
-        }
-        component_map = {
-            1: lambda: ArticleChapterOutline(title=title, sections=[], **default_kwargs),
-            2: lambda: ArticleSectionOutline(title=title, subsections=[], **default_kwargs),
-            3: lambda: ArticleSubsectionOutline(title=title, **default_kwargs),
-        }
-        return ok(component_map.get(level, lambda: None)(), "Invalid level")
-
-    @classmethod
-    def _add_to_parent(
-        cls,
-        parent: Union["ArticleOutline", ArticleChapterOutline, ArticleSectionOutline],
-        component: ArticleOutlineBase,
-        level: int,
-    ) -> None:
-        if level == 1 and isinstance(component, ArticleChapterOutline):
-            parent.chapters.append(component)
-        elif level == 2 and isinstance(component, ArticleSectionOutline):  # noqa: PLR2004
-            parent.sections.append(component)
-        elif level == 3 and isinstance(component, ArticleSubsectionOutline):  # noqa: PLR2004
-            parent.subsections.append(component)
+    """Outline of an academic paper, containing chapters, sections, subsections."""

fabricatio/models/extra/article_proposal.py

@@ -11,25 +11,23 @@ class ArticleProposal(CensoredAble, Display, WithRef[str], AsPrompt, PersistentA
     Guides LLM in generating comprehensive research proposals with clearly defined components.
     """
 
+    language: str
+    """The language in which the article is written. This should align with the language specified in the article briefing."""
+
+    title: str
+    """The title of the academic paper, formatted in Title Case."""
+
+    focused_problem: List[str]
+    """A list of specific research problems or questions that the paper aims to address."""
+
     technical_approaches: List[str]
-    """Technical approaches"""
+    """A list of technical approaches or methodologies used to solve the research problems."""
 
     research_methods: List[str]
-    """Methodological components (list of techniques/tools).
-    Example: ['Differentiable architecture search', 'Transformer-based search space', 'Multi-lingual perplexity evaluation']"""
+    """A list of methodological components, including techniques and tools utilized in the research."""
 
     research_aim: List[str]
-    """Primary research objectives (list of 2-4 measurable goals).
-    Example: ['Develop parameter-efficient NAS framework', 'Establish cross-lingual architecture transfer metrics']"""
-
-    focused_problem: List[str]
-    """Specific research problem(s) or question(s) addressed (list of 1-3 concise statements).
-    Example: ['NAS computational overhead in low-resource settings', 'Architecture transferability across language pairs']"""
-
-    title: str
-    """Paper title in academic style (Title Case, 8-15 words). Example: 'Exploring Neural Architecture Search for Low-Resource Machine Translation'"""
-    language: str
-    """Written language of the article. SHALL be aligned to the language of the article briefing provided."""
+    """A list of primary research objectives that the paper seeks to achieve."""
 
     def _as_prompt_inner(self) -> Dict[str, str]:
         return {"ArticleBriefing": self.referenced, "ArticleProposal": self.display()}

fabricatio/models/generic.py

@@ -1,6 +1,6 @@
 """This module defines generic classes for models in the Fabricatio library."""
 
-from abc import abstractmethod
+from abc import ABC, abstractmethod
 from pathlib import Path
 from typing import Any, Callable, Dict, Iterable, List, Optional, Self, Union, final, overload
 
@@ -95,7 +95,7 @@ class WithRef[T](Base):
         """Get the referenced object."""
         return ok(self._reference, "_reference is None")
 
-    def update_ref[S](self: S, reference: T | S) -> S:  # noqa: PYI019
+    def update_ref[S: "WithRef"](self: S, reference: T | S) -> S:  # noqa: PYI019
         """Update the reference of the object."""
         if isinstance(reference, self.__class__):
             self._reference = reference.referenced
@@ -108,7 +108,7 @@ class PersistentAble(Base):
     """Class that provides a method to persist the object."""
 
     def persist(self, path: str | Path) -> Self:
-        """Persist the object to a file.
+        """Persist the object to a file or directory.
 
         Args:
             path (str | Path): The path to save the object.
@@ -117,7 +117,7 @@ class PersistentAble(Base):
             Self: The current instance of the object.
         """
         p = Path(path)
-        out = self.model_dump_json()
+        out = self.model_dump_json(indent=1)
         if p.is_dir():
             p.joinpath(f"{self.__class__.__name__}_{blake3_hash(out.encode())[:6]}.json").write_text(
                 out, encoding="utf-8"
@@ -125,6 +125,7 @@ class PersistentAble(Base):
             return self
         p.mkdir(exist_ok=True, parents=True)
         p.write_text(out, encoding="utf-8")
+        logger.info(f"Persisted {self} to {p.as_posix()}")
         return self
 
     def from_persistent(self, path: str | Path) -> Self:
@@ -139,6 +140,61 @@ class PersistentAble(Base):
         return self.model_validate_json(Path(path).read_text(encoding="utf-8"))
 
 
+class ModelHash(Base):
+    """Class that provides a hash value for the object."""
+
+    def __hash__(self) -> int:
+        """Calculates a hash value for the ArticleBase object based on its model_dump_json representation."""
+        return hash(self.model_dump_json())
+
+
+class UpdateFrom(Base):
+    """Class that provides a method to update the object from another object."""
+
+    def update_pre_check(self, other: Self) -> Self:
+        """Pre-check for updating the object from another object."""
+        if not isinstance(other, self.__class__):
+            raise TypeError(f"Cannot update from a non-{self.__class__.__name__} instance.")
+
+        return self
+
+    @abstractmethod
+    def update_from_inner(self, other: Self) -> Self:
+        """Updates the current instance with the attributes of another instance."""
+
+    @final
+    def update_from(self, other: Self) -> Self:
+        """Updates the current instance with the attributes of another instance."""
+        return self.update_pre_check(other).update_from_inner(other)
+
+
+class ResolveUpdateConflict(Base):
+    """Class that provides a method to update the object from another object."""
+
+    @abstractmethod
+    def resolve_update_conflict(self, other: Self) -> str:
+        """Resolve the update conflict between two objects.
+
+        Args:
+            other (Self): The other object to resolve the update conflict with.
+
+        Returns:
+            str: The resolved update conflict.
+        """
+
+
+class Introspect(Base):
+    """Class that provides a method to introspect the object."""
+
+    @abstractmethod
+    def introspect(self) -> str:
+        """Internal introspection of the object.
+
+        Returns:
+            str: The internal introspection of the object.
+        """
+
+
 class WithBriefing(Named, Described):
     """Class that provides a briefing based on the name and description."""
 
@@ -173,20 +229,11 @@ class WithBriefing(Named, Described):
                 raise TypeError(f"{system_msg_like} is not a dict or str")
 
 
-class ReverseGenerate(GenerateJsonSchema):
+class UnsortGenerate(GenerateJsonSchema):
     """Class that provides a reverse JSON schema of the model."""
 
-    def _sort_recursive(self, value: Any, parent_key: str | None = None) -> Any:
-        if isinstance(value, dict):
-            sorted_dict: dict[str, JsonSchemaValue] = {}
-            # Reverse all keys regardless of parent_key
-            keys = reversed(value.keys())
-            for key in keys:
-                sorted_dict[key] = self._sort_recursive(value[key], parent_key=key)
-            return sorted_dict
-        if isinstance(value, list):
-            # Reverse list order and process each item
-            return [self._sort_recursive(item, parent_key) for item in reversed(value)]
+    def sort(self, value: JsonSchemaValue, parent_key: str | None = None) -> JsonSchemaValue:
+        """Not sort."""
         return value
 
 
@@ -201,7 +248,7 @@ class WithFormatedJsonSchema(Base):
             str: The JSON schema of the model in a formatted string.
         """
         return orjson.dumps(
-            cls.model_json_schema(schema_generator=ReverseGenerate),
+            cls.model_json_schema(schema_generator=UnsortGenerate),
             option=orjson.OPT_INDENT_2,
         ).decode()
 
@@ -261,6 +308,10 @@ class ProposedAble(CreateJsonObjPrompt, InstantiateFromString):
     """Class that provides a method to propose a JSON object based on the requirement."""
 
 
+class ProposedUpdateAble(PersistentAble, UpdateFrom, ABC):
+    """Make the obj can be updated from the proposed obj in place."""
+
+
 class FinalizedDumpAble(Base):
     """Class that provides a method to finalize the dump of the object."""
 
@@ -392,7 +443,7 @@ class PrepareVectorization(Base):
         """
         max_length = max_length or configs.embedding.max_sequence_length
         chunk = self._prepare_vectorization_inner()
-        if len(chunk) > max_length:
+        if max_length and len(chunk) > max_length:
             logger.error(err := f"Chunk exceeds maximum sequence length {max_length}.")
             raise ValueError(err)
 
@@ -475,7 +526,7 @@ class ScopedConfig(Base):
         """Fallback to another instance's attribute values if the current instance's attributes are None.
 
         Args:
-            other (LLMUsage): Another instance from which to copy attribute values.
+            other (ScopedConfig): Another instance from which to copy attribute values.
 
         Returns:
             Self: The current instance, allowing for method chaining.
@@ -495,7 +546,7 @@ class ScopedConfig(Base):
         """Hold to another instance's attribute values if the current instance's attributes are None.
 
         Args:
-            others (LLMUsage | Iterable[LLMUsage]): Another instance or iterable of instances from which to copy attribute values.
+            others (Union[ScopedConfig, Iterable[ScopedConfig]]): Another instance or iterable of instances from which to copy attribute values.
 
         Returns:
             Self: The current instance, allowing for method chaining.