fabricatio 0.2.5.dev1__cp312-cp312-manylinux_2_34_x86_64.whl → 0.2.5.dev2__cp312-cp312-manylinux_2_34_x86_64.whl

fabricatio/_rust.pyi

@@ -2,60 +2,101 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional
 
 class TemplateManager:
-    """TemplateManager class for managing handlebars templates."""
+    """Template rendering engine using Handlebars templates.
+
+    This manager handles template discovery, loading, and rendering
+    through a wrapper around the handlebars-rust engine.
+
+    See: https://crates.io/crates/handlebars
+    """
     def __init__(
         self, template_dirs: List[Path], suffix: Optional[str] = None, active_loading: Optional[bool] = None
     ) -> None:
         """Initialize the template manager.
 
         Args:
-            template_dirs (List[Path]): A list of paths to directories containing templates.
-            suffix (str, optional): The suffix of template files. None means 'hbs' suffix.
-            active_loading (bool, optional): Whether to enable active loading of templates.
+            template_dirs: List of directories containing template files
+            suffix: File extension for templates (defaults to 'hbs')
+            active_loading: Whether to enable dev mode for reloading templates on change
         """
 
     @property
     def template_count(self) -> int:
-        """Get the number of templates discovered."""
+        """Returns the number of currently loaded templates."""
 
     def get_template_source(self, name: str) -> Optional[str]:
-        """Get the source path of a template by name.
+        """Get the filesystem path for a template.
 
         Args:
-            name (str): The name of the template to retrieve.
+            name: Template name (without extension)
 
         Returns:
-            Optional[str]: The source path of the template.
+            Path to the template file if found, None otherwise
         """
 
     def discover_templates(self) -> None:
-        """Discover templates in the specified directories."""
+        """Scan template directories and load available templates.
+
+        This refreshes the template cache, finding any new or modified templates.
+        """
 
     def render_template(self, name: str, data: Dict[str, Any]) -> str:
-        """Render a template with the given name and data.
+        """Render a template with context data.
 
         Args:
-            name (str): The name of the template to render.
-            data (Dict[str, Any]): The data to pass to the template.
+            name: Template name (without extension)
+            data: Context dictionary to provide variables to the template
 
         Returns:
-            str: The rendered template.
+            Rendered template content as string
+
+        Raises:
+            RuntimeError: If template rendering fails
         """
 
 def blake3_hash(content: bytes) -> str:
-    """Calculate the BLAKE3 hash of the given data.
+    """Calculate the BLAKE3 cryptographic hash of data.
 
     Args:
-        content (bytes): The data to hash.
+        content: Bytes to be hashed
 
     Returns:
-        str: The BLAKE3 hash of the data.
+        Hex-encoded BLAKE3 hash string
     """
 
 class BibManager:
-    """BibManager class for managing BibTeX files."""
+    """BibTeX bibliography manager for parsing and querying citation data."""
+
     def __init__(self, path: str) -> None:
-        """Initialize the BibManager with the given path."""
+        """Initialize the bibliography manager.
+
+        Args:
+            path: Path to BibTeX (.bib) file to load
+
+        Raises:
+            RuntimeError: If file cannot be read or parsed
+        """
+
+    def get_cite_key(self, title: str) -> Optional[str]:
+        """Find citation key by exact title match.
+
+        Args:
+            title: Full title to search for (case-insensitive)
+
+        Returns:
+            Citation key if exact match found, None otherwise
+        """
+
+    def get_cite_key_fuzzy(self, query: str) -> Optional[str]:
+        """Find best matching citation using fuzzy text search.
+
+        Args:
+            query: Search term to find in bibliography entries
+
+        Returns:
+            Citation key of best matching entry, or None if no good match
 
