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

fabricatio/capabilities/check.py

@@ -3,17 +3,16 @@
 from asyncio import gather
 from typing import List, Optional, Unpack
 
-from fabricatio import TEMPLATE_MANAGER
+from fabricatio.rust import CONFIG, TEMPLATE_MANAGER, detect_language
+
 from fabricatio.capabilities.advanced_judge import AdvancedJudge
 from fabricatio.capabilities.propose import Propose
-from fabricatio.config import configs
 from fabricatio.journal import logger
 from fabricatio.models.extra.patches import RuleSetMetadata
 from fabricatio.models.extra.problem import Improvement
 from fabricatio.models.extra.rule import Rule, RuleSet
 from fabricatio.models.generic import Display, WithBriefing
 from fabricatio.models.kwargs_types import ValidateKwargs
-from fabricatio.rust import detect_language
 from fabricatio.utils import override_kwargs
 
 
@@ -25,7 +24,7 @@ class Check(AdvancedJudge, Propose):
     """
 
     async def draft_ruleset(
-        self, ruleset_requirement: str, rule_count: int = 0, **kwargs: Unpack[ValidateKwargs[Rule]]
+            self, ruleset_requirement: str, rule_count: int = 0, **kwargs: Unpack[ValidateKwargs[Rule]]
     ) -> Optional[RuleSet]:
         """Generate rule set based on requirement description.
 
@@ -45,7 +44,7 @@ class Check(AdvancedJudge, Propose):
         rule_reqs = (
             await self.alist_str(
                 TEMPLATE_MANAGER.render_template(
-                    configs.templates.ruleset_requirement_breakdown_template,
+                    CONFIG.templates.ruleset_requirement_breakdown_template,
                     {"ruleset_requirement": ruleset_requirement},
                 ),
                 rule_count,
@@ -61,7 +60,7 @@ class Check(AdvancedJudge, Propose):
         rules = await self.propose(
             Rule,
             [
-                TEMPLATE_MANAGER.render_template(configs.templates.rule_requirement_template, {"rule_requirement": r})
+                TEMPLATE_MANAGER.render_template(CONFIG.templates.rule_requirement_template, {"rule_requirement": r})
                 for r in rule_reqs
             ],
             **kwargs,
@@ -81,11 +80,11 @@ class Check(AdvancedJudge, Propose):
         return RuleSet(rules=rules, **ruleset_patch.as_kwargs())
 
     async def check_string_against_rule(
-        self,
-        input_text: str,
-        rule: Rule,
-        reference: str = "",
-        **kwargs: Unpack[ValidateKwargs[Improvement]],
+            self,
+            input_text: str,
+            rule: Rule,
+            reference: str = "",
+            **kwargs: Unpack[ValidateKwargs[Improvement]],
     ) -> Optional[Improvement]:
         """Validate text against specific rule.
 
@@ -104,15 +103,15 @@ class Check(AdvancedJudge, Propose):
             - Proposes Improvement only when violation is confirmed
         """
         if judge := await self.evidently_judge(
-            f"# Content to exam\n{input_text}\n\n# Rule Must to follow\n{rule.display()}\nDoes `Content to exam` provided above violate the `{rule.name}` provided above?"
-            f"should I take some measure to fix that violation? true for I do need, false for I don't need.",
-            **override_kwargs(kwargs, default=None),
+                f"# Content to exam\n{input_text}\n\n# Rule Must to follow\n{rule.display()}\nDoes `Content to exam` provided above violate the `{rule.name}` provided above?"
+                f"should I take some measure to fix that violation? true for I do need, false for I don't need.",
+                **override_kwargs(kwargs, default=None),
         ):
             logger.info(f"Rule `{rule.name}` violated: \n{judge.display()}")
             return await self.propose(
                 Improvement,
                 TEMPLATE_MANAGER.render_template(
-                    configs.templates.check_string_template,
+                    CONFIG.templates.check_string_template,
                     {"to_check": input_text, "rule": rule.display(), "judge": judge.display(), "reference": reference},
                 ),
                 **kwargs,
@@ -120,11 +119,11 @@ class Check(AdvancedJudge, Propose):
         return None
 
     async def check_obj_against_rule[M: (Display, WithBriefing)](
-        self,
-        obj: M,
-        rule: Rule,
-        reference: str = "",
-        **kwargs: Unpack[ValidateKwargs[Improvement]],
+            self,
+            obj: M,
+            rule: Rule,
+            reference: str = "",
+            **kwargs: Unpack[ValidateKwargs[Improvement]],
     ) -> Optional[Improvement]:
         """Validate object against rule using text representation.
 
@@ -152,11 +151,11 @@ class Check(AdvancedJudge, Propose):
         return await self.check_string_against_rule(input_text, rule, reference, **kwargs)
 
     async def check_string(
-        self,
-        input_text: str,
-        ruleset: RuleSet,
-        reference: str = "",
-        **kwargs: Unpack[ValidateKwargs[Improvement]],
+            self,
+            input_text: str,
+            ruleset: RuleSet,
+            reference: str = "",
+            **kwargs: Unpack[ValidateKwargs[Improvement]],
     ) -> Optional[List[Improvement]]:
         """Validate text against full ruleset.
 
@@ -183,11 +182,11 @@ class Check(AdvancedJudge, Propose):
         return [imp for imp in imp_seq if imp]
 
     async def check_obj[M: (Display, WithBriefing)](
-        self,
-        obj: M,
-        ruleset: RuleSet,
-        reference: str = "",
-        **kwargs: Unpack[ValidateKwargs[Improvement]],
+            self,
+            obj: M,
+            ruleset: RuleSet,
+            reference: str = "",
+            **kwargs: Unpack[ValidateKwargs[Improvement]],
     ) -> Optional[List[Improvement]]:
         """Validate object against full ruleset.
 

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,