fabricatio 0.2.6.dev3__cp39-cp39-win_amd64.whl

fabricatio/models/events.py

@@ -0,0 +1,120 @@
+"""The module containing the Event class."""
+
+from typing import List, Self, Union
+
+from fabricatio.config import configs
+from fabricatio.models.utils import TaskStatus
+from pydantic import BaseModel, ConfigDict, Field
+
+type EventLike = Union[str, List[str], "Event"]
+
+
+class Event(BaseModel):
+    """A class representing an event."""
+
+    model_config = ConfigDict(use_attribute_docstrings=True)
+
+    segments: List[str] = Field(default_factory=list, frozen=True)
+    """ The segments of the namespaces."""
+
+    @classmethod
+    def instantiate_from(cls, event: EventLike) -> "Event":
+        """Create an Event instance from a string or list of strings or an Event instance.
+
+        Args:
+            event (EventLike): The event to instantiate from.
+
+        Returns:
+            Event: The Event instance.
+        """
+        if isinstance(event, Event):
+            return event.clone()
+        if isinstance(event, str):
+            event = event.split(configs.pymitter.delimiter)
+
+        return cls(segments=event)
+
+    @classmethod
+    def quick_instantiate(cls, event: EventLike) -> "Event":
+        """Create an Event instance from a string or list of strings or an Event instance and push a wildcard and pending segment.
+
+        Args:
+            event (EventLike): The event to instantiate from.
+
+        Returns:
+            Event: The Event instance.
+
+        Notes:
+            This method is used to create an Event instance from a string or list of strings or an Event instance and push a wildcard and pending segment.
+        """
+        return cls.instantiate_from(event).push_wildcard().push_pending()
+
+    def derive(self, event: EventLike) -> Self:
+        """Derive a new event from this event and another event or a string."""
+        return self.clone().concat(event)
+
+    def collapse(self) -> str:
+        """Collapse the event into a string."""
+        return configs.pymitter.delimiter.join(self.segments)
+
+    def clone(self) -> Self:
+        """Clone the event."""
+        return self.__class__(segments=list(self.segments))
+
+    def push(self, segment: str) -> Self:
+        """Push a segment to the event."""
+        if not segment:
+            raise ValueError("The segment must not be empty.")
+        if configs.pymitter.delimiter in segment:
+            raise ValueError("The segment must not contain the delimiter.")
+
+        self.segments.append(segment)
+        return self
+
+    def push_wildcard(self) -> Self:
+        """Push a wildcard segment to the event."""
+        return self.push("*")
+
+    def push_pending(self) -> Self:
+        """Push a pending segment to the event."""
+        return self.push(TaskStatus.Pending.value)
+
+    def push_running(self) -> Self:
+        """Push a running segment to the event."""
+        return self.push(TaskStatus.Running.value)
+
+    def push_finished(self) -> Self:
+        """Push a finished segment to the event."""
+        return self.push(TaskStatus.Finished.value)
+
+    def push_failed(self) -> Self:
+        """Push a failed segment to the event."""
+        return self.push(TaskStatus.Failed.value)
+
+    def push_cancelled(self) -> Self:
+        """Push a cancelled segment to the event."""
+        return self.push(TaskStatus.Cancelled.value)
+
+    def pop(self) -> str:
+        """Pop a segment from the event."""
+        return self.segments.pop()
+
+    def clear(self) -> Self:
+        """Clear the event."""
+        self.segments.clear()
+        return self
+
+    def concat(self, event: EventLike) -> Self:
+        """Concatenate another event to this event."""
+        self.segments.extend(Event.instantiate_from(event).segments)
+        return self
+
+    def __hash__(self) -> int:
+        """Return the hash of the event, using the collapsed string."""
+        return hash(self.collapse())
+
+    def __eq__(self, other: object) -> bool:
+        """Check if the event is equal to another event or a string."""
+        if not isinstance(other, (str , list , Event)):
+            return False
+        return self.collapse() == Event.instantiate_from(other).collapse()

