fabricatio 0.2.7.dev1__cp312-cp312-manylinux_2_34_x86_64.whl → 0.2.7.dev2__cp312-cp312-manylinux_2_34_x86_64.whl

fabricatio/actions/article.py

@@ -55,19 +55,23 @@ class GenerateArticleProposal(Action):
         **_,
     ) -> Optional[ArticleProposal]:
         if article_briefing is None and article_briefing_path is None and task_input is None:
-            logger.info("Task not approved, since ")
+            logger.error("Task not approved, since all inputs are None.")
             return None
-        if article_briefing_path is None and task_input:
-            article_briefing_path = await self.awhich_pathstr(
-                f"{task_input.briefing}\nExtract the path of file which contains the article briefing."
-            )
 
         return (
             await self.propose(
                 ArticleProposal,
                 briefing := (
                     article_briefing
-                    or safe_text_read(ok(article_briefing_path, "Could not find the path of file to read."))
+                    or safe_text_read(
+                        ok(
+                            article_briefing_path
+                            or await self.awhich_pathstr(
+                                f"{task_input.briefing}\nExtract the path of file which contains the article briefing."
+                            ),
+                            "Could not find the path of file to read.",
+                        )
+                    )
                 ),
                 **self.prepend_sys_msg(),
             )
@@ -85,13 +89,28 @@ class GenerateOutline(Action):
         article_proposal: ArticleProposal,
         **_,
     ) -> Optional[ArticleOutline]:
-        return (
-            await self.propose(
-                ArticleOutline,
-                article_proposal.as_prompt(),
-                **self.prepend_sys_msg(),
+        out = await self.propose(
+            ArticleOutline,
+            article_proposal.as_prompt(),
+            **self.prepend_sys_msg(),
+        )
+
+        manual = await self.draft_rating_manual(
+            topic=(
+                topic
+                := "Fix the internal referring error, make sure there is no more `ArticleRef` pointing to a non-existing article component."
+            ),
+        )
+        while err := out.resolve_ref_error():
+            logger.warning(f"Found error in the outline: \n{err}")
+            out = await self.correct_obj(
+                out,
+                reference=f"# Referring Error\n{err}",
+                topic=topic,
+                rating_manual=manual,
+                supervisor_check=False,
             )
-        ).update_ref(article_proposal)
+        return out.update_ref(article_proposal)
 
 
 class CorrectProposal(Action):
@@ -134,10 +153,42 @@ class GenerateArticle(Action):
     ) -> Optional[Article]:
         article: Article = Article.from_outline(article_outline).update_ref(article_outline)
 
