fabricatio 0.2.1.dev0__cp313-cp313-win_amd64.whl → 0.3.14.dev5__cp313-cp313-win_amd64.whl

fabricatio/models/extra/article_main.py

@@ -0,0 +1,284 @@
+"""ArticleBase and ArticleSubsection classes for managing hierarchical document components."""
+
+from typing import ClassVar, Dict, Generator, List, Self, Tuple, Type, override
+
+from fabricatio.capabilities.persist import PersistentAble
+from fabricatio.decorators import precheck_package
+from fabricatio.journal import logger
+from fabricatio.models.extra.article_base import (
+    ArticleBase,
+    ChapterBase,
+    SectionBase,
+    SubSectionBase,
+)
+from fabricatio.models.extra.article_outline import (
+    ArticleChapterOutline,
+    ArticleOutline,
+    ArticleSectionOutline,
+    ArticleSubsectionOutline,
+)
+from fabricatio.models.generic import Described, SequencePatch, SketchedAble, WithRef, WordCount
+from fabricatio.rust import (
+    convert_all_block_tex,
+    convert_all_inline_tex,
+    fix_misplaced_labels,
+    split_out_metadata,
+    word_count,
+)
+from pydantic import Field, NonNegativeInt
+
+PARAGRAPH_SEP = "// - - -"
+
+
+class Paragraph(SketchedAble, WordCount, Described):
+    """Structured academic paragraph blueprint for controlled content generation."""
+
+    expected_word_count: NonNegativeInt = 0
+    """The expected word count of this paragraph, 0 means not specified"""
+
+    description: str = Field(
+        alias="elaboration",
+        description=Described.model_fields["description"].description,
+    )
+
+    aims: List[str]
+    """Specific communicative objectives for this paragraph's content."""
+
+    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.strip())
+
+    @property
+    def exact_wordcount(self) -> int:
+        """Calculates the exact word count of the content."""
+        return word_count(self.content)
+
+
+class ArticleParagraphSequencePatch(SequencePatch[Paragraph]):
+    """Patch for `Paragraph` list of `ArticleSubsection`."""
+
+
+class ArticleSubsection(SubSectionBase):
+    """Atomic argumentative unit with technical specificity."""
+
+    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 summary of its state."""
+        summary = ""
+        if len(self.paragraphs) == 0:
+            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
+        ):
+            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."""
+        logger.debug(f"Updating SubSection {self.title}")
+        super().update_from_inner(other)
+        self.paragraphs.clear()
+        self.paragraphs.extend(other.paragraphs)
+        return self
+
+    def to_typst_code(self) -> str:
+        """Converts the component into a Typst code snippet for rendering.
+
+        Returns:
+            str: Typst code snippet for rendering.
+        """
+        return super().to_typst_code() + f"\n\n{PARAGRAPH_SEP}\n\n".join(p.content for p in self.paragraphs)
+
+    @classmethod
+    def from_typst_code(cls, title: str, body: str, **kwargs) -> Self:
+        """Creates an Article object from the given Typst code."""
+        _, para_body = split_out_metadata(body)
+
+        return super().from_typst_code(
+            title,
+            body,
+            paragraphs=[Paragraph.from_content(p) for p in para_body.split(PARAGRAPH_SEP)],
+        )
+
+
+class ArticleSection(SectionBase[ArticleSubsection]):
+    """Atomic argumentative unit with high-level specificity."""
+
+    child_type: ClassVar[Type[SubSectionBase]] = ArticleSubsection
+
+
+class ArticleChapter(ChapterBase[ArticleSection]):
+    """Thematic progression implementing research function."""
+
+    child_type: ClassVar[Type[SectionBase]] = ArticleSection
+
+
+class Article(
+    WithRef[ArticleOutline],
+    PersistentAble,
+    ArticleBase[ArticleChapter],
+):
+    """Represents a complete academic paper specification, incorporating validation constraints.
+
+    This class integrates display, censorship processing, article structure referencing, and persistence capabilities,
+    aiming to provide a comprehensive model for academic papers.
+    """
+
+    child_type: ClassVar[Type[ChapterBase]] = ArticleChapter
+
+    def _as_prompt_inner(self) -> Dict[str, str]:
+        return {
+            "Original Article Briefing": self.referenced.referenced.referenced,
+            "Original Article Proposal": self.referenced.referenced.display(),
+            "Original Article Outline": self.referenced.display(),
+            "Original Article": self.display(),
+        }
+
+    def convert_tex(self, paragraphs: bool = True, descriptions: bool = True) -> Self:
+        """Convert tex to typst code."""
+        if descriptions:
+            for a in self.iter_dfs():
+                a.description = fix_misplaced_labels(a.description)
+                a.description = convert_all_inline_tex(a.description)
+                a.description = convert_all_block_tex(a.description)
+
+        if paragraphs:
+            for _, _, subsec in self.iter_subsections():
+                for p in subsec.paragraphs:
+                    p.content = fix_misplaced_labels(p.content)
+                    p.content = convert_all_inline_tex(p.content)
+                    p.content = convert_all_block_tex(p.content)
+        return self
+
+    @override
+    def iter_subsections(self) -> Generator[Tuple[ArticleChapter, ArticleSection, ArticleSubsection], None, None]:
+        return super().iter_subsections()  # pyright: ignore [reportReturnType]
+
+    def extrac_outline(self) -> ArticleOutline:
+        """Extract outline from article."""
+        # Create an empty list to hold chapter outlines
+        chapters = []
+
+        # Iterate through each chapter in the article
+        for chapter in self.chapters:
+            # Create an empty list to hold section outlines
+            sections = []
+
+            # Iterate through each section in the chapter
+            for section in chapter.sections:
+                # Create an empty list to hold subsection outlines
+                subsections = []
+
+                # Iterate through each subsection in the section
+                for subsection in section.subsections:
+                    # Create a subsection outline and add it to the list
+                    subsections.append(
+                        ArticleSubsectionOutline(**subsection.model_dump(exclude={"paragraphs"}, by_alias=True))
+                    )
+
+                # Create a section outline and add it to the list
+                sections.append(
+                    ArticleSectionOutline(
+                        **section.model_dump(exclude={"subsections"}, by_alias=True),
+                        subsections=subsections,
+                    )
+                )
+
+            # Create a chapter outline and add it to the list
+            chapters.append(
+                ArticleChapterOutline(
+                    **chapter.model_dump(exclude={"sections"}, by_alias=True),
+                    sections=sections,
+                )
+            )
+
+        # Create and return the article outline
+        return ArticleOutline(
+            **self.model_dump(exclude={"chapters"}, by_alias=True),
+            chapters=chapters,
+        )
+
+    @classmethod
+    def from_outline(cls, outline: ArticleOutline) -> "Article":
+        """Generates an article from the given outline.
+
+        Args:
+            outline (ArticleOutline): The outline to generate the article from.
+
+        Returns:
+            Article: The generated article.
+        """
+        # Set the title from the outline
+        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"}, by_alias=True),
+            )
+            for section in chapter.sections:
+                # Create a new section
+                article_section = ArticleSection(
+                    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(by_alias=True),
+                    )
+                    article_section.subsections.append(article_subsection)
+                article_chapter.sections.append(article_section)
+            article.chapters.append(article_chapter)
+        return article
+
+    @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)
+
+    @precheck_package(
+        "questionary", "'questionary' is required to run this function. Have you installed `fabricatio[qa]`?."
+    )
+    async def edit_titles(self) -> Self:
+        """Edits the titles of the article."""
+        from questionary import text
+
+        for a in self.iter_dfs():
+            a.title = await text(f"Edit `{a.title}`.", default=a.title).ask_async() or a.title
+        return self
+
+    def check_short_paragraphs(self, threshold: int = 60) -> str:
+        """Checks for short paragraphs in the article."""
+        err = []
+        for chap, sec, subsec in self.iter_subsections():
+            for i, p in enumerate(subsec.paragraphs):
+                if p.exact_wordcount <= threshold:
+                    err.append(
+                        f"{chap.title}->{sec.title}->{subsec.title}-> Paragraph [{i}] is too short, {p.exact_wordcount} words."
+                    )
+
+        return "\n".join(err)

