fabricatio 0.2.9.dev2__cp312-cp312-win_amd64.whl → 0.2.9.dev3__cp312-cp312-win_amd64.whl

fabricatio/capabilities/correct.py

@@ -1,5 +1,6 @@
 """A module containing the Correct capability for reviewing, validating, and improving objects."""
 
+from asyncio import gather
 from typing import Optional, Type, Unpack, cast
 
 from fabricatio.capabilities.propose import Propose
@@ -14,7 +15,7 @@ from fabricatio.models.kwargs_types import (
     ValidateKwargs,
 )
 from fabricatio.rust_instances import TEMPLATE_MANAGER
-from fabricatio.utils import ok, override_kwargs
+from fabricatio.utils import fallback_kwargs, ok, override_kwargs
 
 
 class Correct(Rating, Propose):
@@ -33,8 +34,9 @@ class Correct(Rating, Propose):
             ProblemSolutions: The problem solutions with the best solution selected.
         """
         if (leng := len(problem_solutions.solutions)) == 0:
-            logger.error(f"No solutions found in ProblemSolutions, Skip: {problem_solutions.problem}")
+            logger.error(f"No solutions found in ProblemSolutions, Skip: `{problem_solutions.problem.name}`")
         if leng > 1:
+            logger.info(f"{leng} solutions found in Problem `{problem_solutions.problem.name}`, select the best.")
             problem_solutions.solutions = await self.best(problem_solutions.solutions, **kwargs)
         return problem_solutions
 
@@ -48,11 +50,25 @@ class Correct(Rating, Propose):
         Returns:
             Improvement: The improvement with the best solutions selected for each problem solution.
         """
-        if (leng := len(improvement.problem_solutions)) == 0:
+        if leng := len(improvement.problem_solutions):
+            logger.debug(f"{leng} problem_solutions found in Improvement, decide solution for each of them.")
+            await gather(
+                *[
+                    self.decide_solution(
+                        ps,
+                        **fallback_kwargs(
+                            kwargs, topic=f"which solution is better to deal this problem {ps.problem.compact()}\n\n"
+                        ),
+                    )
+                    for ps in improvement.problem_solutions
+                ],
+            )
+            if any(not (violated := ps).decided() for ps in improvement.problem_solutions):
+                logger.error(f"Some problem_solutions are not decided: {violated}")
+            else:
+                logger.success(f"All problem_solutions are decided '{improvement.focused_on}'")
+        else:
             logger.error(f"No problem_solutions found in Improvement, Skip: {improvement}")
-        if leng > 1:
-            for ps in improvement.problem_solutions:
-                ps.solutions = await self.best(ps.solutions, **kwargs)
         return improvement
 
     async def fix_troubled_obj[M: SketchedAble](
@@ -81,7 +97,7 @@ class Correct(Rating, Propose):
                     "problem": problem_solutions.problem.display(),
                     "solution": ok(
                         problem_solutions.final_solution(),
-                        f"No solution found for problem: {problem_solutions.problem}",
+                        f"{len(problem_solutions.solutions)} solution Found for `{problem_solutions.problem.name}`.",
                     ).display(),
                     "reference": reference,
                 },
@@ -148,13 +164,15 @@ class Correct(Rating, Propose):
             TypeError: If the provided object doesn't implement Display or WithBriefing interfaces.
         """
         if not improvement.decided():
+            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}")
             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}",
+                    f"Failed to fix troubling obj {obj.__class__.__name__} when deal with problem: {ps.problem.name}",
                 )
                 return None
             obj = fixed_obj
@@ -178,6 +196,8 @@ class Correct(Rating, Propose):
             Optional[str]: A corrected version of the input string, or None if correction fails.
         """
         if not improvement.decided():
+            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:

fabricatio/capabilities/rating.py

