fabricatio 0.2.3.dev2__cp312-cp312-win_amd64.whl → 0.2.4.dev0__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."""
@@ -176,6 +203,12 @@ class TemplateConfig(BaseModel):
     draft_rating_weights_klee_template: str = Field(default="draft_rating_weights_klee")
     """The name of the draft rating weights klee template which will be used to draft rating weights with Klee method."""
 
+    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."""
@@ -219,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):
@@ -246,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:

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/generic.py

@@ -1,17 +1,23 @@
 """This module defines generic classes for models in the Fabricatio library."""
 
 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.parser import JsonCapture
 from pydantic import (
     BaseModel,
     ConfigDict,
     Field,
+    HttpUrl,
+    NonNegativeFloat,
+    PositiveFloat,
+    PositiveInt,
+    SecretStr,
 )
 
 
@@ -48,22 +54,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 +197,107 @@ class WithDependency(Base):
                 for p in self.dependencies
             },
         )
+
+
+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,53 +11,36 @@ 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.
     """
 
     name: str = Field(...)
-    """The name of the task, which should be a concise and descriptive name."""
+    """The name of the task, which should be concise and descriptive."""
 
     description: str = Field(default="")
-    """The description of the task, which should provide every details and noting about the task if provided, obeying the CEFR level rule and 5W1H rule."""
+    """A detailed explanation of the task that includes all necessary information. Should be clear and answer what, why, when, where, who, and how questions."""
 
-    goal: List[str] = Field(default=[])
-    """The goal of the task, a list of strings. The goal should be a concise and clear statement of what the task is intended to achieve, goal SHALL NOT be too broad or too narrow."""
+    goals: List[str] = Field(default=[])
+    """A list of objectives that the task aims to accomplish. Each goal should be clear and specific. Complex tasks should be broken into multiple smaller goals."""
 
     namespace: List[str] = Field(default_factory=list)
-    """The namespace of the task, a list of namespace segment, as string, if it is not directly given out, it SHALL just be a empty list meaning `NOT ASSIGNED`"""
+    """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, These file are needed to read or write to meet a specific requirement of this task, if it is not directly given out, it SHALL just be a empty list meaning `NOT ASSIGNED`"""
+    """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."""
@@ -113,7 +95,7 @@ class Task[T](WithBriefing, WithJsonExample, WithDependency):
         Returns:
             Task: A new instance of the `Task` class.
         """
-        return cls(name=name, goal=goal, description=description)
+        return cls(name=name, goals=goal, description=description)
 
     def update_task(self, goal: Optional[List[str] | str] = None, description: Optional[str] = None) -> Self:
         """Update the goal and description of the task.
@@ -126,7 +108,7 @@ class Task[T](WithBriefing, WithJsonExample, WithDependency):
             Task: The updated instance of the `Task` class.
         """
         if goal:
-            self.goal = goal if isinstance(goal, list) else [goal]
+            self.goals = goal if isinstance(goal, list) else [goal]
         if description:
             self.description = description
         return self