fabricatio 0.2.13.dev3__cp312-cp312-win_amd64.whl → 0.3.13__cp312-cp312-win_amd64.whl

fabricatio/capabilities/correct.py

@@ -1,11 +1,12 @@
 """A module containing the Correct capability for reviewing, validating, and improving objects."""
 
 from asyncio import gather
-from typing import Optional, Type, Unpack, cast
+from typing import Optional, Unpack, cast
+
+from fabricatio.rust import CONFIG, TEMPLATE_MANAGER
 
 from fabricatio.capabilities.propose import Propose
 from fabricatio.capabilities.rating import Rating
-from fabricatio.config import configs
 from fabricatio.journal import logger
 from fabricatio.models.adv_kwargs_types import CorrectKwargs
 from fabricatio.models.extra.problem import Improvement, ProblemSolutions
@@ -14,7 +15,6 @@ from fabricatio.models.kwargs_types import (
     BestKwargs,
     ValidateKwargs,
 )
-from fabricatio.rust_instances import TEMPLATE_MANAGER
 from fabricatio.utils import fallback_kwargs, ok, override_kwargs
 
 
@@ -22,7 +22,7 @@ class Correct(Rating, Propose):
     """A class that provides the capability to correct objects."""
 
     async def decide_solution(
-        self, problem_solutions: ProblemSolutions, **kwargs: Unpack[BestKwargs]
+            self, problem_solutions: ProblemSolutions, **kwargs: Unpack[BestKwargs]
     ) -> ProblemSolutions:
         """Decide the best solution from a list of problem solutions.
 
@@ -72,11 +72,11 @@ class Correct(Rating, Propose):
         return improvement
 
     async def fix_troubled_obj[M: SketchedAble](
-        self,
-        obj: M,
-        problem_solutions: ProblemSolutions,
-        reference: str = "",
-        **kwargs: Unpack[ValidateKwargs[M]],
+            self,
+            obj: M,
+            problem_solutions: ProblemSolutions,
+            reference: str = "",
+            **kwargs: Unpack[ValidateKwargs[M]],
     ) -> Optional[M]:
         """Fix a troubled object based on problem solutions.
 
