fabricatio 0.2.9.dev3__cp312-cp312-win_amd64.whl → 0.2.10.dev0__cp312-cp312-win_amd64.whl

fabricatio/models/extra/problem.py

@@ -1,11 +1,12 @@
 """A class representing a problem-solution pair identified during a review process."""
 
 from itertools import chain
-from typing import Any, List, Literal, Optional, Self, Tuple, Unpack
+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 questionary import Choice, checkbox, text
 from rich import print as r_print
 
@@ -13,36 +14,30 @@ from rich import print as r_print
 class Problem(SketchedAble, WithBriefing):
     """Represents a problem identified during review."""
 
-    description: str
-    """Description of the problem, The """
+    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: Literal["low", "medium", "high"]
-    """Severity level of the problem."""
-
-    category: str
-    """Category of the problem."""
+    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."""
 
-    recommendation: str
-    """Recommended solution or action."""
-
 
 class Solution(SketchedAble, WithBriefing):
     """Represents a proposed solution to a problem."""
 
-    description: str
+    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."""
+    """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: Literal["low", "medium", "high"]
-    """Feasibility level of the solution."""
+    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: Literal["low", "medium", "high"]
-    """Impact level of the solution."""
+    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):

fabricatio/models/extra/rag.py

@@ -0,0 +1,72 @@
+"""A module containing the RAG (Retrieval-Augmented Generation) models."""
+
+from abc import ABCMeta, abstractmethod
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Self, Sequence
+
+from fabricatio.decorators import precheck_package
+from pydantic import BaseModel, ConfigDict, 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(BaseModel, metaclass=ABCMeta):
+    """A base class for Milvus data."""
+
+    model_config = ConfigDict(use_attribute_docstrings=True)
+
+    primary_field_name: ClassVar[str] = "id"
+
+    vector_field_name: ClassVar[str] = "vector"
+
+    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}
+
+    @property
+    @abstractmethod
+    def to_vectorize(self) -> str:
+        """The text representation of the data."""
+
+    @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),
+        ]
+
+        type_mapping = {
+            str: DataType.STRING,
+            int: DataType.INT64,
+            float: DataType.DOUBLE,
+            JsonValue: DataType.JSON,
+            # TODO add more mapping
+        }
+
+        for k, v in cls.model_fields.items():
+            k: str
+            v: FieldInfo
+            fields.append(
+                FieldSchema(k, dtype=type_mapping.get(v.annotation, DataType.UNKNOWN), description=v.description or "")
+            )
+        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]

fabricatio/models/extra/rule.py

@@ -40,12 +40,11 @@ class RuleSet(SketchedAble, PersistentAble, WithBriefing, Language):
     framework for the topic or domain covered by the rule set."""
 
     @classmethod
