fabricatio 0.3.15.dev5__cp313-cp313-win_amd64.whl → 0.4.0.dev0__cp313-cp313-win_amd64.whl

fabricatio/models/extra/article_main.py

@@ -1,285 +0,0 @@
-"""ArticleBase and ArticleSubsection classes for managing hierarchical document components."""
-
-from typing import ClassVar, Dict, Generator, List, Self, Tuple, Type, override
-
-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, PersistentAble, SequencePatch, SketchedAble, WithRef, WordCount
-from fabricatio.rust import (
-    convert_all_tex_math,
-    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_word_count(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 exact_word_count(self) -> int:
-        """Calculates the exact word count of all paragraphs in the subsection."""
-        return sum(a.exact_word_count for a in self.paragraphs)
-
-    @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_tex_math(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_tex_math(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_word_count <= threshold:
-                    err.append(
-                        f"{chap.title}->{sec.title}->{subsec.title}-> Paragraph [{i}] is too short, {p.exact_word_count} words."
-                    )
-
-        return "\n".join(err)

fabricatio/models/extra/article_outline.py

@@ -1,45 +0,0 @@
-"""A module containing the ArticleOutline class, which represents the outline of an academic paper."""
-
-from typing import ClassVar, Dict, Type
-
-from fabricatio.models.extra.article_base import (
-    ArticleBase,
-    ChapterBase,
-    SectionBase,
-    SubSectionBase,
-)
-from fabricatio.models.extra.article_proposal import ArticleProposal
-from fabricatio.models.generic import PersistentAble, 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

@@ -1,52 +0,0 @@
-"""A structured proposal for academic paper development with core research elements."""
-
-from typing import Dict, List
-
-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.
-    """
-
-    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

@@ -1,20 +0,0 @@
-"""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

@@ -1,165 +0,0 @@
-"""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

@@ -1,98 +0,0 @@
-"""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