@@ -92,7 +92,7 @@ class Correct(Rating, Propose):
         return await self.propose(
             cast("Type[M]", obj.__class__),
             TEMPLATE_MANAGER.render_template(
-                configs.templates.fix_troubled_obj_template,
+                CONFIG.templates.fix_troubled_obj_template,
                 {
                     "problem": problem_solutions.problem.display(),
                     "solution": ok(
@@ -106,11 +106,11 @@ class Correct(Rating, Propose):
         )
 
     async def fix_troubled_string(
-        self,
-        input_text: str,
-        problem_solutions: ProblemSolutions,
-        reference: str = "",
-        **kwargs: Unpack[ValidateKwargs[str]],
+            self,
+            input_text: str,
+            problem_solutions: ProblemSolutions,
+            reference: str = "",
+            **kwargs: Unpack[ValidateKwargs[str]],
     ) -> Optional[str]:
         """Fix a troubled string based on problem solutions.
 
@@ -125,7 +125,7 @@ class Correct(Rating, Propose):
         """
         return await self.ageneric_string(
             TEMPLATE_MANAGER.render_template(
-                configs.templates.fix_troubled_string_template,
+                CONFIG.templates.fix_troubled_string_template,
                 {
                     "problem": problem_solutions.problem.display(),
                     "solution": ok(
@@ -140,11 +140,11 @@ class Correct(Rating, Propose):
         )
 
     async def correct_obj[M: SketchedAble](
-        self,
-        obj: M,
-        improvement: Improvement,
-        reference: str = "",
-        **kwargs: Unpack[ValidateKwargs[M]],
+            self,
+            obj: M,
+            improvement: Improvement,
+            reference: str = "",
+            **kwargs: Unpack[ValidateKwargs[M]],
     ) -> Optional[M]:
         """Review and correct an object based on defined criteria and templates.
 
@@ -178,7 +178,7 @@ class Correct(Rating, Propose):
         return obj
 
     async def correct_string(
-        self, input_text: str, improvement: Improvement, reference: str = "", **kwargs: Unpack[ValidateKwargs[str]]
+            self, input_text: str, improvement: Improvement, reference: str = "", **kwargs: Unpack[ValidateKwargs[str]]
     ) -> Optional[str]:
         """Review and correct a string based on defined criteria and templates.
 
@@ -210,7 +210,7 @@ class Correct(Rating, Propose):
         return input_text
 
     async def correct_obj_inplace[M: ProposedUpdateAble](
-        self, obj: M, **kwargs: Unpack[CorrectKwargs[M]]
+            self, obj: M, **kwargs: Unpack[CorrectKwargs[M]]
     ) -> Optional[M]:
         """Correct an object in place based on defined criteria and templates.
 

fabricatio/capabilities/extract.py

@@ -2,9 +2,10 @@
 
 from typing import List, Optional, Type, Unpack, overload
 
+from fabricatio.rust import CONFIG
+
 from fabricatio import TEMPLATE_MANAGER
 from fabricatio.capabilities.propose import Propose
-from fabricatio.config import configs
 from fabricatio.models.generic import ProposedAble
 from fabricatio.models.kwargs_types import ValidateKwargs
 
@@ -14,54 +15,57 @@ class Extract(Propose):
 
     @overload
     async def extract[M: ProposedAble](
-        self,
-        cls: Type[M],
-        source: str,
-        extract_requirement: Optional[str] = None,
-        align_language: bool = True,
-        **kwargs: Unpack[ValidateKwargs[M]],
+            self,
+            cls: Type[M],
+            source: str,
+            extract_requirement: Optional[str] = None,
+            align_language: bool = True,
+            **kwargs: Unpack[ValidateKwargs[M]],
     ) -> M: ...
+
     @overload
     async def extract[M: ProposedAble](
-        self,
-        cls: Type[M],
-        source: str,
-        extract_requirement: Optional[str] = None,
-        align_language: bool = True,
-        **kwargs: Unpack[ValidateKwargs[None]],
+            self,
+            cls: Type[M],
+            source: str,
+            extract_requirement: Optional[str] = None,
+            align_language: bool = True,
+            **kwargs: Unpack[ValidateKwargs[None]],
     ) -> Optional[M]: ...
 
     @overload
     async def extract[M: ProposedAble](
-        self,
-        cls: Type[M],
-        source: List[str],
-        extract_requirement: Optional[str] = None,
-        align_language: bool = True,
-        **kwargs: Unpack[ValidateKwargs[M]],
+            self,
+            cls: Type[M],
+            source: List[str],
+            extract_requirement: Optional[str] = None,
+            align_language: bool = True,
+            **kwargs: Unpack[ValidateKwargs[M]],
     ) -> List[M]: ...
+
     @overload
     async def extract[M: ProposedAble](
-        self,
-        cls: Type[M],
-        source: List[str],
-        extract_requirement: Optional[str] = None,
-        align_language: bool = True,
-        **kwargs: Unpack[ValidateKwargs[None]],
+            self,
+            cls: Type[M],
+            source: List[str],
+            extract_requirement: Optional[str] = None,
+            align_language: bool = True,
+            **kwargs: Unpack[ValidateKwargs[None]],
     ) -> List[Optional[M]]: ...
+
     async def extract[M: ProposedAble](
-        self,
-        cls: Type[M],
-        source: List[str] | str,
-        extract_requirement: Optional[str] = None,
-        align_language: bool = True,
-        **kwargs: Unpack[ValidateKwargs[Optional[M]]],
+            self,
+            cls: Type[M],
+            source: List[str] | str,
+            extract_requirement: Optional[str] = None,
+            align_language: bool = True,
+            **kwargs: Unpack[ValidateKwargs[Optional[M]]],
     ) -> M | List[M] | Optional[M] | List[Optional[M]]:
         """Extract information from a given source to a model."""
         return await self.propose(
             cls,
             prompt=TEMPLATE_MANAGER.render_template(
-                configs.templates.extract_template,
+                CONFIG.templates.extract_template,
                 [{"source": s, "extract_requirement": extract_requirement} for s in source]
                 if isinstance(source, list)
                 else {"source": source, "extract_requirement": extract_requirement, "align_language": align_language},

fabricatio/capabilities/rag.py

@@ -10,16 +10,15 @@ from functools import lru_cache
 from operator import itemgetter
 from typing import List, Optional, Self, Type, Unpack
 
+from fabricatio.rust import CONFIG, TEMPLATE_MANAGER
 from more_itertools.recipes import flatten, unique
 from pydantic import Field, PrivateAttr
 
-from fabricatio.config import configs
 from fabricatio.journal import logger
 from fabricatio.models.adv_kwargs_types import CollectionConfigKwargs, FetchKwargs
 from fabricatio.models.extra.rag import MilvusDataBase
 from fabricatio.models.kwargs_types import ChooseKwargs
 from fabricatio.models.usages import EmbeddingUsage
-from fabricatio.rust_instances import TEMPLATE_MANAGER
 from fabricatio.utils import ok
 
 
@@ -50,17 +49,17 @@ class RAG(EmbeddingUsage):
         return self._client
 
     def init_client(
-        self,
-        milvus_uri: Optional[str] = None,
-        milvus_token: Optional[str] = None,
-        milvus_timeout: Optional[float] = None,
+            self,
+            milvus_uri: Optional[str] = None,
+            milvus_token: Optional[str] = None,
+            milvus_timeout: Optional[float] = None,
     ) -> Self:
         """Initialize the Milvus client."""
         self._client = create_client(
-            uri=milvus_uri or ok(self.milvus_uri or configs.rag.milvus_uri).unicode_string(),
+            uri=milvus_uri or ok(self.milvus_uri or CONFIG.rag.milvus_uri).unicode_string(),
             token=milvus_token
-            or (token.get_secret_value() if (token := (self.milvus_token or configs.rag.milvus_token)) else ""),
-            timeout=milvus_timeout or self.milvus_timeout or configs.rag.milvus_timeout,
+                  or (token.get_secret_value() if (token := (self.milvus_token or CONFIG.rag.milvus_token)) else ""),
+            timeout=milvus_timeout or self.milvus_timeout or CONFIG.rag.milvus_timeout,
         )
         return self
 
@@ -73,7 +72,7 @@ class RAG(EmbeddingUsage):
         return self
 
     def view(
-        self, collection_name: Optional[str], create: bool = False, **kwargs: Unpack[CollectionConfigKwargs]
+            self, collection_name: Optional[str], create: bool = False, **kwargs: Unpack[CollectionConfigKwargs]
     ) -> Self:
         """View the specified collection.
 
@@ -86,9 +85,9 @@ class RAG(EmbeddingUsage):
             kwargs["dimension"] = ok(
                 kwargs.get("dimension")
                 or self.milvus_dimensions
-                or configs.rag.milvus_dimensions
+                or CONFIG.rag.milvus_dimensions
                 or self.embedding_dimensions
-                or configs.embedding.dimensions,
+                or CONFIG.embedding.dimensions,
                 "`dimension` is not set at any level.",
             )
             self.client.create_collection(collection_name, auto_id=True, **kwargs)
@@ -115,7 +114,7 @@ class RAG(EmbeddingUsage):
         return ok(self.target_collection, "No collection is being viewed. Have you called `self.view()`?")
 
     async def add_document[D: MilvusDataBase](
-        self, data: List[D] | D, collection_name: Optional[str] = None, flush: bool = False
+            self, data: List[D] | D, collection_name: Optional[str] = None, flush: bool = False
     ) -> Self:
         """Adds a document to the specified collection.
 
@@ -142,15 +141,15 @@ class RAG(EmbeddingUsage):
         return self
 
     async def afetch_document[D: MilvusDataBase](
-        self,
-        query: List[str],
-        document_model: Type[D],
-        collection_name: Optional[str] = None,
-        similarity_threshold: float = 0.37,
-        result_per_query: int = 10,
-        tei_endpoint: Optional[str] = None,
-        reranker_threshold: float = 0.7,
-        filter_expr: str = "",
+            self,
+            query: List[str],
+            document_model: Type[D],
+            collection_name: Optional[str] = None,
+            similarity_threshold: float = 0.37,
+            result_per_query: int = 10,
+            tei_endpoint: Optional[str] = None,
+            reranker_threshold: float = 0.7,
+            filter_expr: str = "",
     ) -> List[D]:
         """Asynchronously fetches documents from a Milvus database based on input vectors.
 
@@ -215,11 +214,11 @@ class RAG(EmbeddingUsage):
         return document_model.from_sequence(resp)
 
     async def aretrieve[D: MilvusDataBase](
-        self,
-        query: List[str] | str,
-        document_model: Type[D],
-        max_accepted: int = 20,
-        **kwargs: Unpack[FetchKwargs],
+            self,
+            query: List[str] | str,
+            document_model: Type[D],
+            max_accepted: int = 20,
+            **kwargs: Unpack[FetchKwargs],
     ) -> List[D]:
         """Retrieve data from the collection.
 
@@ -236,15 +235,15 @@ class RAG(EmbeddingUsage):
             query = [query]
 
         return (
-            await self.afetch_document(
-                query=query,
-                document_model=document_model,
-                **kwargs,
-            )
-        )[:max_accepted]
+                   await self.afetch_document(
+                       query=query,
+                       document_model=document_model,
+                       **kwargs,
+                   )
+               )[:max_accepted]
 
     async def arefined_query(
-        self, question: List[str] | str, **kwargs: Unpack[ChooseKwargs[Optional[List[str]]]]
+            self, question: List[str] | str, **kwargs: Unpack[ChooseKwargs[Optional[List[str]]]]
     ) -> Optional[List[str]]:
         """Refines the given question using a template.
 
@@ -257,7 +256,7 @@ class RAG(EmbeddingUsage):
         """
         return await self.alist_str(
             TEMPLATE_MANAGER.render_template(
-                configs.templates.refined_query_template,
+                CONFIG.templates.refined_query_template,
                 {"question": [question] if isinstance(question, str) else question},
             ),
             **kwargs,

fabricatio/capabilities/rating.py

@@ -4,16 +4,15 @@ from itertools import permutations
 from random import sample
 from typing import Dict, List, Optional, Set, Tuple, Union, Unpack, overload
 
+from fabricatio.rust import CONFIG, TEMPLATE_MANAGER
 from more_itertools import flatten, windowed
 from pydantic import Field, NonNegativeInt, PositiveInt, create_model
 
 from fabricatio.capabilities.propose import Propose
-from fabricatio.config import configs
 from fabricatio.journal import logger
 from fabricatio.models.generic import Display, ProposedAble
 from fabricatio.models.kwargs_types import CompositeScoreKwargs, ValidateKwargs
 from fabricatio.parser import JsonCapture
-from fabricatio.rust_instances import TEMPLATE_MANAGER
 from fabricatio.utils import ok, override_kwargs
 
 
@@ -25,11 +24,11 @@ class Rating(Propose):
     """
 
     async def rate_fine_grind(
-        self,
-        to_rate: str | List[str],
-        rating_manual: Dict[str, str],
-        score_range: Tuple[float, float],
-        **kwargs: Unpack[ValidateKwargs[Dict[str, float]]],
+            self,
+            to_rate: str | List[str],
+            rating_manual: Dict[str, str],
+            score_range: Tuple[float, float],
+            **kwargs: Unpack[ValidateKwargs[Dict[str, float]]],
     ) -> Dict[str, float] | List[Dict[str, float]] | List[Optional[Dict[str, float]]] | None:
         """Rate a given string based on a rating manual and score range.
 
@@ -66,13 +65,13 @@ class Rating(Propose):
         res = await self.propose(
             model,
             TEMPLATE_MANAGER.render_template(
-                configs.templates.rate_fine_grind_template,
+                CONFIG.templates.rate_fine_grind_template,
                 {"to_rate": to_rate, "min_score": min_score, "max_score": max_score},
             )
             if isinstance(to_rate, str)
             else [
                 TEMPLATE_MANAGER.render_template(
-                    configs.templates.rate_fine_grind_template,
+                    CONFIG.templates.rate_fine_grind_template,
                     {"to_rate": t, "min_score": min_score, "max_score": max_score},
                 )
                 for t in to_rate
@@ -88,34 +87,36 @@ class Rating(Propose):
 
     @overload
     async def rate(
-        self,
-        to_rate: str,
-        topic: str,
-        criteria: Set[str],
-        manual: Optional[Dict[str, str]] = None,
-        score_range: Tuple[float, float] = (0.0, 1.0),
-        **kwargs: Unpack[ValidateKwargs],
-    ) -> Dict[str, float]: ...
+            self,
+            to_rate: str,
+            topic: str,
+            criteria: Set[str],
+            manual: Optional[Dict[str, str]] = None,
+            score_range: Tuple[float, float] = (0.0, 1.0),
+            **kwargs: Unpack[ValidateKwargs],
+    ) -> Dict[str, float]:
+        ...
 
     @overload
     async def rate(
-        self,
-        to_rate: List[str],
-        topic: str,
-        criteria: Set[str],
-        manual: Optional[Dict[str, str]] = None,
-        score_range: Tuple[float, float] = (0.0, 1.0),
-        **kwargs: Unpack[ValidateKwargs],
-    ) -> List[Dict[str, float]]: ...
+            self,
+            to_rate: List[str],
+            topic: str,
+            criteria: Set[str],
+            manual: Optional[Dict[str, str]] = None,
+            score_range: Tuple[float, float] = (0.0, 1.0),
+            **kwargs: Unpack[ValidateKwargs],
+    ) -> List[Dict[str, float]]:
+        ...
 
     async def rate(
-        self,
-        to_rate: Union[str, List[str]],
-        topic: str,
-        criteria: Set[str],
-        manual: Optional[Dict[str, str]] = None,
-        score_range: Tuple[float, float] = (0.0, 1.0),
-        **kwargs: Unpack[ValidateKwargs],
+            self,
+            to_rate: Union[str, List[str]],
+            topic: str,
+            criteria: Set[str],
+            manual: Optional[Dict[str, str]] = None,
+            score_range: Tuple[float, float] = (0.0, 1.0),
+            **kwargs: Unpack[ValidateKwargs],
     ) -> Dict[str, float] | List[Dict[str, float]] | List[Optional[Dict[str, float]]] | None:
         """Rate a given string or a sequence of strings based on a topic, criteria, and score range.
 
@@ -132,15 +133,15 @@ class Rating(Propose):
             or a list of dictionaries with the ratings for each criterion if a sequence of strings is provided.
         """
         manual = (
-            manual
-            or await self.draft_rating_manual(topic, criteria, **override_kwargs(kwargs, default=None))
-            or dict(zip(criteria, criteria, strict=True))
+                manual
+                or await self.draft_rating_manual(topic, criteria, **override_kwargs(kwargs, default=None))
+                or dict(zip(criteria, criteria, strict=True))
         )
 
         return await self.rate_fine_grind(to_rate, manual, score_range, **kwargs)
 
     async def draft_rating_manual(
-        self, topic: str, criteria: Optional[Set[str]] = None, **kwargs: Unpack[ValidateKwargs[Dict[str, str]]]
+            self, topic: str, criteria: Optional[Set[str]] = None, **kwargs: Unpack[ValidateKwargs[Dict[str, str]]]
     ) -> Optional[Dict[str, str]]:
         """Drafts a rating manual based on a topic and dimensions.
 
@@ -155,9 +156,9 @@ class Rating(Propose):
 
         def _validator(response: str) -> Dict[str, str] | None:
             if (
-                (json_data := JsonCapture.validate_with(response, target_type=dict, elements_type=str)) is not None
-                and json_data.keys() == criteria
-                and all(isinstance(v, str) for v in json_data.values())
+                    (json_data := JsonCapture.validate_with(response, target_type=dict, elements_type=str)) is not None
+                    and json_data.keys() == criteria
+                    and all(isinstance(v, str) for v in json_data.values())
             ):
                 return json_data
             return None
@@ -171,7 +172,7 @@ class Rating(Propose):
         return await self.aask_validate(
             question=(
                 TEMPLATE_MANAGER.render_template(
-                    configs.templates.draft_rating_manual_template,
+                    CONFIG.templates.draft_rating_manual_template,
                     {
                         "topic": topic,
                         "criteria": list(criteria),
@@ -183,10 +184,10 @@ class Rating(Propose):
         )
 
     async def draft_rating_criteria(
-        self,
-        topic: str,
-        criteria_count: NonNegativeInt = 0,
-        **kwargs: Unpack[ValidateKwargs[Set[str]]],
+            self,
+            topic: str,
+            criteria_count: NonNegativeInt = 0,
+            **kwargs: Unpack[ValidateKwargs[Set[str]]],
     ) -> Optional[Set[str]]:
         """Drafts rating dimensions based on a topic.
 
@@ -201,7 +202,7 @@ class Rating(Propose):
         return await self.aask_validate(
             question=(
                 TEMPLATE_MANAGER.render_template(
-                    configs.templates.draft_rating_criteria_template,
+                    CONFIG.templates.draft_rating_criteria_template,
                     {
                         "topic": topic,
                         "criteria_count": criteria_count,
@@ -215,13 +216,13 @@ class Rating(Propose):
         )
 
     async def draft_rating_criteria_from_examples(
-        self,
-        topic: str,
-        examples: List[str],
-        m: NonNegativeInt = 0,
-        reasons_count: PositiveInt = 2,
-        criteria_count: PositiveInt = 5,
-        **kwargs: Unpack[ValidateKwargs],
+            self,
+            topic: str,
+            examples: List[str],
+            m: NonNegativeInt = 0,
+            reasons_count: PositiveInt = 2,
+            criteria_count: PositiveInt = 5,
+            **kwargs: Unpack[ValidateKwargs],
     ) -> Optional[Set[str]]:
         """Asynchronously drafts a set of rating criteria based on provided examples.
 
@@ -251,7 +252,7 @@ class Rating(Propose):
             await self.aask_validate(  # pyright: ignore [reportArgumentType]
                 question=[
                     TEMPLATE_MANAGER.render_template(
-                        configs.templates.extract_reasons_from_examples_template,
+                        CONFIG.templates.extract_reasons_from_examples_template,
                         {
                             "topic": topic,
                             "first": pair[0],
@@ -271,7 +272,7 @@ class Rating(Propose):
         return await self.aask_validate(
             question=(
                 TEMPLATE_MANAGER.render_template(
-                    configs.templates.extract_criteria_from_reasons_template,
+                    CONFIG.templates.extract_criteria_from_reasons_template,
                     {
                         "topic": topic,
                         "reasons": list(reasons),
@@ -286,10 +287,10 @@ class Rating(Propose):
         )
 
     async def drafting_rating_weights_klee(
-        self,
-        topic: str,
-        criteria: Set[str],
-        **kwargs: Unpack[ValidateKwargs[float]],
+            self,
+            topic: str,
+            criteria: Set[str],
+            **kwargs: Unpack[ValidateKwargs[float]],
     ) -> Dict[str, float]:
         """Drafts rating weights for a given topic and criteria using the Klee method.
 
@@ -311,7 +312,7 @@ class Rating(Propose):
         relative_weights = await self.aask_validate(
             question=[
                 TEMPLATE_MANAGER.render_template(
-                    configs.templates.draft_rating_weights_klee_template,
+                    CONFIG.templates.draft_rating_weights_klee_template,
                     {
                         "topic": topic,
                         "first": pair[0],
@@ -332,14 +333,14 @@ class Rating(Propose):
         return dict(zip(criteria_seq, [w / total for w in weights], strict=True))
 
     async def composite_score(
-        self,
-        topic: str,
-        to_rate: List[str],
-        criteria: Optional[Set[str]] = None,
-        weights: Optional[Dict[str, float]] = None,
-        manual: Optional[Dict[str, str]] = None,
-        approx: bool = False,
-        **kwargs: Unpack[ValidateKwargs[List[Dict[str, float]]]],
+            self,
+            topic: str,
+            to_rate: List[str],
+            criteria: Optional[Set[str]] = None,
+            weights: Optional[Dict[str, float]] = None,
+            manual: Optional[Dict[str, str]] = None,
+            approx: bool = False,
+            **kwargs: Unpack[ValidateKwargs[List[Dict[str, float]]]],
     ) -> List[float]:
         """Calculates the composite scores for a list of items based on a given topic and criteria.
 
@@ -369,14 +370,17 @@ class Rating(Propose):
         return [sum(ratings[c] * weights[c] for c in criteria) for ratings in ratings_seq]
 
     @overload
-    async def best(self, candidates: List[str], k: int = 1, **kwargs: Unpack[CompositeScoreKwargs]) -> List[str]: ...
+    async def best(self, candidates: List[str], k: int = 1, **kwargs: Unpack[CompositeScoreKwargs]) -> List[str]:
+        ...
+
     @overload
     async def best[T: Display](
-        self, candidates: List[T], k: int = 1, **kwargs: Unpack[CompositeScoreKwargs]
-    ) -> List[T]: ...
+            self, candidates: List[T], k: int = 1, **kwargs: Unpack[CompositeScoreKwargs]
+    ) -> List[T]:
+        ...
 
     async def best[T: Display](
-        self, candidates: List[str] | List[T], k: int = 1, **kwargs: Unpack[CompositeScoreKwargs]
+            self, candidates: List[str] | List[T], k: int = 1, **kwargs: Unpack[CompositeScoreKwargs]
     ) -> Optional[List[str] | List[T]]:
         """Choose the best candidates from the list of candidates based on the composite score.
 
@@ -400,4 +404,5 @@ class Rating(Propose):
         rating_seq = await self.composite_score(
             to_rate=[c.display() if isinstance(c, Display) else c for c in candidates], **kwargs
         )
-        return [a[0] for a in sorted(zip(candidates, rating_seq, strict=True), key=lambda x: x[1], reverse=True)[:k]]  # pyright: ignore [reportReturnType]
+        return [a[0] for a in sorted(zip(candidates, rating_seq, strict=True), key=lambda x: x[1], reverse=True)[
+                              :k]]  # pyright: ignore [reportReturnType]