fabricatio 0.2.3.dev3__cp312-cp312-win_amd64.whl → 0.2.4.dev1__cp312-cp312-win_amd64.whl

fabricatio/config.py

@@ -80,6 +80,33 @@ class LLMConfig(BaseModel):
     """The maximum number of tokens to generate. Set to 8192 as per request."""
 
 
+class EmbeddingConfig(BaseModel):
+    """Embedding configuration class."""
+
+    model_config = ConfigDict(use_attribute_docstrings=True)
+
+    model: str = Field(default="text-embedding-ada-002")
+    """The embedding model name. """
+
+    dimensions: Optional[PositiveInt] = Field(default=None)
+    """The dimensions of the embedding. None means not checked."""
+
+    timeout: Optional[PositiveInt] = Field(default=None)
+    """The timeout of the embedding model in seconds."""
+
+    max_sequence_length: PositiveInt = Field(default=8192)
+    """The maximum sequence length of the embedding model. Default is 8192 as per request."""
+
+    caching: bool = Field(default=False)
+    """Whether to cache the embedding. Default is False."""
+
+    api_endpoint: Optional[HttpUrl] = None
+    """The OpenAI API endpoint."""
+
+    api_key: Optional[SecretStr] = None
+    """The OpenAI API key."""
+
+
 class PymitterConfig(BaseModel):
     """Pymitter configuration class.
 
@@ -140,8 +167,8 @@ class TemplateConfig(BaseModel):
     template_suffix: str = Field(default="hbs", frozen=True)
     """The suffix of the templates."""
 
-    propose_task_template: str = Field(default="propose_task")
-    """The name of the propose task template which will be used to propose a task."""
+    create_json_obj_template: str = Field(default="create_json_obj")
+    """The name of the create json object template which will be used to create a json object."""
 
     draft_tool_usage_code_template: str = Field(default="draft_tool_usage_code")
     """The name of the draft tool usage code template which will be used to draft tool usage code."""
@@ -179,6 +206,9 @@ class TemplateConfig(BaseModel):
     retrieved_display_template: str = Field(default="retrieved_display")
     """The name of the retrieved display template which will be used to display retrieved documents."""
 
+    liststr_template: str = Field(default="liststr")
+    """The name of the liststr template which will be used to display a list of strings."""
+
 
 class MagikaConfig(BaseModel):
     """Magika configuration class."""
@@ -222,6 +252,8 @@ class RagConfig(BaseModel):
     """The timeout of the Milvus server."""
     milvus_token: Optional[SecretStr] = Field(default=None)
     """The token of the Milvus server."""
+    milvus_dimensions: Optional[PositiveInt] = Field(default=None)
+    """The dimensions of the Milvus server."""
 
 
 class Settings(BaseSettings):
@@ -249,6 +281,9 @@ class Settings(BaseSettings):
     llm: LLMConfig = Field(default_factory=LLMConfig)
     """LLM Configuration"""
 
+    embedding: EmbeddingConfig = Field(default_factory=EmbeddingConfig)
+    """Embedding Configuration"""
+
     debug: DebugConfig = Field(default_factory=DebugConfig)
     """Debug Configuration"""
 

fabricatio/models/action.py

@@ -46,6 +46,7 @@ class Action(HandleTask, ProposeTask, GiveRating):
             cxt[self.output_key] = ret
         return cxt
 
+    @property
     def briefing(self) -> str:
         """Return a brief description of the action."""
         if self.personality:
@@ -91,9 +92,8 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
         Returns:
             Self: The instance of the workflow with the injected personality.
         """
-        for a in self._instances:
-            if not a.personality:
-                a.personality = personality
+        for a in filter(lambda action: not action.personality, self._instances):
+            a.personality = personality
         return self
 
     async def serve(self, task: Task) -> None:

fabricatio/models/events.py

@@ -3,6 +3,7 @@
 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"]
@@ -33,6 +34,21 @@ class Event(BaseModel):
 
         return cls(segments=event)
 
+    @classmethod
+    def quick_instantiate(cls, event: EventLike) -> Self:
+        """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)
@@ -59,6 +75,26 @@ class Event(BaseModel):
         """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()

fabricatio/models/extra.py

@@ -0,0 +1,96 @@
+"""Extra models for built-in actions."""
+
+from typing import List
+
+from fabricatio.models.generic import Display, PrepareVectorization, ProposedAble
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class Equation(BaseModel):
+    """Structured representation of mathematical equations (including their physical or conceptual meanings)."""
+
+    model_config = ConfigDict(use_attribute_docstrings=True)
+
+    description: str = Field(...)
+    """A concise explanation of the equation's meaning, purpose, and relevance in the context of the research."""
+
+    latex_code: str = Field(...)
+    """The LaTeX code used to represent the equation in a publication-ready format."""
+
+
+class Figure(BaseModel):
+    """Structured representation of figures (including their academic significance and explanatory captions)."""
+
+    model_config = ConfigDict(use_attribute_docstrings=True)
+
+    description: str = Field(...)
+    """A detailed explanation of the figure's content and its role in conveying key insights."""
+
+    figure_caption: str = Field(...)
+    """The caption accompanying the figure, summarizing its main points and academic value."""
+
+    figure_path: str = Field(...)
+    """The file path to the figure"""
+
+
+class Highlightings(BaseModel):
+    """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."""
+
+    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] = Field(default_factory=list)
+    """A list of the paper's authors, typically in the order of contribution."""
+
+    keywords: List[str] = Field(default_factory=list)
+    """A list of keywords that summarize the paper's focus and facilitate indexing."""
+
+    publication_year: int = Field(None)
+    """The year in which the paper was published."""
+
+    # Core Content Elements
+    domain: List[str] = Field(default_factory=list)
+    """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] = Field(default_factory=list)
+    """Key academic contributions that distinguish the paper from prior work in the field."""
+
+    technical_novelty: List[str] = Field(default_factory=list)
+    """Specific technical innovations introduced by the research, listed as individual points."""
+
+    # Academic Discussion Dimensions
+    research_problem: str = Field("")
+    """A clearly defined research question or problem addressed by the study."""
+
+    limitations: List[str] = Field(default_factory=list)
+    """An analysis of the methodological or experimental limitations of the research."""
+
+    future_work: List[str] = Field(default_factory=list)
+    """Suggestions for potential directions or topics for follow-up studies."""
+
+    impact_analysis: str = Field("")
+    """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()