fabricatio/models/extra/article_outline.py

@@ -0,0 +1,46 @@
+"""A module containing the ArticleOutline class, which represents the outline of an academic paper."""
+
+from typing import ClassVar, Dict, Type
+
+from fabricatio.capabilities.persist import PersistentAble
+from fabricatio.models.extra.article_base import (
+    ArticleBase,
+    ChapterBase,
+    SectionBase,
+    SubSectionBase,
+)
+from fabricatio.models.extra.article_proposal import ArticleProposal
+from fabricatio.models.generic import WithRef
+
+
+class ArticleSubsectionOutline(SubSectionBase):
+    """Atomic research component specification for academic paper generation."""
+
+
+class ArticleSectionOutline(SectionBase[ArticleSubsectionOutline]):
+    """A slightly more detailed research component specification for academic paper generation, Must contain subsections."""
+
+    child_type: ClassVar[Type[SubSectionBase]] = ArticleSubsectionOutline
+
+
+class ArticleChapterOutline(ChapterBase[ArticleSectionOutline]):
+    """Macro-structural unit implementing standard academic paper organization. Must contain sections."""
+
+    child_type: ClassVar[Type[SectionBase]] = ArticleSectionOutline
+
+
+class ArticleOutline(
+    WithRef[ArticleProposal],
+    PersistentAble,
+    ArticleBase[ArticleChapterOutline],
+):
+    """Outline of an academic paper, containing chapters, sections, subsections."""
+
+    child_type: ClassVar[Type[ChapterBase]] = ArticleChapterOutline
+
+    def _as_prompt_inner(self) -> Dict[str, str]:
+        return {
+            "Original Article Briefing": self.referenced.referenced,
+            "Original Article Proposal": self.referenced.display(),
+            "Original Article Outline": self.display(),
+        }