fabricatio/models/extra.py

@@ -0,0 +1,171 @@
+"""Extra models for built-in actions."""
+
+from typing import List
+
+from fabricatio.models.generic import Base, Display, FinalizedDumpAble, PrepareVectorization, ProposedAble
+from pydantic import Field
+
+
+class Equation(Base):
+    """Structured representation of mathematical equations (including their physical or conceptual meanings)."""
+
+    description: str
+    """A concise explanation of the equation's meaning, purpose, and relevance in the context of the research."""
+
+    latex_code: str
+    """The LaTeX code used to represent the equation in a publication-ready format."""
+
+
+class Figure(Base):
+    """Structured representation of figures (including their academic significance and explanatory captions)."""
+
+    description: str
+    """A detailed explanation of the figure's content and its role in conveying key insights."""
+
+    figure_caption: str
+    """The caption accompanying the figure, summarizing its main points and academic value."""
+
+    figure_path: str
+    """The file path to the figure"""
+
+
+class Highlightings(Base):
+    """Structured representation of highlighted elements in an academic paper (including equations, algorithms, figures, and tables)."""
+
+    # Academic Achievements Showcase
+    highlighted_equations: List[Equation] = Field(default_factory=list)
+    """Core mathematical equations that represent breakthroughs in the field, accompanied by explanations of their physical or conceptual significance,Should always be in LaTeX format wrapped in $ or $$ signs."""
+
+    highlighted_algorithms: List[str] = Field(default_factory=list)
+    """Pseudocode for key algorithms, annotated to highlight innovative components."""
+
+    highlighted_figures: List[Figure] = Field(default_factory=list)
+    """Critical diagrams or illustrations, each accompanied by a caption explaining their academic importance."""
+
+    highlighted_tables: List[str] = Field(default_factory=list)
+    """Important data tables, annotated to indicate statistical significance or other notable findings."""
+
+
+class ArticleEssence(ProposedAble, Display, PrepareVectorization):
+    """Structured representation of the core elements of an academic paper(providing a comprehensive digital profile of the paper's essential information)."""
+
+    # Basic Metadata
+    title: str = Field(...)
+    """The full title of the paper, including any subtitles if applicable."""
+
+    authors: List[str]
+    """A list of the paper's authors, typically in the order of contribution."""
+
+    keywords: List[str]
+    """A list of keywords that summarize the paper's focus and facilitate indexing."""
+
+    publication_year: int
+    """The year in which the paper was published."""
+
+    # Core Content Elements
+    highlightings: Highlightings = Field(default_factory=Highlightings)
+    """A collection of highlighted elements in the paper, including equations, algorithms, figures, and tables."""
+
+    domain: List[str]
+    """The research domains or fields addressed by the paper (e.g., ['Natural Language Processing', 'Computer Vision'])."""
+
+    abstract: str = Field(...)
+    """A structured abstract that outlines the research problem, methodology, and conclusions in three distinct sections."""
+
+    core_contributions: List[str]
+    """Key academic contributions that distinguish the paper from prior work in the field."""
+
+    technical_novelty: List[str]
+    """Specific technical innovations introduced by the research, listed as individual points."""
+
+    # Academic Discussion Dimensions
+    research_problems: List[str]
+    """A clearly defined research question or problem addressed by the study."""
+
+    limitations: List[str]
+    """An analysis of the methodological or experimental limitations of the research."""
+
+    future_work: List[str]
+    """Suggestions for potential directions or topics for follow-up studies."""
+
+    impact_analysis: List[str]
+    """An assessment of the paper's potential influence on the development of the field."""
+
+    def _prepare_vectorization_inner(self) -> str:
+        return self.model_dump_json()
+
+
+class ArticleProposal(ProposedAble, Display):
+    """Structured representation of the proposal for an academic paper."""
+
+    title: str = Field(...)
+    """The proposed title of the paper."""
+
+    focused_problem: List[str] = Field(default_factory=list)
+    """The specific research problem or question that the paper aims to address."""
+    research_aim: List[str] = Field(default_factory=list)
+    """The main objective or goal of the research, outlining what the study aims to achieve."""
+    research_methods: List[str] = Field(default_factory=list)
+    """The methods used in the research, including the approach, techniques, and tools employed."""
+
+
+class ArticleSubsectionOutline(Base):
+    """Structured representation of the subsections of an academic paper."""
+
+    title: str = Field(...)
+    """The title of the subsection."""
+
+    description: str = Field(...)
+    """A brief description of the subsection's content should be, how it fits into the overall structure of the paper, and its significance in the context of the research."""
+
+
+class ArticleSectionOutline(Base):
+    """Structured representation of the sections of an academic paper."""
+
+    title: str = Field(...)
+    """The title of the section."""
+    description: str = Field(...)
+    """A brief description of the section's content should be, how it fits into the overall structure of the paper, and its significance in the context of the research."""
+    subsections: List[ArticleSubsectionOutline] = Field(default_factory=list)
+    """The subsections of the section, outlining their content and significance."""
+
+
+class ArticleChapterOutline(Base):
+    """Structured representation of the chapters of an academic paper."""
+
+    title: str = Field(...)
+    """The title of the chapter."""
+    description: str = Field(...)
+    """A brief description of the chapter's content should be, how it fits into the overall structure of the paper, and its significance in the context of the research."""
+    sections: List[ArticleSectionOutline] = Field(default_factory=list)
+    """The sections of the chapter, outlining their content and significance."""
+
+
+class ArticleOutline(ProposedAble, Display, FinalizedDumpAble):
+    """Structured representation of the outline for an academic paper."""
+
+    title: str = Field(...)
+    """The proposed title of the paper."""
+
+    prospect: str = Field(...)
+    """A brief description of the research problem or question that the paper aims to address manipulating methods or techniques"""
+
+    chapters: List[ArticleChapterOutline] = Field(default_factory=list)
+    """The chapters of the paper, outlining their content and significance."""
+
+    def finalized_dump(self) -> str:
+        """Finalized dump of the article outline.
+
+        Returns:
+            str: The finalized dump of the article outline.
+        """
+        lines: List[str] = []
+
+        for chapter in self.chapters:
+            lines.append(f"= {chapter.title}")
+            for section in chapter.sections:
+                lines.append(f"== {section.title}")
+                for subsection in section.subsections:
+                    lines.append(f"=== {subsection.title}")
+
+        return "\n\n".join(lines)