-    def get_cite_key(self, title: str) -> str:
-        """Get the cite key for the given title."""
+        Notes:
+            Uses nucleo_matcher for high-quality fuzzy text searching
+            See: https://crates.io/crates/nucleo-matcher
+        """

fabricatio/_rust_instances.py

@@ -1,4 +1,7 @@
+"""Some necessary instances."""
+
 from fabricatio._rust import TemplateManager
+
 from fabricatio.config import configs
 
 template_manager = TemplateManager(

fabricatio/capabilities/rating.py

@@ -4,7 +4,6 @@ from asyncio import gather
 from itertools import permutations
 from typing import Dict, List, Set, Tuple, Union, Unpack, overload
 
-from cache import AsyncLRU
 from fabricatio._rust_instances import template_manager
 from fabricatio.config import configs
 from fabricatio.journal import logger
@@ -113,7 +112,6 @@ class GiveRating(WithBriefing, LLMUsage):
             return await gather(*[self.rate_fine_grind(item, manual, score_range, **kwargs) for item in to_rate])
         raise ValueError("to_rate must be a string or a list of strings")
 
-    @AsyncLRU(maxsize=32)
     async def draft_rating_manual(
         self, topic: str, criteria: Set[str], **kwargs: Unpack[ValidateKwargs]
     ) -> Dict[str, str]:

fabricatio/capabilities/review.py

@@ -1,60 +1,135 @@
 """A module that provides functionality to rate tasks based on a rating manual and score range."""
 
-from typing import List, Optional, Set, Unpack
+from typing import List, Optional, Self, Set, Unpack
 
 from fabricatio import template_manager
 from fabricatio.capabilities.propose import Propose
 from fabricatio.capabilities.rating import GiveRating
 from fabricatio.config import configs
-from fabricatio.models.generic import Display, ProposedAble, WithBriefing
+from fabricatio.models.generic import Base, Display, ProposedAble, WithBriefing
 from fabricatio.models.kwargs_types import GenerateKwargs, ReviewKwargs
 from fabricatio.models.task import Task
 from pydantic import PrivateAttr
+from questionary import Choice, checkbox
+
+
+class ProblemSolutions(Base):
+    """Represents a problem-solution pair identified during a review process.
+
+    This class encapsulates a single problem with its corresponding potential solutions,
+    providing a structured way to manage review findings.
+
+    Attributes:
+        problem (str): The problem statement identified during review.
+        solutions (List[str]): A collection of potential solutions to address the problem.
+    """
+
+    problem: str
+    """The problem identified in the review."""
+    solutions: List[str]
+    """A collection of potential solutions to address the problem."""
+
+    def update_problem(self, problem: str) -> Self:
+        """Update the problem description.
+
+        Args:
+            problem (str): The new problem description to replace the current one.
+
+        Returns:
+            Self: The current instance with updated problem description.
+        """
+        self.problem = problem
+        return self
+
+    def update_solutions(self, solutions: List[str]) -> Self:
+        """Update the list of potential solutions.
+
+        Args:
+            solutions (List[str]): The new collection of solutions to replace the current ones.
+
+        Returns:
+            Self: The current instance with updated solutions.
+        """
+        self.solutions = solutions
+        return self
 
 
 class ReviewResult[T](ProposedAble, Display):
-    """Class that represents the result of a review.
+    """Represents the outcome of a review process with identified problems and solutions.
 
-    This class holds the problems identified in a review and their proposed solutions,
-    along with a reference to the reviewed object.
+    This class maintains a structured collection of problems found during a review,
+    their proposed solutions, and a reference to the original reviewed object.
 
     Attributes:
-        existing_problems (List[str]): List of problems identified in the review.
-        proposed_solutions (List[str]): List of proposed solutions to the problems identified in the review.
+        review_topic (str): The subject or focus area of the review.
+        problem_solutions (List[ProblemSolutions]): Collection of problems identified
+            during review along with their potential solutions.
 
     Type Parameters:
         T: The type of the object being reviewed.
     """
 
-    existing_problems: List[str]
-    """List of problems identified in the review."""
+    review_topic: str
+    """The subject or focus area of the review."""
 