-        for c, deps in article.iter_dfs_with_deps():
-            out = await self.correct_obj(
-                c, reference=f"{article_outline.referenced.as_prompt()}\n" + "\n".join(d.display() for d in deps)
+        writing_manual = await self.draft_rating_manual(
+            topic=(
+                topic_1
+                := "improve the content of the subsection to fit the outline. SHALL never add or remove any section or subsection, you can only add or delete paragraphs within the subsection."
+            ),
+        )
+        err_resolve_manual = await self.draft_rating_manual(
+            topic=(topic_2 := "this article component has violated the constrain, please correct it.")
+        )
+        for c, deps in article.iter_dfs_with_deps(chapter=False):
+            logger.info(f"Updating the article component: \n{c.display()}")
+
+            out = ok(
+                await self.correct_obj(
+                    c,
+                    reference=(
+                        ref := f"{article_outline.referenced.as_prompt()}\n" + "\n".join(d.display() for d in deps)
+                    ),
+                    topic=topic_1,
+                    rating_manual=writing_manual,
+                    supervisor_check=False,
+                ),
+                "Could not correct the article component.",
             )
+            while err := c.resolve_update_error(out):
+                logger.warning(f"Found error in the article component: \n{err}")
+                out = ok(
+                    await self.correct_obj(
+                        out,
+                        reference=f"{ref}\n\n# Violated Error\n{err}",
+                        topic=topic_2,
+                        rating_manual=err_resolve_manual,
+                        supervisor_check=False,
+                    ),
+                    "Could not correct the article component.",
+                )
 
             c.update_from(out)
         return article

fabricatio/capabilities/rating.py

@@ -10,6 +10,7 @@ from fabricatio.journal import logger
 from fabricatio.models.generic import WithBriefing
 from fabricatio.models.kwargs_types import ValidateKwargs
 from fabricatio.models.usages import LLMUsage
+from fabricatio.models.utils import override_kwargs
 from fabricatio.parser import JsonCapture
 from more_itertools import flatten, windowed
 from pydantic import NonNegativeInt, PositiveInt
@@ -126,13 +127,13 @@ class GiveRating(WithBriefing, LLMUsage):
         return await self.rate_fine_grind(to_rate, manual, score_range, **kwargs)
 
     async def draft_rating_manual(
-        self, topic: str, criteria: Set[str], **kwargs: Unpack[ValidateKwargs[Dict[str, str]]]
+        self, topic: str, criteria: Optional[Set[str]] = None, **kwargs: Unpack[ValidateKwargs[Dict[str, str]]]
     ) -> Optional[Dict[str, str]]:
         """Drafts a rating manual based on a topic and dimensions.
 
         Args:
             topic (str): The topic for the rating manual.
-            criteria (Set[str]): A set of dimensions for the rating manual.
+            criteria (Optional[Set[str]], optional): A set of criteria for the rating manual. If not specified, then this method will draft the criteria automatically.
             **kwargs (Unpack[ValidateKwargs]): Additional keyword arguments for the LLM usage.
 
         Returns:
@@ -148,6 +149,14 @@ class GiveRating(WithBriefing, LLMUsage):
                 return json_data
             return None
 
+        criteria = criteria or await self.draft_rating_criteria(
+            topic, **self.prepend_sys_msg(override_kwargs(dict(kwargs), default=None))
+        )
+
+        if criteria is None:
+            logger.error(f"Failed to draft rating criteria for topic {topic}")
+            return None
+
         return await self.aask_validate(
             question=(
                 TEMPLATE_MANAGER.render_template(

fabricatio/capabilities/review.py

@@ -1,6 +1,6 @@
 """A module that provides functionality to rate tasks based on a rating manual and score range."""
 
-from typing import List, Optional, Self, Set, Unpack, cast
+from typing import Dict, List, Optional, Self, Set, Unpack, cast
 
 from fabricatio._rust_instances import TEMPLATE_MANAGER
 from fabricatio.capabilities.propose import Propose
@@ -200,13 +200,14 @@ class Review(GiveRating, Propose):
             ReviewResult[Task[T]]: A review result containing identified problems and proposed solutions,
                 with a reference to the original task.
         """
-        return cast('ReviewResult[Task[T]]', await self.review_obj(task, **kwargs))
+        return cast("ReviewResult[Task[T]]", await self.review_obj(task, **kwargs))
 
     async def review_string(
         self,
         input_text: str,
         topic: str,
         criteria: Optional[Set[str]] = None,
+        rating_manual: Optional[Dict[str, str]] = None,
         **kwargs: Unpack[ValidateKwargs[ReviewResult[str]]],
     ) -> ReviewResult[str]:
         """Review a string based on specified topic and criteria.
@@ -219,6 +220,7 @@ class Review(GiveRating, Propose):
             topic (str): The subject topic for the review criteria.
             criteria (Optional[Set[str]], optional): A set of criteria for the review.
                 If not provided, criteria will be drafted automatically. Defaults to None.
+            rating_manual (Optional[Dict[str,str]], optional): A dictionary of rating criteria and their corresponding scores.
             **kwargs (Unpack[ValidateKwargs]): Additional keyword arguments for the LLM usage.
 
         Returns:
@@ -227,12 +229,13 @@ class Review(GiveRating, Propose):
         """
         default = None
         if "default" in kwargs:
+            # this `default` is the default for the `propose` method
             default = kwargs.pop("default")
 
         criteria = criteria or (await self.draft_rating_criteria(topic, **kwargs))
         if not criteria:
             raise ValueError("No criteria provided for review.")
-        manual = await self.draft_rating_manual(topic, criteria, **kwargs)
+        manual = rating_manual or await self.draft_rating_manual(topic, criteria, **kwargs)
 
         if default is not None:
             kwargs["default"] = default

fabricatio/decorators.py

@@ -177,3 +177,35 @@ def use_temp_module[**P, R](modules: ModuleType | List[ModuleType]) -> Callable[
         return _wrapper
 
     return _decorator
+
+
+def logging_exec_time[**P, R](func: Callable[P, R]) -> Callable[P, R]:
+    """Decorator to log the execution time of a function.
+
+    Args:
+        func (Callable): The function to be executed
+
+    Returns:
+        Callable: A decorator that wraps the function to log the execution time.
+    """
+    from time import time
+
+    if iscoroutinefunction(func):
+
+        @wraps(func)
+        async def _async_wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+            start_time = time()
+            result = await func(*args, **kwargs)
+            logger.debug(f"Execution time of `{func.__name__}`: {time() - start_time:.2f} s")
+            return result
+
+        return _async_wrapper
+
+    @wraps(func)
+    def _wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+        start_time = time()
+        result = func(*args, **kwargs)
+        logger.debug(f"Execution time of {func.__name__}: {(time() - start_time) * 1000:.2f} ms")
+        return result
+
+    return _wrapper

fabricatio/models/action.py

@@ -48,7 +48,7 @@ class Action(HandleTask, ProposeTask, Correct):
         self.description = self.description or self.__class__.__doc__ or ""
 
     @abstractmethod
-    async def _execute(self,*_, **cxt) -> Any:  # noqa: ANN002
+    async def _execute(self, *_, **cxt) -> Any:  # noqa: ANN002
         """Execute the action logic with the provided context arguments.
 
         This method must be implemented by subclasses to define the actual behavior.
@@ -147,6 +147,8 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
         Args:
             task: The task to be processed.
         """
+        logger.info(f"Start execute workflow: {self.name}")
+
         await task.start()
         await self._init_context(task)
 
@@ -155,12 +157,11 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
             # Process each action in sequence
             for step in self._instances:
                 current_action = step.name
-                logger.debug(f"Executing step: {current_action}")
+                logger.info(f"Executing step: {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():
                     act_task.cancel(f"Cancelled by task: {task.name}")
@@ -168,9 +169,10 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
 
                 # Update context with modified values
                 modified_ctx = await act_task
+                logger.success(f"Step execution finished: {current_action}")
                 await self._context.put(modified_ctx)
 
-            logger.info(f"Finished executing workflow: {self.name}")
+            logger.success(f"Workflow execution finished: {self.name}")
 
             # Get final context and extract result
             final_ctx = await self._context.get()
@@ -184,9 +186,9 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
 
             await task.finish(result)
 
-        except RuntimeError as e:
-            logger.error(f"Error during task: {current_action} execution: {e}")
-            logger.error(traceback.format_exc())
+        except Exception as e:  # noqa: BLE001
+            logger.critical(f"Error during task: {current_action} execution: {e}")
+            logger.critical(traceback.format_exc())
             await task.fail()
 
     async def _init_context[T](self, task: Task[T]) -> None:

fabricatio/models/extra.py

@@ -1,8 +1,9 @@
 """Extra models for built-in actions."""
 
 from abc import abstractmethod
+from enum import Enum
 from itertools import chain
-from typing import Dict, Generator, List, Optional, Self, Tuple, final
+from typing import Dict, Generator, List, Optional, Self, Tuple, Union, final, overload
 
 from fabricatio.journal import logger
 from fabricatio.models.generic import AsPrompt, Base, CensoredAble, Display, PrepareVectorization, ProposedAble, WithRef
@@ -263,44 +264,82 @@ class ArticleProposal(CensoredAble, Display, WithRef[str], AsPrompt):
         return {"ArticleBriefing": self.referenced, "ArticleProposal": self.display()}
 
 
-class ArticleRef(CensoredAble):
-    """Reference to a specific section or subsection within an article.
+class ReferringType(str, Enum):
+    """Enumeration of different types of references that can be made in an article."""
 
-    Always instantiated with a fine-grind reference to a specific subsection if possible.
-    """
+    CHAPTER: str = "chapter"
+    SECTION: str = "section"
+    SUBSECTION: str = "subsection"
+
+
+class ArticleRef(CensoredAble):
+    """Reference to a specific chapter, section or subsection within the article. You SHALL not refer to an article component that is external and not present within our own article."""
 
     referred_chapter_title: str
-    """Full title of the chapter that contains the referenced section."""
+    """`title` Field of the referenced chapter"""
 
     referred_section_title: Optional[str] = None
-    """Full title of the section that contains the referenced subsection. Defaults to None if not applicable, which means the reference is to the entire chapter."""
+    """`title` Field of the referenced section. Defaults to None if not applicable, which means the reference is pointing to the entire chapter."""
 
     referred_subsection_title: Optional[str] = None
-    """Full title of the subsection that contains the referenced paragraph. Defaults to None if not applicable, which means the reference is to the entire section."""
+    """`title` Field of the referenced subsection. Defaults to None if not applicable, which means the reference is pointing to the entire section."""
 
     def __hash__(self) -> int:
         """Overrides the default hash function to ensure consistent hashing across instances."""
         return hash((self.referred_chapter_title, self.referred_section_title, self.referred_subsection_title))
 
+    @overload
+    def deref(self, article: "Article") -> Optional["ArticleBase"]:
+        """Dereference the reference to the actual section or subsection within the provided article."""
+
+    @overload
+    def deref(self, article: "ArticleOutline") -> Optional["ArticleOutlineBase"]:
+        """Dereference the reference to the actual section or subsection within the provided article."""
+
+    def deref(self, article: Union["ArticleOutline", "Article"]) -> Union["ArticleOutlineBase", "ArticleBase", None]:
+        """Dereference the reference to the actual section or subsection within the provided article.
+
+        Args:
+            article (ArticleOutline | Article): The article to dereference the reference from.
+
+        Returns:
+            ArticleBase | ArticleOutline | None: The dereferenced section or subsection, or None if not found.
+        """
+        chap = next((chap for chap in article.chapters if chap.title == self.referred_chapter_title), None)
+        if self.referred_section_title is None or chap is None:
+            return chap
+        sec = next((sec for sec in chap.sections if sec.title == self.referred_section_title), None)
+        if self.referred_subsection_title is None or sec is None:
+            return sec
+        return next((subsec for subsec in sec.subsections if subsec.title == self.referred_subsection_title), None)
+
+    @property
+    def referring_type(self) -> ReferringType:
+        """Determine the type of reference based on the presence of specific attributes."""
+        if self.referred_subsection_title is not None:
+            return ReferringType.SUBSECTION
+        if self.referred_section_title is not None:
+            return ReferringType.SECTION
+        return ReferringType.CHAPTER
+
 
 # <editor-fold desc="ArticleOutline">
 class ArticleOutlineBase(Base):
-    """Atomic research component specification for academic paper generation."""
+    """Base class for article outlines."""
 
     writing_aim: List[str]
     """Required: List of specific rhetorical objectives (3-5 items).
     Format: Each item must be an actionable phrase starting with a verb.
     Example: ['Establish metric validity', 'Compare with baseline approaches',
              'Justify threshold selection']"""
-    support_to: List[ArticleRef]
-    """Required: List of ArticleRef objects identifying components this section provides evidence for.
-    Format: Each reference must point to a specific chapter, section, or subsection.
-    Note: References form a directed acyclic graph in the document structure."""
-
     depend_on: List[ArticleRef]
-    """Required: List of ArticleRef objects identifying components this section builds upon.
+    """Required: List of all essential ArticleRef objects identifying components this section builds upon.
     Format: Each reference must point to a previously defined chapter, section, or subsection.
     Note: Circular dependencies are not permitted."""
+    support_to: List[ArticleRef]
+    """Required: List of all essential ArticleRef objects identifying components this section provides evidence for.
+    Format: Each reference must point to a specific chapter, section, or subsection.
+    Note: References form a directed acyclic graph in the document structure."""
 
     description: str = Field(...)
     """Description of the research component in academic style."""
@@ -313,34 +352,16 @@ class ArticleSubsectionOutline(ArticleOutlineBase):
 
 
 class ArticleSectionOutline(ArticleOutlineBase):
-    """Methodological unit organizing related technical components."""
-
-    subsections: List[ArticleSubsectionOutline] = Field(
-        ...,
-    )
-    """IMRaD-compliant substructure with technical progression:
-    1. Conceptual Framework
-    2. Methodological Details
-    3. Implementation Strategy
-    4. Validation Approach
-    5. Transition Logic
-
-    Example Flow:
-    [
-        'Search Space Constraints',
-        'Gradient Optimization Protocol',
-        'Multi-GPU Implementation',
-        'Convergence Validation',
-        'Cross-Lingual Extension'
-    ]"""
+    """A slightly more detailed research component specification for academic paper generation."""
+
+    subsections: List[ArticleSubsectionOutline] = Field(min_length=1)
+    """List of subsections, each containing a specific research component. Must contains at least 1 subsection, But do remember you should always add more subsection as required."""
 
 
 class ArticleChapterOutline(ArticleOutlineBase):
     """Macro-structural unit implementing standard academic paper organization."""
 
-    sections: List[ArticleSectionOutline] = Field(
-        ...,
-    )
+    sections: List[ArticleSectionOutline] = Field(min_length=1)
     """Standard academic progression implementing chapter goals:
     1. Context Establishment
     2. Technical Presentation
@@ -348,25 +369,15 @@ class ArticleChapterOutline(ArticleOutlineBase):
     4. Comparative Analysis
     5. Synthesis
 
-    Example Structure:
-    [
-        'Experimental Setup',
-        'Monolingual Baselines',
-        'Cross-Lingual Transfer',
-        'Low-Resource Scaling',
-        'Error Analysis'
-    ]"""
+    Must contains at least 1 sections, But do remember you should always add more section as required.
+    """
 
 
 class ArticleOutline(Display, CensoredAble, WithRef[ArticleProposal]):
     """Complete academic paper blueprint with hierarchical validation."""
 
     title: str = Field(...)
-    """Full technical title following ACL 2024 guidelines:
-    - Title Case with 12-18 word limit
-    - Structure: [Method] for [Task] via [Approach] in [Domain]
-    Example: 'Efficient Differentiable NAS for Low-Resource MT Through
-    Parameter-Sharing: A Cross-Lingual Study'"""
+    """Title of the academic paper."""
 
     prospect: str = Field(...)
     """Consolidated research statement with four pillars:
@@ -381,15 +392,7 @@ class ArticleOutline(Display, CensoredAble, WithRef[ArticleProposal]):
     60% reduced search costs.'"""
 
     chapters: List[ArticleChapterOutline]
-    """IMRaD structure with enhanced academic validation:
-    1. Introduction: Problem Space & Contributions
-    2. Background: Theoretical Foundations
-    3. Methods: Technical Innovations
-    4. Experiments: Protocol Design
-    5. Results: Empirical Findings
-    6. Discussion: Interpretation & Limitations
-    7. Conclusion: Synthesis & Future Work
-    8. Appendices: Supplementary Materials"""
+    """List of ArticleChapterOutline objects representing the academic paper's structure."""
 
     abstract: str = Field(...)
     """The abstract is a concise summary of the academic paper's main findings."""
@@ -423,6 +426,38 @@ class ArticleOutline(Display, CensoredAble, WithRef[ArticleProposal]):
                     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
+
 
 # </editor-fold>
 
@@ -456,6 +491,15 @@ class ArticleBase(CensoredAble, Display, ArticleOutlineBase):
             raise TypeError(f"Cannot update from a non-{self.__class__} instance.")
         if self.title != other.title:
             raise ValueError("Cannot update from a different title.")
+        return self
+
+    @abstractmethod
+    def resolve_update_error(self, other: Self) -> str:
+        """Resolve update errors in the article outline.
+
+        Returns:
+            str: Error message indicating update errors in the article outline.
+        """
 
     @abstractmethod
     def _update_from_inner(self, other: Self) -> Self:
@@ -481,6 +525,12 @@ class ArticleSubsection(ArticleBase):
     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}`. "
+        return ""
+
     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}")
@@ -500,9 +550,30 @@ class ArticleSection(ArticleBase):
     """Atomic argumentative unit with high-level specificity."""
 
     subsections: List[ArticleSubsection]
+    """List of ArticleSubsection objects containing the content of the section."""
+
+    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
@@ -522,8 +593,26 @@ class ArticleChapter(ArticleBase):
     sections: List[ArticleSection]
     """Thematic progression implementing chapter's 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
@@ -636,15 +725,7 @@ class Article(Display, CensoredAble, WithRef[ArticleOutline]):
         Returns:
             ArticleBase: The corresponding section or subsection.
         """
-        chap = ok(
-            next(chap for chap in self.chap_iter() if chap.title == ref.referred_chapter_title), "Chapter not found"
-        )
-        if ref.referred_section_title is None:
-            return chap
-        sec = ok(next(sec for sec in chap.sections if sec.title == ref.referred_section_title))
-        if ref.referred_subsection_title is None:
-            return sec
-        return ok(next(subsec for subsec in sec.subsections if subsec.title == ref.referred_subsection_title))
+        return ok(ref.deref(self), f"{ref} not found in {self.title}")
 
     def gather_dependencies(self, article: ArticleBase) -> List[ArticleBase]:
         """Gathers dependencies for all sections and subsections in the article.
@@ -672,7 +753,8 @@ class Article(Display, CensoredAble, WithRef[ArticleOutline]):
         q = self.gather_dependencies(article)
 
         deps = []
-        while a := q.pop():
+        while q:
+            a = q.pop()
             deps.extend(self.gather_dependencies(a))
 
         deps = list(
@@ -688,7 +770,8 @@ class Article(Display, CensoredAble, WithRef[ArticleOutline]):
         processed_components = []
 
         # Process all dependencies
-        while component := deps.pop():
+        while deps:
+            component = deps.pop()
             # Skip duplicates
             if (component_code := component.to_typst_code()) in formatted_code:
                 continue
@@ -699,13 +782,29 @@ class Article(Display, CensoredAble, WithRef[ArticleOutline]):
 
         return processed_components
 
-    def iter_dfs_with_deps(self) -> Generator[Tuple[ArticleBase, List[ArticleBase]], None, None]:
+    def iter_dfs_with_deps(
+        self, chapter: bool = True, section: bool = True, subsection: bool = True
+    ) -> Generator[Tuple[ArticleBase, List[ArticleBase]], None, None]:
         """Iterates through the article in a depth-first manner, yielding each component and its dependencies.
 
+        Args:
+            chapter (bool, optional): Whether to include chapter components. Defaults to True.
+            section (bool, optional): Whether to include section components. Defaults to True.
+            subsection (bool, optional): Whether to include subsection components. Defaults to True.
+
         Yields:
             Tuple[ArticleBase, List[ArticleBase]]: Each component and its dependencies.
         """
+        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():
+            if not chapter and isinstance(component, ArticleChapter):
+                continue
+            if not section and isinstance(component, ArticleSection):
+                continue
+            if not subsection and isinstance(component, ArticleSubsection):
+                continue
             yield component, (self.gather_dependencies_recursive(component))
 
 

fabricatio/models/generic.py

@@ -94,7 +94,7 @@ class WithRef[T](Base):
         """Get the referenced object."""
         return ok(self._reference, "_reference is None")
 
-    def update_ref(self, reference: T | Self) -> Self:
+    def update_ref[S](self: S, reference: T | S) -> S:  # noqa: PYI019
         """Update the reference of the object."""
         if isinstance(reference, self.__class__):
             self._reference = reference.referenced

fabricatio/models/kwargs_types.py

@@ -1,7 +1,7 @@
 """This module contains the types for the keyword arguments of the methods in the models module."""
 
 from importlib.util import find_spec
-from typing import Any, Required, TypedDict
+from typing import Any, Dict, Required, TypedDict
 
 from litellm.caching.caching import CacheMode
 from litellm.types.caching import CachingSupportedCallTypes
@@ -114,6 +114,7 @@ class ReviewKwargs[T](ReviewInnerKwargs[T], total=False):
     specific topics and review criteria.
     """
 
+    rating_manual: Dict[str, str]
     topic: Required[str]
 
 

fabricatio/models/usages.py

@@ -7,6 +7,7 @@ import asyncstdlib
 import litellm
 from fabricatio._rust_instances import TEMPLATE_MANAGER
 from fabricatio.config import configs
+from fabricatio.decorators import logging_exec_time
 from fabricatio.journal import logger
 from fabricatio.models.generic import ScopedConfig, WithBriefing
 from fabricatio.models.kwargs_types import ChooseKwargs, EmbeddingKwargs, GenerateKwargs, LLMKwargs, ValidateKwargs
@@ -148,9 +149,10 @@ class LLMUsage(ScopedConfig):
             async for chunk in resp:
                 chunks.append(chunk)
                 buffer += chunk.choices[0].delta.content or ""
-                if len(buffer) % stream_buffer_size == 0:
+                if len(buffer) > stream_buffer_size:
                     print(buffer, end="")  # noqa: T201
                     buffer = ""
+            print(buffer)  # noqa: T201
             if pack := stream_chunk_builder(chunks):
                 return pack.choices
         logger.critical(err := f"Unexpected response type: {type(resp)}")
@@ -186,6 +188,7 @@ class LLMUsage(ScopedConfig):
         **kwargs: Unpack[LLMKwargs],
     ) -> str: ...
 
+    @logging_exec_time
     async def aask(
         self,
         question: str | List[str],

{fabricatio-0.2.7.dev1.dist-info → fabricatio-0.2.7.dev2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.7.dev1
+Version: 0.2.7.dev2
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12

{fabricatio-0.2.7.dev1.dist-info → fabricatio-0.2.7.dev2.dist-info}/RECORD

@@ -1,18 +1,18 @@
-fabricatio-0.2.7.dev1.dist-info/METADATA,sha256=xT0PdjDB-kPb-iykNKBYlkFCw0IT-ai7sUfGdMpcEoI,13844
-fabricatio-0.2.7.dev1.dist-info/WHEEL,sha256=7FgAcpQES0h1xhfN9Ugve9FTUilU6sRAr1WJ5ph2cuw,108
-fabricatio-0.2.7.dev1.dist-info/licenses/LICENSE,sha256=yDZaTLnOi03bi3Dk6f5IjhLUc5old2yOsihHWU0z-i0,1067
-fabricatio/decorators.py,sha256=cJHsxxbnMhc4SzPl4454CPLuDP3H0qbTrzV_U2rLPrs,6372
+fabricatio-0.2.7.dev2.dist-info/METADATA,sha256=O-a8w-I-ZYDDO8utQOE2Ggf3F70kE4OZXrNS5nR-AGA,13844
+fabricatio-0.2.7.dev2.dist-info/WHEEL,sha256=7FgAcpQES0h1xhfN9Ugve9FTUilU6sRAr1WJ5ph2cuw,108
+fabricatio-0.2.7.dev2.dist-info/licenses/LICENSE,sha256=yDZaTLnOi03bi3Dk6f5IjhLUc5old2yOsihHWU0z-i0,1067
+fabricatio/decorators.py,sha256=GrkclNTGT2bk7cjTyuca7mqSVlKwTcujcj3uBuZpT8s,7343
 fabricatio/core.py,sha256=MaEKZ6DDmbdScAY-7F1gwGA6fr7ADX6Mz5rNVi2msFA,6277
-fabricatio/models/generic.py,sha256=h9dTa73eF9GwgpWbqx3dPxLGURQ_kJipSC2x1Utcx5s,15258
+fabricatio/models/generic.py,sha256=7rVwpdw0GsufvfxJg5gSRcpHFhAu9QVbDh0XQ80UT5M,15274
 fabricatio/models/tool.py,sha256=ifivEnYiEUtjeRxQkX8vjfyzn1m1acgfrsABbQqCsGs,6912
 fabricatio/models/role.py,sha256=UgIfGdfIBu4cOug8Nm1a04JCEwjXR_MDZUQhumwMptk,2710
-fabricatio/models/extra.py,sha256=03-FuwZ0vFygN33FYFIgw9NfLXNKDZE-F_oE_NQG5Jk,27464
-fabricatio/models/kwargs_types.py,sha256=CI1RlH6C9NwOiG9jCPLeN57CwJf45FBVKuuG5hptZMI,5246
+fabricatio/models/extra.py,sha256=od7NhLAOjZ7GWTQuI5kn9YH4xcZjLK0S6YDTxNmcOF4,32604
+fabricatio/models/kwargs_types.py,sha256=2tiApAy8JvpkDWKk_26_X1_g08mcHHKQz3c8pCd73x0,5286
 fabricatio/models/utils.py,sha256=E1Jz7oodbn09OkBspSpzCgKkv0AiuxyQElqCgHF7bVY,5718
-fabricatio/models/usages.py,sha256=1aDUE4bqAAE_88f7SSqpuB91THOIN09RI2VInmTdERk,30727
+fabricatio/models/usages.py,sha256=c_yU0pBjzUW9e-om6nIImmRV32eRiX9oxSlkC2HAtz4,30837
 fabricatio/models/events.py,sha256=UvOc6V3vfjKuvh7irDezJ8EGpsNo5yzLdq4xQexVonw,4063
 fabricatio/models/task.py,sha256=-EnzpEyM6Z687gF1lPcmA2szEUw6dFpu3lOtseaz95o,10193
-fabricatio/models/action.py,sha256=Afm3f1eE_KthDcAIVunVa2R6sysvdxxBjPIj5WvfO08,8378
+fabricatio/models/action.py,sha256=qFEY4aISSCSMkltl166DI2j-c-Mjxo1X0SjgfnyCVpg,8537
 fabricatio/toolboxes/fs.py,sha256=OQMdeokYxSNVrCZJAweJ0cYiK4k2QuEiNdIbS5IHIV8,705
 fabricatio/toolboxes/__init__.py,sha256=dYm_Gd8XolSU_h4wnkA09dlaLDK146eeFz0CUgPZ8_c,380
 fabricatio/toolboxes/arithmetic.py,sha256=sSTPkKI6-mb278DwQKFO9jKyzc9kCx45xNH7V6bGBpE,1307
@@ -25,18 +25,18 @@ fabricatio/journal.py,sha256=Op0wC-JlZumnAc_aDmYM4ljnSNLoKEEMfcIRbCF69ow,455
 fabricatio/__init__.py,sha256=6EjK4SxbnvFxdO9ftkXD9rxSuoPEIITNzUkuMO9s3yU,1092
 fabricatio/actions/output.py,sha256=sBQcpLKPslGv-HI751zTrL1H8Ec23uIWgnGDjmkF4e0,1127
 fabricatio/actions/rag.py,sha256=Tsjn9IkO8OlKlhBBnk7J6qh9st61jzD6SUYClGhYs7I,2686
-fabricatio/actions/article.py,sha256=9YgXQWErNfrksEpEUMcxoRZr9wyyfyhDyzP4AGKJ8M8,5151
+fabricatio/actions/article.py,sha256=iHpzfrHEil1Q0t9AbiFSU-X_AHxnFc7qsdd3ReFE7WM,7305
 fabricatio/_rust_instances.py,sha256=bQmlhUCcxTmRgvw1SfzYzNNpgW_UCjmkYw5f-VPAyg8,304
 fabricatio/workflows/articles.py,sha256=oHNV5kNKEcOKP55FA7I1SlxQRlk6N26cpem_QYu05g0,1021
 fabricatio/workflows/rag.py,sha256=uOZXprD479fUhLA6sYvEM8RWcVcUZXXtP0xRbTMPdHE,509
 fabricatio/parser.py,sha256=OV6bIAfLJ-GfaKoTeIOqS3X3GqCgyvzSJsgYMO3ogj4,6100
 fabricatio/capabilities/correct.py,sha256=QVI1K5fU_1akCiE9r0hJgVe0Pd-rFH1pCaFlLAJyhPk,6337
 fabricatio/capabilities/rag.py,sha256=FsjaMKeFgl-kBmUGDfkWn2Sa9Gp1AfOWpOZRZXZlNFY,17270
-fabricatio/capabilities/rating.py,sha256=K9Wa69yvoDwzr1VC37f_1jeFEzvDfulMPZfWUpU-StA,14099
-fabricatio/capabilities/review.py,sha256=jX4VluU6pEefqT933AfkZdejxxABzLQrEkKMBm3vHA8,10828
+fabricatio/capabilities/rating.py,sha256=K6dIaMDMWNUhCenuP_lFriaofj6gBPjfNXEILp5yzjU,14556
+fabricatio/capabilities/review.py,sha256=_m7uGNfhW7iDhcCJrLiSBmEvMq56fpPIzNGh1X20YZM,11103
 fabricatio/capabilities/propose.py,sha256=4QvONVVUp1rs34Te2Rjams6NioEt6FhEAxDWiveQnSg,1544
 fabricatio/capabilities/task.py,sha256=5XUxYNkPIHKm-Q0_oCeEqS-i3kfq9twHqcDiZL0rKVo,4526
 fabricatio/_rust.pyi,sha256=n6mFYqLQlyfumJZQ_E3SesR_yLrjfRLjf6N1VdlF6U8,3707
-fabricatio/_rust.cpython-312-x86_64-linux-gnu.so,sha256=wwyjJOcUb7JLKrLT2gnTPuOzDIaIIcNAnLoPg5TDxLc,1918776
-fabricatio-0.2.7.dev1.data/scripts/tdown,sha256=egGEOvA_9iyXvzSFEm1bb442UvI1gpl-X8c36791vNA,4588880
-fabricatio-0.2.7.dev1.dist-info/RECORD,,
+fabricatio/_rust.cpython-312-x86_64-linux-gnu.so,sha256=D6X2ze73ooY-RQDwxI7sAXy7N45SsYt4mvf6c-gmMsk,1916440
+fabricatio-0.2.7.dev2.data/scripts/tdown,sha256=6uM32dDtLgRz2941ErcuJf6GFvEzcgkS9bKm_qmFNRc,4590176
+fabricatio-0.2.7.dev2.dist-info/RECORD,,