fabricatio/models/extra/article_proposal.py

@@ -0,0 +1,52 @@
+"""A structured proposal for academic paper development with core research elements."""
+
+from typing import Dict, List
+
+from fabricatio.capabilities.persist import PersistentAble
+from fabricatio.models.generic import (
+    AsPrompt,
+    Described,
+    Language,
+    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.
+    """
+
+    focused_problem: List[str]
+    """A list of specific research problems or questions that the paper aims to address."""
+
+    technical_approaches: List[str]
+    """A list of technical approaches or methodologies used to solve the research problems."""
+
+    research_methods: List[str]
+    """A list of methodological components, including techniques and tools utilized in the research."""
+
+    research_aim: List[str]
+    """A list of primary research objectives that the paper seeks to achieve."""
+
+    literature_review: List[str]
+    """A list of key references and literature that support the research context and background."""
+
+    expected_outcomes: List[str]
+    """A list of anticipated results or contributions that the research aims to achieve."""
+
+    keywords: List[str]
+    """A list of keywords that represent the main topics and focus areas of the research."""
+
+    description: str = Field(alias="abstract")
+    """A concise summary of the research proposal, outlining the main points and objectives."""
+
+    def _as_prompt_inner(self) -> Dict[str, str]:
+        return {
+            "ArticleBriefing": self.referenced,
+            "ArticleProposal": self.display(),
+        }

fabricatio/models/extra/patches.py

@@ -0,0 +1,20 @@
+"""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."""
+
+from typing import Optional, Type
+
+from fabricatio.models.extra.rule import RuleSet
+from fabricatio.models.generic import Language, Patch, WithBriefing
+from pydantic import BaseModel
+
+
+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 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."""
+        return RuleSet

fabricatio/models/extra/problem.py

@@ -0,0 +1,165 @@
+"""A class representing a problem-solution pair identified during a review process."""
+
+from itertools import chain
+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 rich import print as r_print
+
+
+class Problem(SketchedAble, WithBriefing):
+    """Represents a problem identified during review."""
+
+    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_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."""
+
+
+class Solution(SketchedAble, WithBriefing):
+    """Represents a proposed solution to a problem."""
+
+    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, and which should be an Idiot-proof tutorial."""
+
+    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_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):
+    """Represents a problem-solution pair identified during a review process."""
+
+    problem: Problem
+    """The problem identified in the review."""
+    solutions: List[Solution]
+    """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."""
+        self.solutions.clear()
+        self.solutions.extend(other.solutions)
+        return self
+
+    def update_problem(self, problem: Problem) -> Self:
+        """Update the problem description."""
+        self.problem = problem
+        return self
+
+    def update_solutions(self, solutions: List[Solution]) -> Self:
+        """Update the list of potential solutions."""
+        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."""
+        from questionary import text
+
+        """Interactively edit the problem description."""
+        self.problem = Problem.model_validate_strings(
+            await text("Please edit the problem below:", default=self.problem.display()).ask_async()
+        )
+        return self
+
+    async def edit_solutions(self) -> Self:
+        """Interactively edit the list of potential solutions."""
+        r_print(self.problem.display())
+        string_seq = await ask_edit([s.display() for s in self.solutions])
+        self.solutions = [Solution.model_validate_strings(s) for s in string_seq]
+        return self
+
+    def decided(self) -> bool:
+        """Check if the improvement is decided."""
+        return len(self.solutions) == 1
+
+    def final_solution(self, always_use_first: bool = False) -> Optional[Solution]:
+        """Get the final solution."""
+        if not always_use_first and not self.decided():
+            logger.error(
+                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]
+
+
+class Improvement(SketchedAble):
+    """A class representing an improvement suggestion."""
+
+    focused_on: str
+    """The focused on topic of the improvement"""
+
+    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.
+
+        Presents an interactive prompt allowing a supervisor to select which
+        problems (and optionally solutions) should be retained in the final review.
+
+        Args:
+            check_solutions (bool, optional): When True, also prompts for filtering
+                individual solutions for each retained problem. Defaults to False.
+
+        Returns:
+            Self: The current instance with filtered problems and solutions.
+        """
+        from questionary import Choice, checkbox
+
+        # Choose the problems to retain
+        chosen_ones: List[ProblemSolutions] = await checkbox(
+            "Please choose the problems you want to retain.(Default: retain all)",
+            choices=[Choice(p.problem.name, p, checked=True) for p in self.problem_solutions],
+        ).ask_async()
+        self.problem_solutions = [await p.edit_problem() for p in chosen_ones]
+        if not check_solutions:
+            return self
+
+        # Choose the solutions to retain
+        for to_exam in self.problem_solutions:
+            to_exam.update_solutions(
+                await checkbox(
+                    f"Please choose the solutions you want to retain.(Default: retain all)\n\t`{to_exam.problem}`",
+                    choices=[Choice(s.name, s, checked=True) for s in to_exam.solutions],
+                ).ask_async()
+            )
+            await to_exam.edit_solutions()
+
+        return self
+
+    def decided(self) -> bool:
+        """Check if the improvement is decided."""
+        return all(ps.decided() for ps in self.problem_solutions)
+
+    @classmethod
+    def gather(cls, *improvements: Unpack[Tuple["Improvement", ...]]) -> Self:
+        """Gather multiple improvements into a single instance."""
+        return cls(
+            focused_on=";".join(imp.focused_on for imp in improvements),
+            problem_solutions=list(chain(*(imp.problem_solutions for imp in improvements))),
+        )

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 Base, 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(Base, 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