-    proposed_solutions: List[str]
-    """List of proposed solutions to the problems identified in the review."""
+    problem_solutions: List[ProblemSolutions]
+    """Collection of problems identified during review along with their potential solutions."""
 
     _ref: T = PrivateAttr(None)
-    """Reference to the object being reviewed."""
+    """Reference to the original object that was reviewed."""
 
     def update_ref[K](self, ref: K) -> "ReviewResult[K]":
-        """Update the reference to the object being reviewed.
+        """Update the reference to the reviewed object.
 
         Args:
-            ref (K): The new reference to the object being reviewed.
+            ref (K): The new reference object to be associated with this review.
 
         Returns:
-            ReviewResult[K]: The updated instance of the ReviewResult class with the new reference type.
+            ReviewResult[K]: The current instance with updated reference type.
         """
         self._ref = ref
         return self
 
     def deref(self) -> T:
-        """Dereference the object being reviewed.
+        """Retrieve the referenced object that was reviewed.
 
         Returns:
-            T: The object being reviewed.
+            T: The original object that was reviewed.
         """
         return self._ref
 
+    async def supervisor_check(self, check_solutions: bool = False) -> 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.
+        """
+        # Choose the problems to retain
+        chosen_ones: List[ProblemSolutions] = await checkbox(
+            f"Please choose the problems you want to retain, under the topic of `{self.review_topic}`.(Default: retain all)",
+            choices=[Choice(p.problem, p, checked=True) for p in self.problem_solutions],
+        ).ask_async()
+        if not check_solutions:
+            self.problem_solutions = chosen_ones
+            return self
+
+        # Choose the solutions to retain
+        for to_exam in chosen_ones:
+            to_exam.update_solutions(
+                await checkbox(
+                    f"Please choose the solutions you want to retain, under the problem of `{to_exam.problem}`.(Default: retain all)",
+                    choices=[Choice(s, s, checked=True) for s in to_exam.solutions],
+                ).ask_async()
+            )
+        return self
+
 
 class Review(GiveRating, Propose):
     """Class that provides functionality to review tasks and strings using a language model.

fabricatio/config.py

@@ -3,6 +3,7 @@
 from typing import List, Literal, Optional
 
 from appdirs import user_config_dir