-    def gather(cls, *rulesets: Unpack[Tuple["RuleSet",...]]) -> Self:
+    def gather(cls, *rulesets: Unpack[Tuple["RuleSet", ...]]) -> Self:
         """Gathers multiple rule sets into a single rule set."""
         if not rulesets:
             raise ValueError("No rulesets provided")
         return cls(
-            language=rulesets[0].language,
             name=";".join(ruleset.name for ruleset in rulesets),
             description=";".join(ruleset.description for ruleset in rulesets),
             rules=list(flatten(r.rules for r in rulesets)),

fabricatio/models/generic.py

@@ -11,7 +11,7 @@ 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 fabricatio.rust import blake3_hash
+from fabricatio.rust import blake3_hash, detect_language
 from fabricatio.rust_instances import TEMPLATE_MANAGER
 from fabricatio.utils import ok
 from litellm.utils import token_counter
@@ -36,6 +36,7 @@ class Base(BaseModel):
     The `model_config` uses `use_attribute_docstrings=True` to ensure field descriptions are
     pulled from the attribute's docstring instead of the default Pydantic behavior.
     """
+
     model_config = ConfigDict(use_attribute_docstrings=True)
 
 
@@ -45,13 +46,14 @@ class Display(Base):
     Provides methods to generate both pretty-printed and compact JSON representations of the model.
     Used for debugging and logging purposes.
     """
+
     def display(self) -> str:
         """Generate pretty-printed JSON representation.
 
         Returns:
             str: JSON string with 1-level indentation for readability
         """
-        return self.model_dump_json(indent=1)
+        return self.model_dump_json(indent=1,by_alias=True)
 
     def compact(self) -> str:
         """Generate compact JSON representation.
@@ -59,7 +61,7 @@ class Display(Base):
         Returns:
             str: Minified JSON string without whitespace
         """
-        return self.model_dump_json()
+        return self.model_dump_json(by_alias=True)
 
     @staticmethod
     def seq_display(seq: Iterable["Display"], compact: bool = False) -> str:
@@ -102,6 +104,20 @@ class Described(Base):
     this object's intent and application."""
 
 
+class Titled(Base):
+    """Class that includes a title attribute."""
+
+    title: str
+    """The title of this object, make it professional and concise.No prefixed heading number should be included."""
+
+
+class WordCount(Base):
+    """Class that includes a word count attribute."""
+
+    expected_word_count: int
+    """Expected word count of this research component."""
+
+
 class AsPrompt(Base):
     """Class that provides a method to generate a prompt from the model.
 
@@ -194,6 +210,7 @@ class PersistentAble(Base):
     Enables saving model instances to disk with timestamped filenames and loading from persisted files.
     Implements basic versioning through filename hashing and timestamping.
     """
+
     def persist(self, path: str | Path) -> Self:
         """Save model instance to disk with versioned filename.
 
@@ -208,7 +225,7 @@ class PersistentAble(Base):
             - Hash generated from JSON content ensures uniqueness
         """
         p = Path(path)
-        out = self.model_dump_json()
+        out = self.model_dump_json(indent=1,by_alias=True)
 
         # Generate a timestamp in the format YYYYMMDD_HHMMSS
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
@@ -281,11 +298,17 @@ class PersistentAble(Base):
 class Language(Base):
     """Class that provides a language attribute."""
 
-    language: str
-    """The written language of this object, which should be aligned to the original requirement
-    For example if the requirement is in Chinese, the language should be set to `zh`, if the requirement is in English, the language should be set to `en` and etc."""
-
-
+    @property
+    def language(self)->str:
+        """Get the language of the object."""
+        if isinstance(self,Described):
+            return detect_language(self.description)
+        if isinstance(self,Titled):
+            return detect_language(self.title)
+        if isinstance(self,Named):
+            return detect_language(self.name)
+
+        return detect_language(self.model_dump_json(by_alias=True))
 class ModelHash(Base):
     """Class that provides a hash value for the object.
 
@@ -527,7 +550,7 @@ class FinalizedDumpAble(Base):
         Returns:
             str: The finalized dump of the object.
         """
-        return self.model_dump_json()
+        return self.model_dump_json(indent=1,by_alias=True)
 
     def finalized_dump_to(self, path: str | Path) -> Self:
         """Finalize the dump of the object to a file.
@@ -670,6 +693,7 @@ class ScopedConfig(Base):
     Manages LLM, embedding, and vector database configurations with fallback logic.
     Allows configuration values to be overridden in a hierarchical manner.
     """
+
     llm_api_endpoint: Optional[HttpUrl] = None
     """The OpenAI API endpoint."""
 

fabricatio/models/kwargs_types.py

@@ -1,48 +1,10 @@
 """This module contains the types for the keyword arguments of the methods in the models module."""
 
-from importlib.util import find_spec
 from typing import Any, Dict, List, Optional, Required, TypedDict
 
 from litellm.caching.caching import CacheMode
 from litellm.types.caching import CachingSupportedCallTypes
 
-if find_spec("pymilvus"):
-    from pymilvus import CollectionSchema
-    from pymilvus.milvus_client import IndexParams
-
-    class CollectionConfigKwargs(TypedDict, total=False):
-        """Configuration parameters for a vector collection.
-
-        These arguments are typically used when configuring connections to vector databases.
-        """
-
-        dimension: int | None
-        primary_field_name: str
-        id_type: str
-        vector_field_name: str
-        metric_type: str
-        timeout: float | None
-        schema: CollectionSchema | None
-        index_params: IndexParams | None
-
-
-class FetchKwargs(TypedDict, total=False):
-    """Arguments for fetching data from vector collections.
-
-    Controls how data is retrieved from vector databases, including filtering
-    and result limiting parameters.
-    """
-
-    collection_name: str | None
-    similarity_threshold: float
-    result_per_query: int
-
-
-class RetrievalKwargs(FetchKwargs, total=False):
-    """Arguments for retrieval operations."""
-
-    final_limit: int
-
 
 class EmbeddingKwargs(TypedDict, total=False):
     """Configuration parameters for text embedding operations.
@@ -139,6 +101,7 @@ class ReviewKwargs[T](ReviewInnerKwargs[T], total=False):
 
 class ReferencedKwargs[T](ValidateKwargs[T], total=False):
     """Arguments for content review operations."""
+
     reference: str
 
 

fabricatio/models/task.py

@@ -7,11 +7,11 @@ from asyncio import Queue
 from typing import Any, List, Optional, Self
 
 from fabricatio.config import configs
+from fabricatio.constants import TaskStatus
 from fabricatio.core import env
 from fabricatio.journal import logger
 from fabricatio.models.events import Event, EventLike
 from fabricatio.models.generic import ProposedAble, WithBriefing, WithDependency
-from fabricatio.models.utils import TaskStatus
 from fabricatio.rust_instances import TEMPLATE_MANAGER
 from pydantic import Field, PrivateAttr
 
@@ -112,12 +112,12 @@ class Task[T](WithBriefing, ProposedAble, WithDependency):
         """Return a formatted status label for the task.
 
         Args:
-            status (TaskStatus): The status of the task.
+            status (fabricatio.constants.TaskStatus): The status of the task.
 
         Returns:
             str: The formatted status label.
         """
-        return self._namespace.derive(self.name).push(status.value).collapse()
+        return self._namespace.derive(self.name).push(status).collapse()
 
     @property
     def pending_label(self) -> str:

fabricatio/models/usages.py

@@ -2,7 +2,7 @@
 
 import traceback
 from asyncio import gather
-from typing import Callable, Dict, Iterable, List, Optional, Self, Sequence, Set, Union, Unpack, overload
+from typing import Callable, Dict, Iterable, List, Literal, Optional, Self, Sequence, Set, Union, Unpack, overload
 
 import asyncstdlib
 import litellm
@@ -13,7 +13,6 @@ from fabricatio.models.generic import ScopedConfig, WithBriefing
 from fabricatio.models.kwargs_types import ChooseKwargs, EmbeddingKwargs, GenerateKwargs, LLMKwargs, ValidateKwargs
 from fabricatio.models.task import Task
 from fabricatio.models.tool import Tool, ToolBox
-from fabricatio.models.utils import Messages
 from fabricatio.parser import GenericCapture, JsonCapture
 from fabricatio.rust_instances import TEMPLATE_MANAGER
 from fabricatio.utils import ok
@@ -28,7 +27,7 @@ from litellm.types.utils import (
 )
 from litellm.utils import CustomStreamWrapper, token_counter  # pyright: ignore [reportPrivateImportUsage]
 from more_itertools import duplicates_everseen
-from pydantic import Field, NonNegativeInt, PositiveInt
+from pydantic import BaseModel, ConfigDict, Field, NonNegativeInt, PositiveInt
 
 if configs.cache.enabled and configs.cache.type:
     litellm.enable_cache(type=configs.cache.type, **configs.cache.params)
@@ -299,10 +298,11 @@ class LLMUsage(ScopedConfig):
             for lap in range(max_validations):
                 try:
                     if ((validated := validator(response := await self.aask(question=q, **kwargs))) is not None) or (
-                        co_extractor
+                        co_extractor is not None
+                        and logger.debug("Co-extraction is enabled.") is None
                         and (
                             validated := validator(
-                                await self.aask(
+                                response := await self.aask(
                                     question=(
                                         TEMPLATE_MANAGER.render_template(
                                             configs.templates.co_validation_template,
@@ -319,12 +319,13 @@ class LLMUsage(ScopedConfig):
                         return validated
 
                 except RateLimitError as e:
-                    logger.warning(f"Rate limit error: {e}")
+                    logger.warning(f"Rate limit error:\n{e}")
                     continue
                 except Exception as e:  # noqa: BLE001
-                    logger.error(f"Error during validation: \n{e}")
+                    logger.error(f"Error during validation:\n{e}")
                     logger.debug(traceback.format_exc())
                     break
+                logger.error(f"Failed to validate the response at {lap}th attempt:\n{response}")
                 if not kwargs.get("no_cache"):
                     kwargs["no_cache"] = True
                     logger.debug("Closed the cache for the next attempt")
@@ -493,7 +494,7 @@ class LLMUsage(ScopedConfig):
         affirm_case: str = "",
         deny_case: str = "",
         **kwargs: Unpack[ValidateKwargs[bool]],
-    ) -> bool:
+    ) -> Optional[bool]:
         """Asynchronously judges a prompt using AI validation.
 
         Args:
@@ -730,3 +731,72 @@ class ToolBoxUsage(LLMUsage):
         for other in (x for x in others if isinstance(x, ToolBoxUsage)):
             other.toolboxes.update(self.toolboxes)
         return self
+
+
+class Message(BaseModel):
+    """A class representing a message."""
+
+    model_config = ConfigDict(use_attribute_docstrings=True)
+    role: Literal["user", "system", "assistant"]
+    """The role of the message sender."""
+    content: str
+    """The content of the message."""
+
+
+class Messages(list):
+    """A list of messages."""
+
+    def add_message(self, role: Literal["user", "system", "assistant"], content: str) -> Self:
+        """Adds a message to the list with the specified role and content.
+
+        Args:
+            role (Literal["user", "system", "assistant"]): The role of the message sender.
+            content (str): The content of the message.
+
+        Returns:
+            Self: The current instance of Messages to allow method chaining.
+        """
+        if content:
+            self.append(Message(role=role, content=content))
+        return self
+
+    def add_user_message(self, content: str) -> Self:
+        """Adds a user message to the list with the specified content.
+
+        Args:
+            content (str): The content of the user message.
+
+        Returns:
+            Self: The current instance of Messages to allow method chaining.
+        """
+        return self.add_message("user", content)
+
+    def add_system_message(self, content: str) -> Self:
+        """Adds a system message to the list with the specified content.
+
+        Args:
+            content (str): The content of the system message.
+
+        Returns:
+            Self: The current instance of Messages to allow method chaining.
+        """
+        return self.add_message("system", content)
+
+    def add_assistant_message(self, content: str) -> Self:
+        """Adds an assistant message to the list with the specified content.
+
+        Args:
+            content (str): The content of the assistant message.
+
+        Returns:
+            Self: The current instance of Messages to allow method chaining.
+        """
+        return self.add_message("assistant", content)
+
+    def as_list(self) -> List[Dict[str, str]]:
+        """Converts the messages to a list of dictionaries.
+
+        Returns:
+            list[dict]: A list of dictionaries representing the messages.
+        """
+        return [message.model_dump() for message in self]

fabricatio/parser.py

@@ -48,10 +48,10 @@ class Capture(BaseModel):
             case "json" if configs.general.use_json_repair:
                 logger.debug("Applying json repair to text.")
                 if isinstance(text, str):
-                    return repair_json(text, ensure_ascii=False)
-                return [repair_json(item, ensure_ascii=False) for item in text]
+                    return repair_json(text, ensure_ascii=False)  # pyright: ignore [reportReturnType]
+                return [repair_json(item, ensure_ascii=False) for item in text]  # pyright: ignore [reportReturnType, reportGeneralTypeIssues]
             case _:
-                return text
+                return text  # pyright: ignore [reportReturnType]
 
     def capture(self, text: str) -> Tuple[str, ...] | str | None:
         """Capture the first occurrence of the pattern in the given text.
@@ -88,7 +88,7 @@ class Capture(BaseModel):
         if (cap := self.capture(text)) is None:
             return None
         try:
-            return convertor(cap)
+            return convertor(cap)  # pyright: ignore [reportArgumentType]
         except (ValueError, SyntaxError, ValidationError) as e:
             logger.error(f"Failed to convert text using {convertor.__name__} to convert.\nerror: {e}\n {cap}")
             return None
@@ -120,7 +120,7 @@ class Capture(BaseModel):
             judges.append(lambda output_obj: len(output_obj) == length)
 
         if (out := self.convert_with(text, deserializer)) and all(j(out) for j in judges):
-            return out
+            return out  # pyright: ignore [reportReturnType]
         return None
 
     @classmethod

fabricatio/rust.pyi

@@ -1,5 +1,4 @@
-"""
-Python interface definitions for Rust-based functionality.
+"""Python interface definitions for Rust-based functionality.
 
 This module provides type stubs and documentation for Rust-implemented utilities,
 including template rendering, cryptographic hashing, language detection, and
@@ -12,12 +11,8 @@ Key Features:
 - Text utilities: Word boundary splitting and word counting.
 """
 
-
 from pathlib import Path
-from typing import List, Optional
-
-from pydantic import JsonValue
-
+from typing import Any, Dict, List, Optional
 
 class TemplateManager:
     """Template rendering engine using Handlebars templates.
@@ -59,7 +54,7 @@ class TemplateManager:
         This refreshes the template cache, finding any new or modified templates.
         """
 
-    def render_template(self, name: str, data: JsonValue) -> str:
+    def render_template(self, name: str, data: Dict[str, Any]) -> str:
         """Render a template with context data.
 
         Args:
@@ -73,7 +68,7 @@ class TemplateManager:
             RuntimeError: If template rendering fails
         """
 
-    def render_template_raw(self, template: str, data: JsonValue) -> str:
+    def render_template_raw(self, template: str, data: Dict[str, Any]) -> str:
         """Render a template with context data.
 
         Args:
@@ -97,7 +92,6 @@ def blake3_hash(content: bytes) -> str:
 def detect_language(string: str) -> str:
     """Detect the language of a given string."""
 
-
 def split_word_bounds(string: str) -> List[str]:
     """Split the string into words based on word boundaries.
 
@@ -107,6 +101,29 @@ def split_word_bounds(string: str) -> List[str]:
     Returns:
         A list of words extracted from the string.
     """
+
+def split_sentence_bounds(string: str) -> List[str]:
+    """Split the string into sentences based on sentence boundaries.
+
+    Args:
+        string: The input string to be split.
+
+    Returns:
+        A list of sentences extracted from the string.
+    """
+
+def split_into_chunks(string: str, max_chunk_size: int, max_overlapping_rate: float = 0.3) -> List[str]:
+    """Split the string into chunks of a specified size.
+
+    Args:
+        string: The input string to be split.
+        max_chunk_size: The maximum size of each chunk.
+        max_overlapping_rate: The minimum overlapping rate between chunks.
+
+    Returns:
+        A list of chunks extracted from the string.
+    """
+
 def word_count(string: str) -> int:
     """Count the number of words in the string.
 
@@ -117,8 +134,6 @@ def word_count(string: str) -> int:
         The number of words in the string.
     """
 
-
-
 class BibManager:
     """BibTeX bibliography manager for parsing and querying citation data."""
 

{fabricatio-0.2.9.dev3.dist-info → fabricatio-0.2.10.dev0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.9.dev3
+Version: 0.2.10.dev0
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12