@@ -43,7 +43,7 @@ class Rating(LLMUsage):
             Dict[str, float]: A dictionary with the ratings for each dimension.
         """
 
-        def _validator(response: str) -> Dict[str, float] | None:
+        def _validator(response: str) -> Optional[Dict[str, float]] :
             if (
                 (json_data := JsonCapture.validate_with(response, dict, str))
                 and json_data.keys() == rating_manual.keys()
@@ -88,7 +88,7 @@ class Rating(LLMUsage):
         to_rate: str,
         topic: str,
         criteria: Set[str],
-        manual: Optional[Dict[str, str]],
+        manual: Optional[Dict[str, str]] = None,
         score_range: Tuple[float, float] = (0.0, 1.0),
         **kwargs: Unpack[ValidateKwargs],
     ) -> Dict[str, float]: ...
@@ -99,7 +99,7 @@ class Rating(LLMUsage):
         to_rate: List[str],
         topic: str,
         criteria: Set[str],
-        manual: Optional[Dict[str, str]],
+        manual: Optional[Dict[str, str]] = None,
         score_range: Tuple[float, float] = (0.0, 1.0),
         **kwargs: Unpack[ValidateKwargs],
     ) -> List[Dict[str, float]]: ...
@@ -109,7 +109,7 @@ class Rating(LLMUsage):
         to_rate: Union[str, List[str]],
         topic: str,
         criteria: Set[str],
-        manual: Optional[Dict[str, str]],
+        manual: Optional[Dict[str, str]] = None,
         score_range: Tuple[float, float] = (0.0, 1.0),
         **kwargs: Unpack[ValidateKwargs],
     ) -> Optional[Dict[str, float] | List[Dict[str, float]]]:
@@ -170,7 +170,7 @@ class Rating(LLMUsage):
                     configs.templates.draft_rating_manual_template,
                     {
                         "topic": topic,
-                        "criteria": criteria,
+                        "criteria": list(criteria),
                     },
                 )
             ),
@@ -360,14 +360,14 @@ class Rating(LLMUsage):
         return [sum(ratings[c] * weights[c] for c in criteria) for ratings in ratings_seq]
 
     @overload
-    async def best(self, candidates: List[str], k: int=1, **kwargs: Unpack[CompositeScoreKwargs]) -> List[str]: ...
+    async def best(self, candidates: List[str], k: int = 1, **kwargs: Unpack[CompositeScoreKwargs]) -> List[str]: ...
     @overload
     async def best[T: Display](
-        self, candidates: List[T], k: int=1, **kwargs: Unpack[CompositeScoreKwargs]
+        self, candidates: List[T], k: int = 1, **kwargs: Unpack[CompositeScoreKwargs]
     ) -> List[T]: ...
 
     async def best[T: Display](
-        self, candidates: List[str] | List[T], k: int=1, **kwargs: Unpack[CompositeScoreKwargs]
+        self, candidates: List[str] | List[T], k: int = 1, **kwargs: Unpack[CompositeScoreKwargs]
     ) -> Optional[List[str] | List[T]]:
         """Choose the best candidates from the list of candidates based on the composite score.
 

fabricatio/models/action.py

@@ -177,27 +177,27 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
         current_action = None
         try:
             # Process each action in sequence
-            for step in self._instances:
+            for i,step in enumerate(self._instances):
                 current_action = step.name
-                logger.info(f"Executing step >> {current_action}")
+                logger.info(f"Executing step [{i}] >> {current_action}")
 
                 # Get current context and execute action
                 context = await self._context.get()
                 act_task = create_task(step.act(context))
                 # Handle task cancellation
                 if task.is_cancelled():
-                    logger.warning(f"Task cancelled by task: {task.name}")
+                    logger.warning(f"Workflow cancelled by task: {task.name}")
                     act_task.cancel(f"Cancelled by task: {task.name}")
                     break
 
                 # Update context with modified values
                 modified_ctx = await act_task
-                logger.success(f"Step execution finished: {current_action}")
+                logger.success(f"Step [{i}] `{current_action}` execution finished.")
                 if step.output_key:
-                    logger.success(f"Setting output to `{step.output_key}`")
+                    logger.success(f"Setting action `{current_action}` output to `{step.output_key}`")
                 await self._context.put(modified_ctx)
 
-            logger.success(f"Workflow execution finished: {self.name}")
+            logger.success(f"Workflow `{self.name}` execution finished.")
 
             # Get final context and extract result
             final_ctx = await self._context.get()

fabricatio/models/extra/article_base.py

@@ -7,8 +7,10 @@ from typing import Generator, List, Optional, Self, Tuple, overload
 
 from fabricatio.models.generic import (
     AsPrompt,
+    Described,
     FinalizedDumpAble,
     Introspect,
+    Language,
     ModelHash,
     PersistentAble,
     ProposedUpdateAble,
@@ -103,12 +105,9 @@ class ArticleRef(ProposedUpdateAble):
         return ReferringType.CHAPTER
 
 
-class ArticleMetaData(SketchedAble):
+class ArticleMetaData(SketchedAble, Described, Language):
     """Metadata for an article component."""
 
-    description: str
-    """Description of the research component in academic style."""
-
     support_to: List[ArticleRef]
     """List of references to other component of this articles that this component supports."""
     depend_on: List[ArticleRef]
@@ -273,12 +272,9 @@ class ChapterBase[T: SectionBase](ArticleOutlineBase):
         return ""
 
 
-class ArticleBase[T: ChapterBase](FinalizedDumpAble, AsPrompt, ABC):
+class ArticleBase[T: ChapterBase](FinalizedDumpAble, AsPrompt, Language, ABC):
     """Base class for article outlines."""
 
-    language: str
-    """Written language of the article. SHALL be aligned to the language of the article proposal provided."""
-
     title: str
     """Title of the academic paper."""
 
@@ -378,12 +374,31 @@ class ArticleBase[T: ChapterBase](FinalizedDumpAble, AsPrompt, ABC):
                 return component, summary
         return None
 
+    def gather_introspected(self) -> Optional[str]:
+        """Gathers all introspected components in the article structure."""
+        return "\n".join([i for component in self.chapters if (i := component.introspect())])
+
     @overload
     def find_illegal_ref(self, gather_identical: bool) -> Optional[Tuple[ArticleRef | List[ArticleRef], str]]: ...
 
     @overload
     def find_illegal_ref(self) -> Optional[Tuple[ArticleRef, str]]: ...
 
+    def iter_chap_title(self) -> Generator[str, None, None]:
+        """Iterates through all chapter titles in the article."""
+        for chap in self.chapters:
+            yield chap.title
+
+    def iter_section_title(self) -> Generator[str, None, None]:
+        """Iterates through all section titles in the article."""
+        for _, sec in self.iter_sections():
+            yield sec.title
+
+    def iter_subsection_title(self) -> Generator[str, None, None]:
+        """Iterates through all subsection titles in the article."""
+        for _, _, subsec in self.iter_subsections():
+            yield subsec.title
+
     def find_illegal_ref(self, gather_identical: bool = False) -> Optional[Tuple[ArticleRef | List[ArticleRef], str]]:
         """Finds the first illegal component in the outline.
 
@@ -391,21 +406,68 @@ class ArticleBase[T: ChapterBase](FinalizedDumpAble, AsPrompt, ABC):
             Tuple[ArticleOutlineBase, str]: A tuple containing the illegal component and an error message.
         """
         summary = ""
+        chap_titles_set = set(self.iter_chap_title())
+        sec_titles_set = set(self.iter_section_title())
+        subsec_titles_set = set(self.iter_subsection_title())
+
         for component in self.iter_dfs_rev():
             for ref in chain(component.depend_on, component.support_to):
                 if not ref.deref(self):
                     summary += f"Invalid internal reference in `{component.__class__.__name__}` titled `{component.title}`, because the referred {ref.referring_type} is not exists within the article, see the original obj dump: {ref.model_dump()}\n"
-                if summary and not gather_identical:
-                    return ref, summary
-                if summary and gather_identical:
-                    return [
-                        identical_ref
-                        for identical_ref in chain(self.iter_depend_on(), self.iter_support_on())
-                        if identical_ref == ref
-                    ], summary
+
+                    if ref.referred_chapter_title not in (chap_titles_set):
+                        summary += f"Chapter titled `{ref.referred_chapter_title}` is not any of {chap_titles_set}\n"
+                    if ref.referred_section_title and ref.referred_section_title not in (sec_titles_set):
+                        summary += f"Section Titled `{ref.referred_section_title}` is not any of {sec_titles_set}\n"
+                    if ref.referred_subsection_title and ref.referred_subsection_title not in (subsec_titles_set):
+                        summary += (
+                            f"Subsection Titled `{ref.referred_subsection_title}` is not any of {subsec_titles_set}"
+                        )
+
+                if summary:
+                    return (
+                        (
+                            [
+                                identical_ref
+                                for identical_ref in chain(self.iter_depend_on(), self.iter_support_on())
+                                if identical_ref == ref
+                            ],
+                            summary,
+                        )
+                        if gather_identical
+                        else (ref, summary)
+                    )
 
         return None
 
+    def gather_illegal_ref(self) -> Tuple[List[ArticleRef], str]:
+        """Gathers all illegal references in the article."""
+        summary = []
+        chap_titles_set = set(self.iter_chap_title())
+        sec_titles_set = set(self.iter_section_title())
+        subsec_titles_set = set(self.iter_subsection_title())
+        res_seq = []
+
+        for component in self.iter_dfs():
+            for ref in (
+                r for r in chain(component.depend_on, component.support_to) if not r.deref(self) and r not in res_seq
+            ):
+                res_seq.append(ref)
+                if ref.referred_chapter_title not in chap_titles_set:
+                    summary.append(
+                        f"Chapter titled `{ref.referred_chapter_title}` is not exist, since it is not any of {chap_titles_set}."
+                    )
+                if ref.referred_section_title and (ref.referred_section_title not in sec_titles_set):
+                    summary.append(
+                        f"Section Titled `{ref.referred_section_title}` is not exist, since it is not any of {sec_titles_set}"
+                    )
+                if ref.referred_subsection_title and (ref.referred_subsection_title not in subsec_titles_set):
+                    summary.append(
+                        f"Subsection Titled `{ref.referred_subsection_title}` is not exist, since it is not any of {subsec_titles_set}"
+                    )
+
+        return res_seq, "\n".join(summary)
+
     def finalized_dump(self) -> str:
         """Generates standardized hierarchical markup for academic publishing systems.
 

fabricatio/models/extra/article_main.py

@@ -15,6 +15,7 @@ from fabricatio.models.extra.article_outline import (
     ArticleOutline,
 )
 from fabricatio.models.generic import PersistentAble, SequencePatch, SketchedAble, WithRef
+from fabricatio.rust import word_count
 from fabricatio.utils import ok
 
 
@@ -27,6 +28,9 @@ class Paragraph(SketchedAble):
     writing_aim: List[str]
     """Specific communicative objectives for this paragraph's content."""
 
+    expected_word_count: int
+    """Expected word count for the paragraph."""
+
     content: str
     """The actual content of the paragraph, represented as a string."""
 
@@ -41,11 +45,26 @@ class ArticleSubsection(SubSectionBase):
     paragraphs: List[Paragraph]
     """List of Paragraph objects containing the content of the subsection."""
 
+    _max_word_count_deviation: float = 0.3
+    """Maximum allowed deviation from the expected word count, as a percentage."""
+
+    @property
+    def word_count(self) -> int:
+        """Calculates the total word count of all paragraphs in the subsection."""
+        return sum(word_count(p.content) for p in self.paragraphs)
+
     def introspect(self) -> str:
-        """Introspects the subsection and returns a message if it has no paragraphs."""
+        """Introspects the subsection and returns a summary of its state."""
+        summary = ""
         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 ""
+            summary += f"`{self.__class__.__name__}` titled `{self.title}` have no paragraphs!\n"
+        if (
+            abs((wc := self.word_count) - self.expected_word_count) / self.expected_word_count
+            > self._max_word_count_deviation
+        ):
+            summary += f"`{self.__class__.__name__}` titled `{self.title}` have {wc} words, expected {self.expected_word_count} words!"
+
+        return summary
 
     def update_from_inner(self, other: Self) -> Self:
         """Updates the current instance with the attributes of another instance."""
@@ -94,7 +113,7 @@ class Article(
 
     @override
     def iter_subsections(self) -> Generator[Tuple[ArticleChapter, ArticleSection, ArticleSubsection], None, None]:
-        return super().iter_subsections()
+        return super().iter_subsections()  # pyright: ignore [reportReturnType]
 
     @classmethod
     def from_outline(cls, outline: ArticleOutline) -> "Article":

fabricatio/models/extra/article_proposal.py

@@ -2,7 +2,7 @@
 
 from typing import Dict, List
 
-from fabricatio.models.generic import AsPrompt, SketchedAble, PersistentAble, WithRef
+from fabricatio.models.generic import AsPrompt, PersistentAble, SketchedAble, WithRef
 
 
 class ArticleProposal(SketchedAble, WithRef[str], AsPrompt, PersistentAble):

fabricatio/models/extra/problem.py

@@ -1,7 +1,7 @@
 """A class representing a problem-solution pair identified during a review process."""
 
 from itertools import chain
-from typing import List, Literal, Optional, Self
+from typing import Any, List, Literal, Optional, Self, Tuple, Unpack
 
 from fabricatio.journal import logger
 from fabricatio.models.generic import SketchedAble, WithBriefing
@@ -51,7 +51,12 @@ class ProblemSolutions(SketchedAble):
     problem: Problem
     """The problem identified in the review."""
     solutions: List[Solution]
-    """A collection of potential solutions."""
+    """A collection of potential solutions, spread the thought, add more solution as possible.Do not leave this as blank"""
+
+    def model_post_init(self, context: Any, /) -> None:
+        """Initialize the problem-solution pair with a problem and a list of solutions."""
+        if len(self.solutions) == 0:
+            logger.warning(f"No solution found for problem {self.problem.name}, please add more solutions manually.")
 
     def update_from_inner(self, other: Self) -> Self:
         """Update the current instance with another instance's attributes."""
@@ -69,6 +74,10 @@ class ProblemSolutions(SketchedAble):
         self.solutions = solutions
         return self
 
+    def has_solutions(self) -> bool:
+        """Check if the problem-solution pair has any solutions."""
+        return len(self.solutions) > 0
+
     async def edit_problem(self) -> Self:
         """Interactively edit the problem description."""
         self.problem = Problem.model_validate_strings(
@@ -87,11 +96,11 @@ class ProblemSolutions(SketchedAble):
         """Check if the improvement is decided."""
         return len(self.solutions) == 1
 
-    def final_solution(self) -> Optional[Solution]:
+    def final_solution(self, always_use_first: bool = False) -> Optional[Solution]:
         """Get the final solution."""
-        if not self.decided():
+        if not always_use_first and not self.decided():
             logger.error(
-                f"There is more than one solution for problem {self.problem.name}, please decide which solution is eventually adopted."
+                f"There is {len(self.solutions)} solutions for problem {self.problem.name}, please decide which solution is eventually adopted."
             )
             return None
         return self.solutions[0]
@@ -106,6 +115,10 @@ class Improvement(SketchedAble):
     problem_solutions: List[ProblemSolutions]
     """Collection of problems identified during review along with their potential solutions."""
 
+    def all_problems_have_solutions(self) -> bool:
+        """Check if all problems have solutions."""
+        return all(ps.has_solutions() for ps in self.problem_solutions)
+
     async def supervisor_check(self, check_solutions: bool = True) -> Self:
         """Perform an interactive review session to filter problems and solutions.
 
@@ -145,9 +158,9 @@ class Improvement(SketchedAble):
         return all(ps.decided() for ps in self.problem_solutions)
 
     @classmethod
-    def gather(cls, *improvements: Self) -> Self:
+    def gather(cls, *improvements: Unpack[Tuple["Improvement", ...]]) -> Self:
         """Gather multiple improvements into a single instance."""
         return cls(
-            focused_on="\n".join(imp.focused_on for imp in improvements),
+            focused_on=";".join(imp.focused_on for imp in improvements),
             problem_solutions=list(chain(*(imp.problem_solutions for imp in improvements))),
         )

fabricatio/models/extra/rule.py

@@ -8,15 +8,15 @@ descriptions, examples, and metadata for each rule and rule set, making it suita
 complex rule management systems.
 """
 
-from typing import List
+from typing import List, Self, Tuple, Unpack
 
 from fabricatio.models.generic import Language, PersistentAble, SketchedAble, WithBriefing
+from more_itertools import flatten
 
 
-class Rule(WithBriefing,Language, SketchedAble,PersistentAble):
+class Rule(WithBriefing, Language, SketchedAble, PersistentAble):
     """Represents a rule or guideline for a specific topic."""
 
-
     violation_examples: List[str]
     """A list of concrete examples demonstrating violations of this rule. Each example should
     be a clear scenario or case that illustrates how the rule can be broken, including the
@@ -30,7 +30,7 @@ class Rule(WithBriefing,Language, SketchedAble,PersistentAble):
     serve as practical guidance for implementing the rule correctly."""
 
 
-class RuleSet( SketchedAble, PersistentAble, WithBriefing,Language):
+class RuleSet(SketchedAble, PersistentAble, WithBriefing, Language):
     """Represents a collection of rules and guidelines for a particular topic."""
 
     rules: List[Rule]
@@ -38,3 +38,15 @@ class RuleSet( SketchedAble, PersistentAble, WithBriefing,Language):
     a well-defined, specific guideline that contributes to the overall purpose of the rule set.
     The rules should be logically organized and consistent with each other, forming a coherent
     framework for the topic or domain covered by the rule set."""
+
+    @classmethod
+    def gather(cls, *rulesets: Unpack[Tuple["RuleSet",...]]) -> Self:
+        """Gathers multiple rule sets into a single rule set."""
+        if not rulesets:
+            raise ValueError("No rulesets provided")
+        return cls(
+            language=rulesets[0].language,
+            name=";".join(ruleset.name for ruleset in rulesets),
+            description=";".join(ruleset.description for ruleset in rulesets),
+            rules=list(flatten(r.rules for r in rulesets)),
+        )

fabricatio/models/generic.py

@@ -229,7 +229,7 @@ class PersistentAble(Base):
         return self
 
     @classmethod
-    def from_latest_persistent(cls, dir_path: str | Path) -> Self:
+    def from_latest_persistent(cls, dir_path: str | Path) -> Optional[Self]:
         """Load most recent persisted instance from directory.
 
         Args:
@@ -244,13 +244,13 @@ class PersistentAble(Base):
         """
         dir_path = Path(dir_path)
         if not dir_path.is_dir():
-            raise NotADirectoryError(f"{dir_path} is not a valid directory")
+            return None
 
         pattern = f"{cls.__name__}_*.json"
         files = list(dir_path.glob(pattern))
 
         if not files:
-            raise FileNotFoundError(f"No persistent files found for {cls.__name__} in {dir_path}")
+            return None
 
         def _get_timestamp(file_path: Path) -> datetime:
             stem = file_path.stem

fabricatio/models/usages.py

@@ -130,7 +130,6 @@ class LLMUsage(ScopedConfig):
         question: str,
         system_message: str = "",
         n: PositiveInt | None = None,
-        stream_buffer_size: int = 50,
         **kwargs: Unpack[LLMKwargs],
     ) -> Sequence[TextChoices | Choices | StreamingChoices]:
         """Asynchronously invokes the language model with a question and optional system message.
@@ -139,7 +138,6 @@ class LLMUsage(ScopedConfig):
             question (str): The question to ask the model.
             system_message (str): The system message to provide context to the model. Defaults to an empty string.
             n (PositiveInt | None): The number of responses to generate. Defaults to the instance's `llm_generation_count` or the global configuration.
-            stream_buffer_size (int): The buffer size for streaming responses. Defaults to 50.
             **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage.
 
         Returns:
@@ -155,16 +153,7 @@ class LLMUsage(ScopedConfig):
         if isinstance(resp, CustomStreamWrapper):
             if not configs.debug.streaming_visible and (pack := stream_chunk_builder(await asyncstdlib.list())):
                 return pack.choices
-            chunks = []
-            buffer = ""
-            async for chunk in resp:
-                chunks.append(chunk)
-                buffer += chunk.choices[0].delta.content or ""
-                if len(buffer) > stream_buffer_size:
-                    print(buffer, end="")  # noqa: T201
-                    buffer = ""
-            print(buffer)  # noqa: T201
-            if pack := stream_chunk_builder(chunks):
+            if pack := stream_chunk_builder(await asyncstdlib.list(resp)):
                 return pack.choices
         logger.critical(err := f"Unexpected response type: {type(resp)}")
         raise ValueError(err)

fabricatio/rust.pyi

@@ -1,8 +1,24 @@
+"""
+Python interface definitions for Rust-based functionality.
+
+This module provides type stubs and documentation for Rust-implemented utilities,
+including template rendering, cryptographic hashing, language detection, and
+bibliography management. The actual implementations are provided by Rust modules.
+
+Key Features:
+- TemplateManager: Handles Handlebars template rendering and management.
+- BibManager: Manages BibTeX bibliography parsing and querying.
+- Cryptographic utilities: BLAKE3 hashing.
+- Text utilities: Word boundary splitting and word counting.
+"""
+
+
 from pathlib import Path
 from typing import List, Optional
 
 from pydantic import JsonValue
 
+
 class TemplateManager:
     """Template rendering engine using Handlebars templates.
 
@@ -81,6 +97,28 @@ def blake3_hash(content: bytes) -> str:
 def detect_language(string: str) -> str:
     """Detect the language of a given string."""
 
+
+def split_word_bounds(string: str) -> List[str]:
+    """Split the string into words based on word boundaries.
+
+    Args:
+        string: The input string to be split.
+
+    Returns:
+        A list of words extracted from the string.
+    """
+def word_count(string: str) -> int:
+    """Count the number of words in the string.
+
+    Args:
+        string: The input string to count words from.
+
+    Returns:
+        The number of words in the string.
+    """
+
+
+
 class BibManager:
     """BibTeX bibliography manager for parsing and querying citation data."""
 

fabricatio/utils.py

@@ -1,6 +1,6 @@
 """A collection of utility functions for the fabricatio package."""
 
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Mapping, Optional
 
 from questionary import text
 
@@ -25,16 +25,16 @@ async def ask_edit(
     return res
 
 
-def override_kwargs(kwargs: Dict[str,Any], **overrides) -> Dict[str, Any]:
+def override_kwargs(kwargs: Mapping[str,Any], **overrides) -> Dict[str, Any]:
     """Override the values in kwargs with the provided overrides."""
-    new_kwargs = kwargs.copy()
+    new_kwargs = dict(kwargs.items())
     new_kwargs.update({k: v for k, v in overrides.items() if v is not None})
     return new_kwargs
 
 
-def fallback_kwargs(kwargs: Dict[str, Any], **overrides) -> Dict[str, Any]:
+def fallback_kwargs(kwargs: Mapping[str, Any], **overrides) -> Dict[str, Any]:
     """Fallback the values in kwargs with the provided overrides."""
-    new_kwargs = kwargs.copy()
+    new_kwargs = dict(kwargs.items())
     new_kwargs.update({k: v for k, v in overrides.items() if k not in new_kwargs and v is not None})
     return new_kwargs