+from litellm.types.caching import LiteLLMCacheType
 from pydantic import (
     BaseModel,
     ConfigDict,
@@ -25,6 +26,8 @@ from pydantic_settings import (
     TomlConfigSettingsSource,
 )
 
+from fabricatio.models.kwargs_types import CacheKwargs
+
 ROAMING_DIR = user_config_dir("fabricatio", "", roaming=True)
 
 
@@ -265,6 +268,19 @@ class RagConfig(BaseModel):
     """The dimensions of the Milvus server."""
 
 
+class CacheConfig(BaseModel):
+    """cache configuration class, uses litellm as cache backend. more info see https://docs.litellm.ai/docs/caching/all_caches."""
+
+    model_config = ConfigDict(use_attribute_docstrings=True)
+
+    type: Optional[LiteLLMCacheType] = None
+    """The type of cache to use. If None, the default cache type will be used."""
+    params: CacheKwargs = Field(default_factory=CacheKwargs)
+    """The parameters for the cache. If type is None, the default parameters will be used."""
+    enabled: bool = Field(default=False)
+    """Whether to enable cache."""
+
+
 class Settings(BaseSettings):
     """Application settings class.
 
@@ -314,6 +330,9 @@ class Settings(BaseSettings):
     rag: RagConfig = Field(default_factory=RagConfig)
     """RAG Configuration"""
 
+    cache: CacheConfig = Field(default_factory=CacheConfig)
+    """Cache Configuration"""
+
     @classmethod
     def settings_customise_sources(
         cls,

fabricatio/models/kwargs_types.py

@@ -1,7 +1,9 @@
 """This module contains the types for the keyword arguments of the methods in the models module."""
 
-from typing import List, NotRequired, Set, TypedDict
+from typing import Any, List, NotRequired, Set, TypedDict
 
+from litellm.caching.caching import CacheMode
+from litellm.types.caching import CachingSupportedCallTypes
 from pydantic import NonNegativeFloat, NonNegativeInt, PositiveInt
 
 
@@ -65,3 +67,40 @@ class ChooseKwargs(GenerateKwargs):
     """A type representing the keyword arguments for the choose method."""
 
     k: NotRequired[NonNegativeInt]
+
+
+class CacheKwargs(TypedDict, total=False):
+    """A type representing the keyword arguments for the cache method."""
+
+    mode: NotRequired[CacheMode]  # when default_on cache is always on, when default_off cache is opt in
+    host: NotRequired[str]
+    port: NotRequired[str]
+    password: NotRequired[str]
+    namespace: NotRequired[str]
+    ttl: NotRequired[float]
+    default_in_memory_ttl: NotRequired[float]
+    default_in_redis_ttl: NotRequired[float]
+    similarity_threshold: NotRequired[float]
+    supported_call_types: NotRequired[List[CachingSupportedCallTypes]]
+    # s3 Bucket, boto3 configuration
+    s3_bucket_name: NotRequired[str]
+    s3_region_name: NotRequired[str]
+    s3_api_version: NotRequired[str]
+    s3_use_ssl: NotRequired[bool]
+    s3_verify: NotRequired[bool | str]
+    s3_endpoint_url: NotRequired[str]
+    s3_aws_access_key_id: NotRequired[str]
+    s3_aws_secret_access_key: NotRequired[str]
+    s3_aws_session_token: NotRequired[str]
+    s3_config: NotRequired[Any]
+    s3_path: NotRequired[str]
+    redis_semantic_cache_use_async: bool
+    redis_semantic_cache_embedding_model: str
+    redis_flush_size: NotRequired[int]
+    redis_startup_nodes: NotRequired[List]
+    disk_cache_dir: Any
+    qdrant_api_base: NotRequired[str]
+    qdrant_api_key: NotRequired[str]
+    qdrant_collection_name: NotRequired[str]
+    qdrant_quantization_config: NotRequired[str]
+    qdrant_semantic_cache_embedding_model: str

fabricatio/models/role.py

@@ -15,7 +15,7 @@ from pydantic import Field
 class Role(ProposeTask, HandleTask, Review):
     """Class that represents a role with a registry of events and workflows."""
 
-    registry: dict[Event | str, WorkFlow] = Field(...)
+    registry: dict[Event | str, WorkFlow] = Field(default_factory=dict)
     """ The registry of events and workflows."""
 
     toolboxes: Set[ToolBox] = Field(default_factory=set)

fabricatio/models/usages.py

@@ -25,6 +25,14 @@ from litellm.utils import CustomStreamWrapper
 from more_itertools import duplicates_everseen
 from pydantic import Field, NonNegativeInt, PositiveInt
 
+if configs.cache.enabled:
+    from litellm.caching import Cache
+
+    if configs.cache.type is None:
+        Cache(**configs.cache.params)
+    else:
+        Cache(type=configs.cache.type, **configs.cache.params)
+
 
 class LLMUsage(ScopedConfig):
     """Class that manages LLM (Large Language Model) usage parameters and methods."""
@@ -105,14 +113,14 @@ class LLMUsage(ScopedConfig):
     async def aask(
         self,
         question: List[str],
-        system_message: Optional[List[str]] = None,
+        system_message: List[str],
         **kwargs: Unpack[LLMKwargs],
     ) -> List[str]: ...
     @overload
     async def aask(
         self,
         question: str,
-        system_message: Optional[List[str]] = None,
+        system_message: List[str],
         **kwargs: Unpack[LLMKwargs],
     ) -> List[str]: ...
     @overload
@@ -148,36 +156,23 @@ class LLMUsage(ScopedConfig):
             str | List[str]: The content of the model's response message.
         """
         system_message = system_message or ""
-        match (isinstance(question, list), isinstance(system_message, list)):
-            case (True, True):
+        match (question, system_message):
+            case (list(q_seq), list(sm_seq)):
                 res = await gather(
                     *[
                         self.ainvoke(n=1, question=q, system_message=sm, **kwargs)
-                        for q, sm in zip(question, system_message, strict=True)
+                        for q, sm in zip(q_seq, sm_seq, strict=True)
                     ]
                 )
                 return [r.pop().message.content for r in res]
-            case (True, False):
-                res = await gather(
-                    *[self.ainvoke(n=1, question=q, system_message=system_message, **kwargs) for q in question]
-                )
+            case (list(q_seq), str(sm)):
+                res = await gather(*[self.ainvoke(n=1, question=q, system_message=sm, **kwargs) for q in q_seq])
                 return [r.pop().message.content for r in res]
-            case (False, True):
-                res = await gather(
-                    *[self.ainvoke(n=1, question=question, system_message=sm, **kwargs) for sm in system_message]
-                )
+            case (str(q), list(sm_seq)):
+                res = await gather(*[self.ainvoke(n=1, question=q, system_message=sm, **kwargs) for sm in sm_seq])
                 return [r.pop().message.content for r in res]
-            case (False, False):
-                return (
-                    (
-                        await self.ainvoke(
-                            n=1,
-                            question=question,
-                            system_message=system_message,
-                            **kwargs,
-                        )
-                    ).pop()
-                ).message.content
+            case (str(q), str(sm)):
+                return ((await self.ainvoke(n=1, question=q, system_message=sm, **kwargs)).pop()).message.content
             case _:
                 raise RuntimeError("Should not reach here.")
 
@@ -514,7 +509,7 @@ class ToolBoxUsage(LLMUsage):
             logger.warning("No toolboxes available.")
             return []
         return await self.achoose(
-            instruction=task.briefing,  # TODO write a template to build a more robust instruction
+            instruction=task.briefing,
             choices=list(self.toolboxes),
             k=k,
             max_validations=max_validations,
@@ -548,7 +543,7 @@ class ToolBoxUsage(LLMUsage):
             logger.warning(f"No tools available in toolbox {toolbox.name}.")
             return []
         return await self.achoose(
-            instruction=task.briefing,  # TODO write a template to build a more robust instruction
+            instruction=task.briefing,
             choices=toolbox.tools,
             k=k,
             max_validations=max_validations,

{fabricatio-0.2.5.dev1.dist-info → fabricatio-0.2.5.dev2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.5.dev1
+Version: 0.2.5.dev2
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12
@@ -9,7 +9,6 @@ Classifier: Framework :: AsyncIO
 Classifier: Framework :: Pydantic :: 2
 Classifier: Typing :: Typed
 Requires-Dist: appdirs>=1.4.4
-Requires-Dist: async-cache>=1.1.1
 Requires-Dist: asyncio>=3.4.3
 Requires-Dist: asyncstdlib>=3.13.0
 Requires-Dist: litellm>=1.60.0

{fabricatio-0.2.5.dev1.dist-info → fabricatio-0.2.5.dev2.dist-info}/RECORD

@@ -1,15 +1,15 @@
-fabricatio-0.2.5.dev1.dist-info/METADATA,sha256=PsgnEb4yQ2DY_hhyF2y3h0smp-IZwa49GxJb0Mftekc,8623
-fabricatio-0.2.5.dev1.dist-info/WHEEL,sha256=RIvmwLDYujv60MYBx2jxyP4vdn1DD7X0kBgz1TQvZuc,108
-fabricatio-0.2.5.dev1.dist-info/licenses/LICENSE,sha256=yDZaTLnOi03bi3Dk6f5IjhLUc5old2yOsihHWU0z-i0,1067
+fabricatio-0.2.5.dev2.dist-info/METADATA,sha256=GdJ_ONACMtfHqATVU1a3FHdIGh2GTMrqwBpXXGBHIEU,8589
+fabricatio-0.2.5.dev2.dist-info/WHEEL,sha256=RIvmwLDYujv60MYBx2jxyP4vdn1DD7X0kBgz1TQvZuc,108
+fabricatio-0.2.5.dev2.dist-info/licenses/LICENSE,sha256=yDZaTLnOi03bi3Dk6f5IjhLUc5old2yOsihHWU0z-i0,1067
 fabricatio/decorators.py,sha256=cJHsxxbnMhc4SzPl4454CPLuDP3H0qbTrzV_U2rLPrs,6372
 fabricatio/core.py,sha256=MaEKZ6DDmbdScAY-7F1gwGA6fr7ADX6Mz5rNVi2msFA,6277
 fabricatio/models/generic.py,sha256=dP5rNf13Yo-Zy0WpmunsDYOxNbJF3RpFcVBTrYaHnvc,12197
 fabricatio/models/tool.py,sha256=m7gFo8nXywGj7J3zOfPC_wPUgcTY-76ZwAmHlQLWkb8,6836
-fabricatio/models/role.py,sha256=cmKhS_IVjvwkjusestEci_0F0hK0eCa_1Hl4U9vqhiY,1774
+fabricatio/models/role.py,sha256=Xd-TYNefcY9FGeINAI8Q5sCu2pgBXl0l9XKxN0r4rZ0,1791
 fabricatio/models/extra.py,sha256=svUxjM9iPtXCpNJwxYdkvRtvORsze8Fcz4Oql-46huQ,7295
-fabricatio/models/kwargs_types.py,sha256=_nycS6qG1geLmVR5Rh29w7bsANbYyPoI5n77AYO4nMQ,1935
+fabricatio/models/kwargs_types.py,sha256=gHB7Uhk2aArXLdA8Cqb7JhGKoilNxIFD1MvPG5hhuHk,3486
 fabricatio/models/utils.py,sha256=vahILaesw50ofFft-wZ9kZ_Qogqi6vIOISWczvwVXxk,4311
-fabricatio/models/usages.py,sha256=bhRaAlqLSt7p3Khgot4uElo8C-hzVbwst3boeIIMpXo,26237
+fabricatio/models/usages.py,sha256=f4oRQND4BSixYHsqCiIFwSNVYcDfMAJn2JDltnIiwDQ,25936
 fabricatio/models/events.py,sha256=sBCKeNoYc4TFDoke-jhFEyA11RcdGu-wdF5ynAuVOMM,3983
 fabricatio/models/task.py,sha256=BdBfCtxzgDzqHE0eP65liUGRmddAtKhim6optodzEcQ,10193
 fabricatio/models/action.py,sha256=JgCjyddvY-YYnfQPdBwe7i-r4CJNTkGSMnuUW8666HQ,6326
@@ -20,22 +20,22 @@ fabricatio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fabricatio/fs/readers.py,sha256=JNjTaHpH0ljXxJ7SREJYL5gU8bbCe3lDEaVCmna1rww,1168
 fabricatio/fs/curd.py,sha256=DjaL8_lROZVcPghC0U1u7mklLWFxbO9Vz1LWqp6aLl0,4010
 fabricatio/fs/__init__.py,sha256=kfE2e_ijOQtDND_GUBGWDEwtgcP5pYAymCgT0H3qh6M,521
-fabricatio/config.py,sha256=niQ2_IfIQXc6JV4Ff7Z3uGn2SdCEmdGne1lozKikp00,13641
+fabricatio/config.py,sha256=tByDnt0HOthTOdEYK4KJwUqT74gJSVjUUxNOtc9Sa58,14422
 fabricatio/journal.py,sha256=bzxZay48ZWI0VIkkDXm4Wc_Cc9lBQYa2VGx3Hxy_PtA,753
 fabricatio/__init__.py,sha256=kr86hyEDgUbxl1KmWTJqmW1R-aeC8Hd4KFp-2HFr0LM,1870
 fabricatio/actions/output.py,sha256=0sKfU8C9y326IcgZMLeEoZZH3iMpgFGOLGoi9wYZz1U,663
 fabricatio/actions/rag.py,sha256=tP1uKLq7mo19YhsJzFbGYryrcMx6xcvBc3n_Wzh0hjg,796
 fabricatio/actions/article.py,sha256=-WKVYu1HrQOL5nyBraCvRG2bfbkTa_ylH_PyFSI6iLs,2704
-fabricatio/_rust_instances.py,sha256=JAtO-vL8ihvduf1SHLNf0w7ZSVGCJeIv6zZ9Ekyy1hY,271
+fabricatio/_rust_instances.py,sha256=0jwXdYG0pmEaa5Jx8twvRMTtARLe-HeebGR4PEThiBU,305
 fabricatio/workflows/articles.py,sha256=utvKDBFEJbcM76729-H2AvgMCNcsX1NquqMpHqGZq8E,565
 fabricatio/workflows/rag.py,sha256=uOZXprD479fUhLA6sYvEM8RWcVcUZXXtP0xRbTMPdHE,509
 fabricatio/parser.py,sha256=S-4p1mjvJZEgnQW6WKdkmE68MzqqWXGSiLbADdhE-W4,4791
 fabricatio/capabilities/rag.py,sha256=mGUWaVsLbA1vNe0LRdAOeUlR4WMc6mwuOQ0vhPG8m74,15181
-fabricatio/capabilities/rating.py,sha256=ZBlWbecHTAtRhO1beO4fWX3IfwjeyAYSvpXGIRhoGss,13384
-fabricatio/capabilities/review.py,sha256=rsUlKZzURibM33UxuqjgPgxlHcA1vEGvCb-sIeZO9Do,5725
+fabricatio/capabilities/rating.py,sha256=czWKW7PEvJCJoWBhj23-kCbrMUK7k74eTs6mT_AmJvM,13331
+fabricatio/capabilities/review.py,sha256=p3zhwqY4wiV1uAeMledYt8lelPWjWr5UGvEpJyKW3Yc,8715
 fabricatio/capabilities/propose.py,sha256=oW9QKpY2mDkVPEvgsgqxXxDR2ylVqN5TEL8E0Wh_vJI,1714
 fabricatio/capabilities/task.py,sha256=BISAFbMgBI4udW0otE3-iyq0RXc05YN_30N0yI5qLxQ,4504
-fabricatio/_rust.pyi,sha256=tKI4o5ZsxcW4k-O5etU5s60TzjRgJArYxR2YUk7sqkE,1980
-fabricatio/_rust.cpython-312-x86_64-linux-gnu.so,sha256=1ySWosE-ZFyYk7EHHNApJ54x4Q5QgUY4aRrb92LgyLQ,1684256
-fabricatio-0.2.5.dev1.data/scripts/tdown,sha256=EP2gMfsbKrPyWPCx4itYrQqbhVaVpbCxoufK3IbXrTs,4568208
-fabricatio-0.2.5.dev1.dist-info/RECORD,,
+fabricatio/_rust.pyi,sha256=UFWsfkDqeMQt-ipW-4pk1Dnr8u1eHqQ0y-IJNCnqr5M,3066
+fabricatio/_rust.cpython-312-x86_64-linux-gnu.so,sha256=X-d8ziGuBqQEtJXheq6NTFAsxotGLiy2it6rteu9Cic,1898944
+fabricatio-0.2.5.dev2.data/scripts/tdown,sha256=MsmVZJr1r5g1VXyayAS7DEtHgLj0O8a2YbGNf1u6SDw,4571832
+fabricatio-0.2.5.dev2.dist-info/RECORD,,