fabricatio/models/generic.py

@@ -1,17 +1,25 @@
 """This module defines generic classes for models in the Fabricatio library."""
 
+from abc import abstractmethod
 from pathlib import Path
-from typing import Callable, List, Self
+from typing import Callable, Iterable, List, Optional, Self, Union, final
 
 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,
 )
 
 
@@ -21,6 +29,18 @@ class Base(BaseModel):
     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)
+
+
 class Named(Base):
     """Class that includes a name attribute."""
 
@@ -48,22 +68,63 @@ class WithBriefing(Named, Described):
         return f"{self.name}: {self.description}" if self.description else self.name
 
 
-class WithJsonExample(Base):
-    """Class that provides a JSON schema for the model."""
+class WithFormatedJsonSchema(Base):
+    """Class that provides a formatted JSON schema of the model."""
 
     @classmethod
-    def json_example(cls) -> str:
-        """Return a JSON example for the model.
+    def formated_json_schema(cls) -> str:
+        """Get the JSON schema of the model in a formatted string.
 
         Returns:
-            str: A JSON example for the model.
+            str: The JSON schema of the model in a formatted string.
         """
         return orjson.dumps(
-            {field_name: field_info.description for field_name, field_info in cls.model_fields.items()},
+            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
+    def create_json_prompt(cls, requirement: str) -> 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.
+        """
+        return template_manager.render_template(
+            configs.templates.create_json_obj_template,
+            {"requirement": requirement, "json_schema": cls.formated_json_schema()},
+        )
+
+
+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 methods for proposing a task."""
+
+    pass
+
+
 class WithDependency(Base):
     """Class that manages file dependencies."""
 
@@ -150,3 +211,129 @@ class WithDependency(Base):
                 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."""
+
+    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)

fabricatio/models/kwargs_types.py

@@ -5,6 +5,20 @@ from typing import List, NotRequired, TypedDict
 from pydantic import NonNegativeFloat, NonNegativeInt, PositiveInt
 
 
+class CollectionSimpleConfigKwargs(TypedDict):
+    """A type representing the configuration for a collection."""
+
+    dimension: NotRequired[int]
+    timeout: NotRequired[float]
+
+
+class FetchKwargs(TypedDict):
+    """A type representing the keyword arguments for the fetch method."""
+
+    similarity_threshold: NotRequired[float]
+    result_per_query: NotRequired[int]
+
+
 class EmbeddingKwargs(TypedDict):
     """A type representing the keyword arguments for the embedding method."""
 

fabricatio/models/task.py

@@ -4,7 +4,6 @@ It includes methods to manage the task's lifecycle, such as starting, finishing,
 """
 
 from asyncio import Queue
-from enum import Enum
 from typing import Any, List, Optional, Self
 
 from fabricatio._rust_instances import template_manager
@@ -12,35 +11,18 @@ from fabricatio.config import configs
 from fabricatio.core import env
 from fabricatio.journal import logger
 from fabricatio.models.events import Event, EventLike
-from fabricatio.models.generic import WithBriefing, WithDependency, WithJsonExample
+from fabricatio.models.generic import ProposedAble, WithBriefing, WithDependency
+from fabricatio.models.utils import TaskStatus
 from pydantic import Field, PrivateAttr
 
 
-class TaskStatus(Enum):
-    """An enumeration representing the status of a task.
-
-    Attributes:
-        Pending: The task is pending.
-        Running: The task is currently running.
-        Finished: The task has been successfully completed.
-        Failed: The task has failed.
-        Cancelled: The task has been cancelled.
-    """
-
-    Pending = "pending"
-    Running = "running"
-    Finished = "finished"
-    Failed = "failed"
-    Cancelled = "cancelled"
-
-
-class Task[T](WithBriefing, WithJsonExample, WithDependency):
+class Task[T](WithBriefing, ProposedAble, WithDependency):
     """A class representing a task with a status and output.
 
     Attributes:
         name (str): The name of the task.
         description (str): The description of the task.
-        goal (str): The goal of the task.
+        goals (str): The goal of the task.
         dependencies (List[str]): The file dependencies of the task, a list of file paths.
         namespace (List[str]): The namespace of the task, a list of namespace segment, as string.
     """
@@ -58,7 +40,7 @@ class Task[T](WithBriefing, WithJsonExample, WithDependency):
     """A list of string segments that identify the task's location in the system. If not specified, defaults to an empty list."""
 
     dependencies: List[str] = Field(default_factory=list)
-    """A list of file paths that are needed (either reading or writing) to complete this task. If not specified, defaults to an empty list."""
+    """A list of file paths that are needed or mentioned in the task's description (either reading or writing) to complete this task. If not specified, defaults to an empty list."""
 
     _output: Queue[T | None] = PrivateAttr(default_factory=Queue)
     """The output queue of the task."""