fabricatio/models/generic.py

@@ -0,0 +1,406 @@
+"""This module defines generic classes for models in the Fabricatio library."""
+
+from abc import abstractmethod
+from pathlib import Path
+from typing import Any, Callable, Dict, Iterable, List, Optional, Self, Union, final, overload
+
+import orjson
+from fabricatio._rust import blake3_hash
+from fabricatio._rust_instances import TEMPLATE_MANAGER
+from fabricatio.config import configs
+from fabricatio.fs.readers import MAGIKA, safe_text_read
+from fabricatio.journal import logger
+from fabricatio.parser import JsonCapture
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    HttpUrl,
+    NonNegativeFloat,
+    PositiveFloat,
+    PositiveInt,
+    SecretStr,
+)
+
+
+class Base(BaseModel):
+    """Base class for all models with Pydantic configuration."""
+
+    model_config = ConfigDict(use_attribute_docstrings=True)
+
+
+class Display(Base):
+    """Class that provides a method to display the model in a formatted JSON string."""
+
+    def display(self) -> str:
+        """Display the model in a formatted JSON string.
+
+        Returns:
+            str: The formatted JSON string of the model.
+        """
+        return self.model_dump_json(indent=1)
+
+    def compact(self) -> str:
+        """Display the model in a compact JSON string.
+
+        Returns:
+            str: The compact JSON string of the model.
+        """
+        return self.model_dump_json()
+
+
+class Named(Base):
+    """Class that includes a name attribute."""
+
+    name: str = Field(frozen=True)
+    """The name of the object."""
+
+
+class Described(Base):
+    """Class that includes a description attribute."""
+
+    description: str = Field(default="", frozen=True)
+    """The description of the object."""
+
+
+class WithBriefing(Named, Described):
+    """Class that provides a briefing based on the name and description."""
+
+    @property
+    def briefing(self) -> str:
+        """Get the briefing of the object.
+
+        Returns:
+            str: The briefing of the object.
+        """
+        return f"{self.name}: {self.description}" if self.description else self.name
+
+    def prepend[D: Dict[str, Any]](self, kwargs: D) -> D:
+        """Prepend the briefing to the system message in the kwargs.
+
+        Args:
+            kwargs (Dict[str, Any]): The keyword arguments to modify.
+
+        Returns:
+            Dict[str, Any]: The modified keyword arguments.
+        """
+        kwargs["system_message"] = f"# your personal briefing: \n{self.briefing}\n" + kwargs.get("system_message", "")
+        return kwargs
+
+
+class WithFormatedJsonSchema(Base):
+    """Class that provides a formatted JSON schema of the model."""
+
+    @classmethod
+    def formated_json_schema(cls) -> str:
+        """Get the JSON schema of the model in a formatted string.
+
+        Returns:
+            str: The JSON schema of the model in a formatted string.
+        """
+        return orjson.dumps(
+            cls.model_json_schema(),
+            option=orjson.OPT_INDENT_2 | orjson.OPT_SORT_KEYS,
+        ).decode()
+
+
+class CreateJsonObjPrompt(WithFormatedJsonSchema):
+    """Class that provides a prompt for creating a JSON object."""
+
+    @classmethod
+    @overload
+    def create_json_prompt(cls, requirement: List[str]) -> List[str]: ...
+
+    @classmethod
+    @overload
+    def create_json_prompt(cls, requirement: str) -> str: ...
+
+    @classmethod
+    def create_json_prompt(cls, requirement: str | List[str]) -> str | List[str]:
+        """Create the prompt for creating a JSON object with given requirement.
+
+        Args:
+            requirement (str): The requirement for the JSON object.
+
+        Returns:
+            str: The prompt for creating a JSON object with given requirement.
+        """
+        if isinstance(requirement, str):
+            return TEMPLATE_MANAGER.render_template(
+                configs.templates.create_json_obj_template,
+                {"requirement": requirement, "json_schema": cls.formated_json_schema()},
+            )
+        return [
+            TEMPLATE_MANAGER.render_template(
+                configs.templates.create_json_obj_template,
+                {"requirement": r, "json_schema": cls.formated_json_schema()},
+            )
+            for r in requirement
+        ]
+
+
+class InstantiateFromString(Base):
+    """Class that provides a method to instantiate the class from a string."""
+
+    @classmethod
+    def instantiate_from_string(cls, string: str) -> Self | None:
+        """Instantiate the class from a string.
+
+        Args:
+            string (str): The string to instantiate the class from.
+
+        Returns:
+            Self | None: The instance of the class or None if the string is not valid.
+        """
+        return JsonCapture.convert_with(string, cls.model_validate_json)
+
+
+class ProposedAble(CreateJsonObjPrompt, InstantiateFromString):
+    """Class that provides a method to propose a JSON object based on the requirement."""
+
+    pass
+
+
+class FinalizedDumpAble(Base):
+    """Class that provides a method to finalize the dump of the object."""
+
+    @abstractmethod
+    def finalized_dump(self) -> str:
+        """Finalize the dump of the object.
+
+        Returns:
+            str: The finalized dump of the object.
+        """
+
+    def finalized_dump_to(self, path: str | Path) -> Self:
+        """Finalize the dump of the object to a file.
+
+        Args:
+            path (str | Path): The path to save the finalized dump.
+
+        Returns:
+            Self: The current instance of the object.
+        """
+        Path(path).write_text(self.finalized_dump(), encoding="utf-8")
+        return self
+
+
+class WithDependency(Base):
+    """Class that manages file dependencies."""
+
+    dependencies: List[str] = Field(default_factory=list)
+    """The file dependencies which is needed to read or write to meet a specific requirement, a list of file paths."""
+
+    def add_dependency[P: str | Path](self, dependency: P | List[P]) -> Self:
+        """Add a file dependency to the task.
+
+        Args:
+            dependency (str | Path | List[str | Path]): The file dependency to add to the task.
+
+        Returns:
+            Self: The current instance of the task.
+        """
+        if not isinstance(dependency, list):
+            dependency = [dependency]
+        self.dependencies.extend(Path(d).as_posix() for d in dependency)
+        return self
+
+    def remove_dependency[P: str | Path](self, dependency: P | List[P]) -> Self:
+        """Remove a file dependency from the task.
+
+        Args:
+            dependency (str | Path | List[str | Path]): The file dependency to remove from the task.
+
+        Returns:
+            Self: The current instance of the task.
+        """
+        if not isinstance(dependency, list):
+            dependency = [dependency]
+        for d in dependency:
+            self.dependencies.remove(Path(d).as_posix())
+        return self
+
+    def clear_dependencies(self) -> Self:
+        """Clear all file dependencies from the task.
+
+        Returns:
+            Self: The current instance of the task.
+        """
+        self.dependencies.clear()
+        return self
+
+    def override_dependencies[P: str | Path](self, dependencies: List[P] | P) -> Self:
+        """Override the file dependencies of the task.
+
+        Args:
+            dependencies (List[str | Path] | str | Path): The file dependencies to override the task's dependencies.
+
+        Returns:
+            Self: The current instance of the task.
+        """
+        return self.clear_dependencies().add_dependency(dependencies)
+
+    def pop_dependence[T](self, idx: int = -1, reader: Callable[[str], T] = safe_text_read) -> T:
+        """Pop the file dependencies from the task.
+
+        Returns:
+            str: The popped file dependency
+        """
+        return reader(self.dependencies.pop(idx))
+
+    @property
+    def dependencies_prompt(self) -> str:
+        """Generate a prompt for the task based on the file dependencies.
+
+        Returns:
+            str: The generated prompt for the task.
+        """
+        return TEMPLATE_MANAGER.render_template(
+            configs.templates.dependencies_template,
+            {
+                (pth := Path(p)).name: {
+                    "path": pth.as_posix(),
+                    "exists": pth.exists(),
+                    "description": (identity := MAGIKA.identify_path(pth)).output.description,
+                    "size": f"{pth.stat().st_size / (1024 * 1024) if pth.exists() and pth.is_file() else 0:.3f} MB",
+                    "content": (text := safe_text_read(pth)),
+                    "lines": len(text.splitlines()),
+                    "language": identity.output.ct_label,
+                    "checksum": blake3_hash(pth.read_bytes()) if pth.exists() and pth.is_file() else "unknown",
+                }
+                for p in self.dependencies
+            },
+        )
+
+
+class PrepareVectorization(Base):
+    """Class that prepares the vectorization of the model."""
+
+    @abstractmethod
+    def _prepare_vectorization_inner(self) -> str:
+        """Prepare the vectorization of the model."""
+
+    def prepare_vectorization(self, max_length: Optional[int] = None) -> str:
+        """Prepare the vectorization of the model.
+
+        Returns:
+            str: The prepared vectorization of the model.
+        """
+        max_length = max_length or configs.embedding.max_sequence_length
+        chunk = self._prepare_vectorization_inner()
+        if len(chunk) > max_length:
+            logger.error(err := f"Chunk exceeds maximum sequence length {max_length}.")
+            raise ValueError(err)
+
+        return chunk
+
+
+class ScopedConfig(Base):
+    """Class that manages a scoped configuration."""
+
+    llm_api_endpoint: Optional[HttpUrl] = None
+    """The OpenAI API endpoint."""
+
+    llm_api_key: Optional[SecretStr] = None
+    """The OpenAI API key."""
+
+    llm_timeout: Optional[PositiveInt] = None
+    """The timeout of the LLM model."""
+
+    llm_max_retries: Optional[PositiveInt] = None
+    """The maximum number of retries."""
+
+    llm_model: Optional[str] = None
+    """The LLM model name."""
+
+    llm_temperature: Optional[NonNegativeFloat] = None
+    """The temperature of the LLM model."""
+
+    llm_stop_sign: Optional[str | List[str]] = None
+    """The stop sign of the LLM model."""
+
+    llm_top_p: Optional[NonNegativeFloat] = None
+    """The top p of the LLM model."""
+
+    llm_generation_count: Optional[PositiveInt] = None
+    """The number of generations to generate."""
+
+    llm_stream: Optional[bool] = None
+    """Whether to stream the LLM model's response."""
+
+    llm_max_tokens: Optional[PositiveInt] = None
+    """The maximum number of tokens to generate."""
+
+    llm_tpm: Optional[PositiveInt] = None
+    """The tokens per minute of the LLM model."""
+
+    llm_rpm: Optional[PositiveInt] = None
+    """The requests per minute of the LLM model."""
+
+    embedding_api_endpoint: Optional[HttpUrl] = None
+    """The OpenAI API endpoint."""
+
+    embedding_api_key: Optional[SecretStr] = None
+    """The OpenAI API key."""
+
+    embedding_timeout: Optional[PositiveInt] = None
+    """The timeout of the LLM model."""
+
+    embedding_model: Optional[str] = None
+    """The LLM model name."""
+
+    embedding_max_sequence_length: Optional[PositiveInt] = None
+    """The maximum sequence length."""
+
+    embedding_dimensions: Optional[PositiveInt] = None
+    """The dimensions of the embedding."""
+    embedding_caching: Optional[bool] = False
+    """Whether to cache the embedding result."""
+
+    milvus_uri: Optional[HttpUrl] = Field(default=None)
+    """The URI of the Milvus server."""
+    milvus_token: Optional[SecretStr] = Field(default=None)
+    """The token for the Milvus server."""
+    milvus_timeout: Optional[PositiveFloat] = Field(default=None)
+    """The timeout for the Milvus server."""
+    milvus_dimensions: Optional[PositiveInt] = Field(default=None)
+    """The dimensions of the Milvus server."""
+
+    @final
+    def fallback_to(self, other: "ScopedConfig") -> Self:
+        """Fallback to another instance's attribute values if the current instance's attributes are None.
+
+        Args:
+            other (LLMUsage): Another instance from which to copy attribute values.
+
+        Returns:
+            Self: The current instance, allowing for method chaining.
+        """
+        # Iterate over the attribute names and copy values from 'other' to 'self' where applicable
+        # noinspection PydanticTypeChecker,PyTypeChecker
+        for attr_name in ScopedConfig.model_fields:
+            # Copy the attribute value from 'other' to 'self' only if 'self' has None and 'other' has a non-None value
+            if getattr(self, attr_name) is None and (attr := getattr(other, attr_name)) is not None:
+                setattr(self, attr_name, attr)
+
+        # Return the current instance to allow for method chaining
+        return self
+
+    @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.
+
+        Args:
+            others (LLMUsage | Iterable[LLMUsage]): Another instance or iterable of instances from which to copy attribute values.
+
+        Returns:
+            Self: The current instance, allowing for method chaining.
+        """
+        if not isinstance(others, Iterable):
+            others = [others]
+        for other in others:
+            # noinspection PyTypeChecker,PydanticTypeChecker
+            for attr_name in ScopedConfig.model_fields:
+                if (attr := getattr(self, attr_name)) is not None and getattr(other, attr_name) is None:
+                    setattr(other, attr_name, attr)
+        return self