fabricatio 0.2.9.dev3__cp312-cp312-win_amd64.whl → 0.2.10__cp312-cp312-win_amd64.whl

fabricatio/models/extra/article_main.py

@@ -1,12 +1,14 @@
 """ArticleBase and ArticleSubsection classes for managing hierarchical document components."""
 
-from itertools import chain
 from typing import Dict, Generator, List, Self, Tuple, override
 
+from fabricatio.rust import word_count, convert_all_block_tex, convert_all_inline_tex
+from pydantic import Field
+
+from fabricatio.fs.readers import extract_sections
 from fabricatio.journal import logger
 from fabricatio.models.extra.article_base import (
     ArticleBase,
-    ArticleOutlineBase,
     ChapterBase,
     SectionBase,
     SubSectionBase,
@@ -14,26 +16,30 @@ from fabricatio.models.extra.article_base import (
 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
+from fabricatio.models.generic import Described, PersistentAble, SequencePatch, SketchedAble, WithRef, WordCount
+
+PARAGRAPH_SEP = "// - - -"
 
 
-class Paragraph(SketchedAble):
+class Paragraph(SketchedAble, WordCount, Described):
     """Structured academic paragraph blueprint for controlled content generation."""
 
-    description: str
-    """Functional summary of the paragraph's role in document structure."""
+    description: str = Field(
+        alias="elaboration",
+        description=Described.model_fields["description"].description,
+    )
 
-    writing_aim: List[str]
+    aims: 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."""
 
+    @classmethod
+    def from_content(cls, content: str) -> Self:
+        """Create a Paragraph object from the given content."""
+        return cls(elaboration="", aims=[], expected_word_count=word_count(content), content=content)
+
 
 class ArticleParagraphSequencePatch(SequencePatch[Paragraph]):
     """Patch for `Paragraph` list of `ArticleSubsection`."""
@@ -57,10 +63,10 @@ class ArticleSubsection(SubSectionBase):
         """Introspects the subsection and returns a summary of its state."""
         summary = ""
         if len(self.paragraphs) == 0:
-            summary += f"`{self.__class__.__name__}` titled `{self.title}` have no paragraphs!\n"
+            summary += f"`{self.__class__.__name__}` titled `{self.title}` have no paragraphs, You should add some!\n"
         if (
-            abs((wc := self.word_count) - self.expected_word_count) / self.expected_word_count
-            > self._max_word_count_deviation
+                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!"
 
@@ -80,16 +86,53 @@ class ArticleSubsection(SubSectionBase):
         Returns:
             str: Typst code snippet for rendering.
         """
-        return f"=== {self.title}\n" + "\n\n".join(p.content for p in self.paragraphs)
+        return f"=== {self.title}\n" + f"\n{PARAGRAPH_SEP}\n".join(p.content for p in self.paragraphs)
+
+    @classmethod
+    def from_typst_code(cls, title: str, body: str) -> Self:
+        """Creates an Article object from the given Typst code."""
+        return cls(
+            heading=title,
+            elaboration="",
+            paragraphs=[Paragraph.from_content(p) for p in body.split(PARAGRAPH_SEP)],
+            expected_word_count=word_count(body),
+            aims=[],
+        )
 
 
 class ArticleSection(SectionBase[ArticleSubsection]):
     """Atomic argumentative unit with high-level specificity."""
 
+    @classmethod
+    def from_typst_code(cls, title: str, body: str) -> Self:
+        """Creates an Article object from the given Typst code."""
+        return cls(
+            subsections=[
+                ArticleSubsection.from_typst_code(*pack) for pack in extract_sections(body, level=3, section_char="=")
+            ],
+            heading=title,
+            elaboration="",
+            expected_word_count=word_count(body),
+            aims=[],
+        )
+
 
 class ArticleChapter(ChapterBase[ArticleSection]):
     """Thematic progression implementing research function."""
 
+    @classmethod
+    def from_typst_code(cls, title: str, body: str) -> Self:
+        """Creates an Article object from the given Typst code."""
+        return cls(
+            sections=[
+                ArticleSection.from_typst_code(*pack) for pack in extract_sections(body, level=2, section_char="=")
+            ],
+            heading=title,
+            elaboration="",
+            expected_word_count=word_count(body),
+            aims=[],
+        )
+
 
 class Article(
     SketchedAble,
@@ -111,6 +154,22 @@ class Article(
             "Original Article": self.display(),
         }
 
+    def convert_tex(self) -> Self:
+        """Convert tex to typst code"""
+        for _, _, subsec in self.iter_subsections():
+            for p in subsec.paragraphs:
+                p.content = convert_all_inline_tex(p.content)
+                p.content = convert_all_block_tex(p.content)
+        return self
+
+    def fix_wrapper(self) -> Self:
+        """Fix wrapper"""
+        for _, _, subsec in self.iter_subsections():
+            for p in subsec.paragraphs:
+                p.content = p.content.replace(r" \( ", "$").replace(r" \) ", "$").replace("\\[\n", "$$\n").replace(
+                    "\n\\]", "\n$$")
+        return self
+
     @override
     def iter_subsections(self) -> Generator[Tuple[ArticleChapter, ArticleSection, ArticleSubsection], None, None]:
         return super().iter_subsections()  # pyright: ignore [reportReturnType]
@@ -126,107 +185,49 @@ class Article(
             Article: The generated article.
         """
         # Set the title from the outline
-        article = Article(**outline.model_dump(exclude={"chapters"}), chapters=[])
+        article = Article(**outline.model_dump(exclude={"chapters"}, by_alias=True), chapters=[])
 
         for chapter in outline.chapters:
             # Create a new chapter
             article_chapter = ArticleChapter(
                 sections=[],
-                **chapter.model_dump(exclude={"sections"}),
+                **chapter.model_dump(exclude={"sections"}, by_alias=True),
             )
             for section in chapter.sections:
                 # Create a new section
                 article_section = ArticleSection(
                     subsections=[],
-                    **section.model_dump(exclude={"subsections"}),
+                    **section.model_dump(exclude={"subsections"}, by_alias=True),
                 )
                 for subsection in section.subsections:
                     # Create a new subsection
                     article_subsection = ArticleSubsection(
                         paragraphs=[],
-                        **subsection.model_dump(),
+                        **subsection.model_dump(by_alias=True),
                     )
                     article_section.subsections.append(article_subsection)
                 article_chapter.sections.append(article_section)
             article.chapters.append(article_chapter)
         return article
 
-    def gather_dependencies(self, article: ArticleOutlineBase) -> List[ArticleOutlineBase]:
-        """Gathers dependencies for all sections and subsections in the article.
-
-        This method should be called after the article is fully constructed.
-        """
-        depends = [ok(a.deref(self)) for a in article.depend_on]
-
-        supports = []
-        for a in self.iter_dfs_rev():
-            if article in {ok(b.deref(self)) for b in a.support_to}:
-                supports.append(a)
-
-        return list(set(depends + supports))
-
-    def gather_dependencies_recursive(self, article: ArticleOutlineBase) -> List[ArticleOutlineBase]:
-        """Gathers all dependencies recursively for the given article.
-
-        Args:
-            article (ArticleOutlineBase): The article to gather dependencies for.
-
-        Returns:
-            List[ArticleBase]: A list of all dependencies for the given article.
-        """
-        q = self.gather_dependencies(article)
-
-        deps = []
-        while q:
-            a = q.pop()
-            deps.extend(self.gather_dependencies(a))
-
-        deps = list(
-            chain(
-                filter(lambda x: isinstance(x, ArticleChapter), deps),
-                filter(lambda x: isinstance(x, ArticleSection), deps),
-                filter(lambda x: isinstance(x, ArticleSubsection), deps),
-            )
+    @classmethod
+    def from_typst_code(cls, title: str, body: str) -> Self:
+        """Generates an article from the given Typst code."""
+        return cls(
+            chapters=[
+                ArticleChapter.from_typst_code(*pack) for pack in extract_sections(body, level=1, section_char="=")
+            ],
+            heading=title,
+            expected_word_count=word_count(body),
+            abstract="",
         )
 
-        # Initialize result containers
-        formatted_code = ""
-        processed_components = []
-
-        # Process all dependencies
-        while deps:
-            component = deps.pop()
-            # Skip duplicates
-            if (component_code := component.to_typst_code()) in formatted_code:
-                continue
-
-            # Add this component
-            formatted_code += component_code
-            processed_components.append(component)
-
-        return processed_components
-
-    def iter_dfs_with_deps(
-        self, chapter: bool = True, section: bool = True, subsection: bool = True
-    ) -> Generator[Tuple[ArticleOutlineBase, List[ArticleOutlineBase]], 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_rev():
-            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))
+    @classmethod
+    def from_mixed_source(cls, article_outline: ArticleOutline, typst_code: str) -> Self:
+        """Generates an article from the given outline and Typst code."""
+        self = cls.from_typst_code(article_outline.title, typst_code)
+        self.expected_word_count = article_outline.expected_word_count
+        self.description = article_outline.description
+        for a, o in zip(self.iter_dfs(), article_outline.iter_dfs(), strict=True):
+            a.update_metadata(o)
+        return self.update_ref(article_outline)

fabricatio/models/extra/article_proposal.py

@@ -2,21 +2,25 @@
 
 from typing import Dict, List
 
-from fabricatio.models.generic import AsPrompt, PersistentAble, SketchedAble, WithRef
-
-
-class ArticleProposal(SketchedAble, WithRef[str], AsPrompt, PersistentAble):
+from fabricatio.models.generic import (
+    AsPrompt,
+    Described,
+    Language,
+    PersistentAble,
+    SketchedAble,
+    Titled,
+    WithRef,
+    WordCount,
+)
+from pydantic import Field
+
+
+class ArticleProposal(SketchedAble, WithRef[str], AsPrompt, PersistentAble, WordCount, Described, Titled, Language):
     """Structured proposal for academic paper development with core research elements.
 
     Guides LLM in generating comprehensive research proposals with clearly defined components.
     """
 
-    language: str
-    """The language in which the article is written. This should align with the language specified in the article briefing."""
-
-    title: str
-    """The title of the academic paper, formatted in Title Case."""
-
     focused_problem: List[str]
     """A list of specific research problems or questions that the paper aims to address."""
 
@@ -38,12 +42,9 @@ class ArticleProposal(SketchedAble, WithRef[str], AsPrompt, PersistentAble):
     keywords: List[str]
     """A list of keywords that represent the main topics and focus areas of the research."""
 
-    abstract: str
+    description: str = Field(alias="abstract")
     """A concise summary of the research proposal, outlining the main points and objectives."""
 
-    expected_word_count: int
-    """The estimated word count of the final academic paper."""
-
     def _as_prompt_inner(self) -> Dict[str, str]:
         return {
             "ArticleBriefing": self.referenced,

fabricatio/models/extra/patches.py

@@ -3,17 +3,17 @@
 from typing import Optional, Type
 
 from fabricatio.models.extra.rule import RuleSet
-from fabricatio.models.generic import Patch, WithBriefing
+from fabricatio.models.generic import Language, Patch, WithBriefing
 from pydantic import BaseModel
 
 
-class BriefingPatch[T: WithBriefing](Patch[T], WithBriefing):
-    """Patch class for updating the description and name of a `WithBriefing` object, all fields within this instance will be directly copied onto the target model's field."""
+class BriefingMetadata[T: WithBriefing](Patch[T], WithBriefing):
+    """A patch class for updating the description and name of a `WithBriefing` object, all fields within this instance will be directly copied onto the target model's field."""
 
 
-class RuleSetBriefingPatch(BriefingPatch[RuleSet]):
-    """Patch class for updating the description and name of a `RuleSet` object, all fields within this instance will be directly copied onto the target model's field."""
-    language: str
+class RuleSetMetadata(BriefingMetadata[RuleSet], Language):
+    """A patch class for updating the description and name of a `RuleSet` object, all fields within this instance will be directly copied onto the target model's field."""
+
     @staticmethod
     def ref_cls() -> Optional[Type[BaseModel]]:
         """Get the reference class of the model."""

fabricatio/models/extra/problem.py

@@ -1,11 +1,12 @@
 """A class representing a problem-solution pair identified during a review process."""
 
 from itertools import chain
-from typing import Any, List, Literal, Optional, Self, Tuple, Unpack
+from typing import Any, List, Optional, Self, Tuple, Unpack
 
 from fabricatio.journal import logger
 from fabricatio.models.generic import SketchedAble, WithBriefing
 from fabricatio.utils import ask_edit
+from pydantic import Field
 from questionary import Choice, checkbox, text
 from rich import print as r_print
 
@@ -13,36 +14,30 @@ from rich import print as r_print
 class Problem(SketchedAble, WithBriefing):
     """Represents a problem identified during review."""
 
-    description: str
-    """Description of the problem, The """
+    description: str = Field(alias="cause")
+    """The cause of the problem, including the root cause, the context, and the impact, make detailed enough for engineer to understand the problem and its impact."""
 
-    severity: Literal["low", "medium", "high"]
-    """Severity level of the problem."""
-
-    category: str
-    """Category of the problem."""
+    severity_level: int = Field(ge=0, le=10)
+    """Severity level of the problem, which is a number between 0 and 10, 0 means the problem is not severe, 10 means the problem is extremely severe."""
 
     location: str
     """Location where the problem was identified."""
 
-    recommendation: str
-    """Recommended solution or action."""
-
 
 class Solution(SketchedAble, WithBriefing):
     """Represents a proposed solution to a problem."""
 
-    description: str
+    description: str = Field(alias="mechanism")
     """Description of the solution, including a detailed description of the execution steps, and the mechanics, principle or fact."""
 
     execute_steps: List[str]
-    """A list of steps to execute to implement the solution, which is expected to be able to finally solve the corresponding problem."""
+    """A list of steps to execute to implement the solution, which is expected to be able to finally solve the corresponding problem, and which should be an Idiot-proof tutorial."""
 
-    feasibility: Literal["low", "medium", "high"]
-    """Feasibility level of the solution."""
+    feasibility_level: int = Field(ge=0, le=10)
+    """Feasibility level of the solution, which is a number between 0 and 10, 0 means the solution is not feasible, 10 means the solution is complete feasible."""
 
-    impact: Literal["low", "medium", "high"]
-    """Impact level of the solution."""
+    impact_level: int = Field(ge=0, le=10)
+    """Impact level of the solution, which is a number between 0 and 10, 0 means the solution is not impactful, 10 means the solution is extremely impactful."""
 
 
 class ProblemSolutions(SketchedAble):

fabricatio/models/extra/rag.py

@@ -0,0 +1,98 @@
+"""A module containing the RAG (Retrieval-Augmented Generation) models."""
+
+from abc import ABC
+from functools import partial
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Self, Sequence, Set
+
+from fabricatio.decorators import precheck_package
+from fabricatio.models.generic import Vectorizable
+from fabricatio.utils import ok
+from pydantic import JsonValue
+
+if TYPE_CHECKING:
+    from importlib.util import find_spec
+
+    from pydantic.fields import FieldInfo
+
+    if find_spec("pymilvus"):
+        from pymilvus import CollectionSchema
+
+
+class MilvusDataBase(Vectorizable, ABC):
+    """A base class for Milvus data."""
+
+    primary_field_name: ClassVar[str] = "id"
+    """The name of the primary field in Milvus."""
+    vector_field_name: ClassVar[str] = "vector"
+    """The name of the vector field in Milvus."""
+
+    index_type: ClassVar[str] = "FLAT"
+    """The type of index to be used in Milvus."""
+    metric_type: ClassVar[str] = "COSINE"
+    """The type of metric to be used in Milvus."""
+
+    def prepare_insertion(self, vector: List[float]) -> Dict[str, Any]:
+        """Prepares the data for insertion into Milvus.
+
+        Returns:
+            dict: A dictionary containing the data to be inserted into Milvus.
+        """
+        return {**self.model_dump(exclude_none=True, by_alias=True), self.vector_field_name: vector}
+
+    @classmethod
+    @precheck_package(
+        "pymilvus", "pymilvus is not installed. Have you installed `fabricatio[rag]` instead of `fabricatio`?"
+    )
+    def as_milvus_schema(cls, dimension: int = 1024) -> "CollectionSchema":
+        """Generates the schema for Milvus collection."""
+        from pymilvus import CollectionSchema, DataType, FieldSchema
+
+        fields = [
+            FieldSchema(cls.primary_field_name, dtype=DataType.INT64, is_primary=True, auto_id=True),
+            FieldSchema(cls.vector_field_name, dtype=DataType.FLOAT_VECTOR, dim=dimension),
+        ]
+
+        for k, v in cls.model_fields.items():
+            k: str
+            v: FieldInfo
+            schema = partial(FieldSchema, k, description=v.description or "")
+            anno = ok(v.annotation)
+
+            if anno == int:
+                fields.append(schema(dtype=DataType.INT64))
+            elif anno == str:
+                fields.append(schema(dtype=DataType.VARCHAR, max_length=65535))
+            elif anno == float:
+                fields.append(schema(dtype=DataType.DOUBLE))
+            elif anno == list[str] or anno == List[str] or anno == set[str] or anno == Set[str]:
+                fields.append(
+                    schema(dtype=DataType.ARRAY, element_type=DataType.VARCHAR, max_length=65535, max_capacity=4096)
+                )
+            elif anno == list[int] or anno == List[int] or anno == set[int] or anno == Set[int]:
+                fields.append(schema(dtype=DataType.ARRAY, element_type=DataType.INT64, max_capacity=4096))
+            elif anno == list[float] or anno == List[float] or anno == set[float] or anno == Set[float]:
+                fields.append(schema(dtype=DataType.ARRAY, element_type=DataType.DOUBLE, max_capacity=4096))
+            elif anno == JsonValue:
+                fields.append(schema(dtype=DataType.JSON))
+
+            else:
+                raise NotImplementedError(f"{k}:{anno} is not supported")
+
+        return CollectionSchema(fields)
+
+    @classmethod
+    def from_sequence(cls, data: Sequence[Dict[str, Any]]) -> List[Self]:
+        """Constructs a list of instances from a sequence of dictionaries."""
+        return [cls(**d) for d in data]
+
+
+class MilvusClassicModel(MilvusDataBase):
+    """A class representing a classic model stored in Milvus."""
+
+    text: str
+    """The text to be stored in Milvus."""
+    subject: str = ""
+    """The subject of the text."""
+
+    def _prepare_vectorization_inner(self) -> str:
+        return self.text

fabricatio/models/extra/rule.py

@@ -40,12 +40,11 @@ class RuleSet(SketchedAble, PersistentAble, WithBriefing, Language):
     framework for the topic or domain covered by the rule set."""
 
     @classmethod
-    def gather(cls, *rulesets: Unpack[Tuple["RuleSet",...]]) -> Self:
+    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)),