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

fabricatio/models/extra/article_main.py

@@ -14,11 +14,12 @@ from fabricatio.models.extra.article_base import (
 from fabricatio.models.extra.article_outline import (
     ArticleOutline,
 )
-from fabricatio.models.generic import CensoredAble, Display, PersistentAble, SequencePatch, WithRef
+from fabricatio.models.generic import PersistentAble, SequencePatch, SketchedAble, WithRef
+from fabricatio.rust import word_count
 from fabricatio.utils import ok
 
 
-class Paragraph(CensoredAble):
+class Paragraph(SketchedAble):
     """Structured academic paragraph blueprint for controlled content generation."""
 
     description: str
@@ -27,6 +28,9 @@ class Paragraph(CensoredAble):
     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."""
@@ -73,8 +92,7 @@ class ArticleChapter(ChapterBase[ArticleSection]):
 
 
 class Article(
-    Display,
-    CensoredAble,
+    SketchedAble,
     WithRef[ArticleOutline],
     PersistentAble,
     ArticleBase[ArticleChapter],
@@ -95,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_outline.py

@@ -9,7 +9,7 @@ from fabricatio.models.extra.article_base import (
     SubSectionBase,
 )
 from fabricatio.models.extra.article_proposal import ArticleProposal
-from fabricatio.models.generic import CensoredAble, Display, PersistentAble, WithRef
+from fabricatio.models.generic import PersistentAble, SketchedAble, WithRef
 
 
 class ArticleSubsectionOutline(SubSectionBase):
@@ -25,8 +25,7 @@ class ArticleChapterOutline(ChapterBase[ArticleSectionOutline]):
 
 
 class ArticleOutline(
-    Display,
-    CensoredAble,
+    SketchedAble,
     WithRef[ArticleProposal],
     PersistentAble,
     ArticleBase[ArticleChapterOutline],

fabricatio/models/extra/article_proposal.py

@@ -2,10 +2,10 @@
 
 from typing import Dict, List
 
-from fabricatio.models.generic import AsPrompt, CensoredAble, Display, PersistentAble, WithRef
+from fabricatio.models.generic import AsPrompt, PersistentAble, SketchedAble, WithRef
 
 
-class ArticleProposal(CensoredAble, Display, WithRef[str], AsPrompt, PersistentAble):
+class ArticleProposal(SketchedAble, WithRef[str], AsPrompt, PersistentAble):
     """Structured proposal for academic paper development with core research elements.
 
     Guides LLM in generating comprehensive research proposals with clearly defined components.
@@ -41,8 +41,8 @@ class ArticleProposal(CensoredAble, Display, WithRef[str], AsPrompt, PersistentA
     abstract: str
     """A concise summary of the research proposal, outlining the main points and objectives."""
 
-    min_word_count: int
-    """The minimum number of words required for the research proposal."""
+    expected_word_count: int
+    """The estimated word count of the final academic paper."""
 
     def _as_prompt_inner(self) -> Dict[str, str]:
         return {

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

@@ -33,45 +33,50 @@ class Base(BaseModel):
     """Base class for all models with Pydantic configuration.
 
     This class sets up the basic Pydantic configuration for all models in the Fabricatio library.
+    The `model_config` uses `use_attribute_docstrings=True` to ensure field descriptions are
+    pulled from the attribute's docstring instead of the default Pydantic behavior.
     """
-
     model_config = ConfigDict(use_attribute_docstrings=True)
 
 
 class Display(Base):
-    """Class that provides a method to display the model in a formatted JSON string.
+    """Class that provides formatted JSON representation utilities.
 
-    This class includes methods to display the model in both formatted and compact JSON strings.
+    Provides methods to generate both pretty-printed and compact JSON representations of the model.
+    Used for debugging and logging purposes.
     """
-
     def display(self) -> str:
-        """Display the model in a formatted JSON string.
+        """Generate pretty-printed JSON representation.
 
         Returns:
-            str: The formatted JSON string of the model.
+            str: JSON string with 1-level indentation for readability
         """
         return self.model_dump_json(indent=1)
 
     def compact(self) -> str:
-        """Display the model in a compact JSON string.
+        """Generate compact JSON representation.
 
         Returns:
-            str: The compact JSON string of the model.
+            str: Minified JSON string without whitespace
         """
         return self.model_dump_json()
 
     @staticmethod
     def seq_display(seq: Iterable["Display"], compact: bool = False) -> str:
-        """Display a sequence of Display objects in a formatted JSON string.
+        """Generate formatted display for sequence of Display objects.
 
         Args:
-            seq (Iterable[Display]): The sequence of Display objects to display.
-            compact (bool): Whether to display the sequence in a compact format. Defaults to False.
+            seq (Iterable[Display]): Sequence of objects to display
+            compact (bool): Use compact format instead of pretty print
 
         Returns:
-            str: The formatted JSON string of the sequence.
+            str: Combined display output with boundary markers
         """
-        return "\n".join(d.compact() if compact else d.display() for d in seq)
+        return (
+            "--- Start of Extra Info Sequence ---"
+            + "\n".join(d.compact() if compact else d.display() for d in seq)
+            + "--- End of Extra Info Sequence ---"
+        )
 
 
 class Named(Base):
@@ -184,25 +189,29 @@ class WithRef[T](Base):
 
 
 class PersistentAble(Base):
-    """Class that provides a method to persist the object.
+    """Class providing file persistence capabilities.
 
-    This class includes methods to persist the object to a file or directory.
+    Enables saving model instances to disk with timestamped filenames and loading from persisted files.
+    Implements basic versioning through filename hashing and timestamping.
     """
-
     def persist(self, path: str | Path) -> Self:
-        """Persist the object to a file or directory.
+        """Save model instance to disk with versioned filename.
 
         Args:
-            path (str | Path): The path to save the object.
+            path (str | Path): Target directory or file path. If directory, filename is auto-generated.
 
         Returns:
-            Self: The current instance of the object.
+            Self: Current instance for method chaining
+
+        Notes:
+            - Filename format: <ClassName>_<YYYYMMDD_HHMMSS>_<6-char_hash>.json
+            - Hash generated from JSON content ensures uniqueness
         """
         p = Path(path)
         out = self.model_dump_json()
 
         # Generate a timestamp in the format YYYYMMDD_HHMMSS
-        timestamp = datetime.now().strftime("%Y%m%d")
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
 
         # Generate the hash
         file_hash = blake3_hash(out.encode())[:6]
@@ -219,15 +228,52 @@ class PersistentAble(Base):
         logger.info(f"Persisted `{self.__class__.__name__}` to {p.as_posix()}")
         return self
 
+    @classmethod
+    def from_latest_persistent(cls, dir_path: str | Path) -> Optional[Self]:
+        """Load most recent persisted instance from directory.
+
+        Args:
+            dir_path (str | Path): Directory containing persisted files
+
+        Returns:
+            Self: Most recently modified instance
+
+        Raises:
+            NotADirectoryError: If path is not a valid directory
+            FileNotFoundError: If no matching files found
+        """
+        dir_path = Path(dir_path)
+        if not dir_path.is_dir():
+            return None
+
+        pattern = f"{cls.__name__}_*.json"
+        files = list(dir_path.glob(pattern))
+
+        if not files:
+            return None
+
+        def _get_timestamp(file_path: Path) -> datetime:
+            stem = file_path.stem
+            parts = stem.split("_")
+            return datetime.strptime(f"{parts[1]}_{parts[2]}", "%Y%m%d_%H%M%S")
+
+        files.sort(key=lambda f: _get_timestamp(f), reverse=True)
+
+        return cls.from_persistent(files.pop(0))
+
     @classmethod
     def from_persistent(cls, path: str | Path) -> Self:
-        """Load the object from a file.
+        """Load an instance from a specific persisted file.
 
         Args:
-            path (str | Path): The path to load the object from.
+            path (str | Path): Path to the JSON file.
 
         Returns:
-            Self: The current instance of the object.
+            Self: The loaded instance from the file.
+
+        Raises:
+            FileNotFoundError: If the specified file does not exist.
+            ValueError: If the file content is invalid for the model.
         """
         return cls.model_validate_json(safe_text_read(path))
 
@@ -236,7 +282,7 @@ class Language(Base):
     """Class that provides a language attribute."""
 
     language: str
-    """The written language of this object, which should be aligned to the original requirement 
+    """The written language of this object, which should be aligned to the original requirement
     For example if the requirement is in Chinese, the language should be set to `zh`, if the requirement is in English, the language should be set to `en` and etc."""
 
 
@@ -619,11 +665,11 @@ class Vectorizable(Base):
 
 
 class ScopedConfig(Base):
-    """Class that manages a scoped configuration.
+    """Configuration holder with hierarchical fallback mechanism.
 
-    This class includes attributes and methods to manage configuration settings scoped to the instance.
+    Manages LLM, embedding, and vector database configurations with fallback logic.
+    Allows configuration values to be overridden in a hierarchical manner.
     """
-
     llm_api_endpoint: Optional[HttpUrl] = None
     """The OpenAI API endpoint."""
 
@@ -698,13 +744,15 @@ class ScopedConfig(Base):
 
     @final
     def fallback_to(self, other: "ScopedConfig") -> Self:
-        """Fallback to another instance's attribute values if the current instance's attributes are None.
+        """Merge configuration values with fallback priority.
+
+        Copies non-null values from 'other' to self where current values are None.
 
         Args:
-            other (ScopedConfig): Another instance from which to copy attribute values.
+            other (ScopedConfig): Configuration to fallback to
 
         Returns:
-            Self: The current instance, allowing for method chaining.
+            Self: Current instance with merged values
         """
         # Iterate over the attribute names and copy values from 'other' to 'self' where applicable
         # noinspection PydanticTypeChecker,PyTypeChecker
@@ -718,13 +766,15 @@ class ScopedConfig(Base):
 
     @final
     def hold_to(self, others: Union["ScopedConfig", Iterable["ScopedConfig"]]) -> Self:
-        """Hold to another instance's attribute values if the current instance's attributes are None.
+        """Propagate non-null values to other configurations.
+
+        Copies current non-null values to target configurations where they are None.
 
         Args:
-            others (Union[ScopedConfig, Iterable[ScopedConfig]]): Another instance or iterable of instances from which to copy attribute values.
+            others (ScopedConfig|Iterable): Target configurations to update
 
         Returns:
-            Self: The current instance, allowing for method chaining.
+            Self: Current instance unchanged
         """
         if not isinstance(others, Iterable):
             others = [others]
@@ -777,14 +827,15 @@ class Patch[T](ProposedAble):
             str: The JSON schema of the model in a formatted string.
         """
         my_schema = cls.model_json_schema(schema_generator=UnsortGenerate)
-        if (ref_cls := cls.ref_cls()) is not None:
+
+        ref_cls = cls.ref_cls()
+        if ref_cls is not None:
             # copy the desc info of each corresponding fields from `ref_cls`
-            for field_name, field_info in cls.model_fields.items():
-                if (ref_field := getattr(ref_cls, field_name, None)) is not None:
-                    if (desc := ref_field.field_info.description) is not None:
-                        my_schema["properties"][field_name]["description"] = desc
-                    if (example := ref_field.field_info.examples) is not None:
-                        my_schema["properties"][field_name]["examples"] = example
+            for field_name in [f for f in cls.model_fields if f in ref_cls.model_fields]:
+                my_schema["properties"][field_name]["description"] = (
+                    ref_cls.model_fields[field_name].description or my_schema["properties"][field_name]["description"]
+                )
+            my_schema["description"] = ref_cls.__doc__
 
         return orjson.dumps(
             my_schema,

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,5 +1,23 @@
+"""
+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 Any, Dict, List, Optional
+from typing import List, Optional
+
+from pydantic import JsonValue
+
 
 class TemplateManager:
     """Template rendering engine using Handlebars templates.
@@ -41,7 +59,7 @@ class TemplateManager:
         This refreshes the template cache, finding any new or modified templates.
         """
 
-    def render_template(self, name: str, data: Dict[str, Any]) -> str:
+    def render_template(self, name: str, data: JsonValue) -> str:
         """Render a template with context data.
 
         Args:
@@ -55,7 +73,7 @@ class TemplateManager:
             RuntimeError: If template rendering fails
         """
 
-    def render_template_raw(self, template: str, data: Dict[str, Any]) -> str:
+    def render_template_raw(self, template: str, data: JsonValue) -> str:
         """Render a template with context data.
 
         Args:
@@ -76,9 +94,31 @@ def blake3_hash(content: bytes) -> str:
         Hex-encoded BLAKE3 hash string
     """
 
-def detect_language(string:str)->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."""
 
@@ -165,7 +205,7 @@ class BibManager:
             Title if found, None otherwise
         """
 
-    def get_field_by_key(self, key: str, field: str)-> Optional[str]:
+    def get_field_by_key(self, key: str, field: str) -> Optional[str]:
         """Retrieve a specific field by citation key.
 
         Args:

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
 

fabricatio/workflows/articles.py

@@ -1,6 +1,6 @@
 """Store article essence in the database."""
 
-from fabricatio.actions.article import CorrectOutline, CorrectProposal, GenerateArticleProposal, GenerateOutline
+from fabricatio.actions.article import GenerateArticleProposal, GenerateInitialOutline
 from fabricatio.actions.output import DumpFinalizedOutput
 from fabricatio.models.action import WorkFlow
 
@@ -9,7 +9,7 @@ WriteOutlineWorkFlow = WorkFlow(
     description="Generate an outline for an article. dump the outline to the given path. in typst format.",
     steps=(
         GenerateArticleProposal,
-        GenerateOutline(output_key="to_dump"),
+        GenerateInitialOutline(output_key="article_outline"),
         DumpFinalizedOutput(output_key="task_output"),
     ),
 )
@@ -18,9 +18,7 @@ WriteOutlineCorrectedWorkFlow = WorkFlow(
     description="Generate an outline for an article. dump the outline to the given path. in typst format.",
     steps=(
         GenerateArticleProposal,
-        CorrectProposal(output_key="article_proposal"),
-        GenerateOutline,
-        CorrectOutline(output_key="to_dump"),
+        GenerateInitialOutline(output_key="article_outline"),
         DumpFinalizedOutput(output_key="task_output"),
     ),
 )

{fabricatio-0.2.9.dev1.dist-info → fabricatio-0.2.9.dev3.dist-info}/METADATA

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