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

fabricatio/models/usages.py

@@ -6,16 +6,7 @@ from typing import Callable, Dict, Iterable, List, Literal, Optional, Self, Sequ
 
 import asyncstdlib
 import litellm
-from fabricatio.config import configs
-from fabricatio.decorators import logging_exec_time
-from fabricatio.journal import logger
-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.parser import GenericCapture, JsonCapture
-from fabricatio.rust_instances import TEMPLATE_MANAGER
-from fabricatio.utils import ok
+from fabricatio.rust import CONFIG, TEMPLATE_MANAGER
 from litellm import RateLimitError, Router, stream_chunk_builder  # pyright: ignore [reportPrivateImportUsage]
 from litellm.types.router import Deployment, LiteLLM_Params, ModelInfo
 from litellm.types.utils import (
@@ -29,18 +20,21 @@ from litellm.utils import CustomStreamWrapper, token_counter  # pyright: ignore
 from more_itertools import duplicates_everseen
 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)
-    logger.debug(f"{configs.cache.type.name} Cache enabled")
+from fabricatio.decorators import logging_exec_time
+from fabricatio.journal import logger
+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.parser import GenericCapture, JsonCapture
+from fabricatio.utils import ok
 
 ROUTER = Router(
     routing_strategy="usage-based-routing-v2",
-    default_max_parallel_requests=configs.routing.max_parallel_requests,
-    allowed_fails=configs.routing.allowed_fails,
-    retry_after=configs.routing.retry_after,
-    cooldown_time=configs.routing.cooldown_time,
-    cache_responses=configs.cache.enabled,
-    cache_kwargs=configs.cache.params,
+    default_max_parallel_requests=CONFIG.routing.max_parallel_requests,
+    allowed_fails=CONFIG.routing.allowed_fails,
+    retry_after=CONFIG.routing.retry_after,
+    cooldown_time=CONFIG.routing.cooldown_time,
 )
 
 
@@ -65,10 +59,10 @@ class LLMUsage(ScopedConfig):
 
     # noinspection PyTypeChecker,PydanticTypeChecker,t
     async def aquery(
-        self,
-        messages: List[Dict[str, str]],
-        n: PositiveInt | None = None,
-        **kwargs: Unpack[LLMKwargs],
+            self,
+            messages: List[Dict[str, str]],
+            n: PositiveInt | None = None,
+            **kwargs: Unpack[LLMKwargs],
     ) -> ModelResponse | CustomStreamWrapper:
         """Asynchronously queries the language model to generate a response based on the provided messages and parameters.
 
@@ -86,36 +80,36 @@ class LLMUsage(ScopedConfig):
             Deployment(
                 model_name=(
                     m_name := ok(
-                        kwargs.get("model") or self.llm_model or configs.llm.model, "model name is not set at any place"
+                        kwargs.get("model") or self.llm_model or CONFIG.llm.model, "model name is not set at any place"
                     )
                 ),  # pyright: ignore [reportCallIssue]
                 litellm_params=(
                     p := LiteLLM_Params(
                         api_key=ok(
-                            self.llm_api_key or configs.llm.api_key, "llm api key is not set at any place"
+                            self.llm_api_key or CONFIG.llm.api_key, "llm api key is not set at any place"
                         ).get_secret_value(),
                         api_base=ok(
-                            self.llm_api_endpoint or configs.llm.api_endpoint,
+                            self.llm_api_endpoint or CONFIG.llm.api_endpoint,
                             "llm api endpoint is not set at any place",
                         ).unicode_string(),
                         model=m_name,
-                        tpm=self.llm_tpm or configs.llm.tpm,
-                        rpm=self.llm_rpm or configs.llm.rpm,
-                        max_retries=kwargs.get("max_retries") or self.llm_max_retries or configs.llm.max_retries,
-                        timeout=kwargs.get("timeout") or self.llm_timeout or configs.llm.timeout,
+                        tpm=self.llm_tpm or CONFIG.llm.tpm,
+                        rpm=self.llm_rpm or CONFIG.llm.rpm,
+                        max_retries=kwargs.get("max_retries") or self.llm_max_retries or CONFIG.llm.max_retries,
+                        timeout=kwargs.get("timeout") or self.llm_timeout or CONFIG.llm.timeout,
                     )
                 ),
                 model_info=ModelInfo(id=hash(m_name + p.model_dump_json(exclude_none=True))),
             )
         ).acompletion(
             messages=messages,  # pyright: ignore [reportArgumentType]
-            n=n or self.llm_generation_count or configs.llm.generation_count,
+            n=n or self.llm_generation_count or CONFIG.llm.generation_count,
             model=m_name,
-            temperature=kwargs.get("temperature") or self.llm_temperature or configs.llm.temperature,
-            stop=kwargs.get("stop") or self.llm_stop_sign or configs.llm.stop_sign,
-            top_p=kwargs.get("top_p") or self.llm_top_p or configs.llm.top_p,
-            max_tokens=kwargs.get("max_tokens") or self.llm_max_tokens or configs.llm.max_tokens,
-            stream=ok(kwargs.get("stream") or self.llm_stream or configs.llm.stream, "stream is not set at any place"),
+            temperature=kwargs.get("temperature") or self.llm_temperature or CONFIG.llm.temperature,
+            stop=kwargs.get("stop") or self.llm_stop_sign or CONFIG.llm.stop_sign,
+            top_p=kwargs.get("top_p") or self.llm_top_p or CONFIG.llm.top_p,
+            max_tokens=kwargs.get("max_tokens") or self.llm_max_tokens or CONFIG.llm.max_tokens,
+            stream=ok(kwargs.get("stream") or self.llm_stream or CONFIG.llm.stream, "stream is not set at any place"),
             cache={
                 "no-cache": kwargs.get("no_cache"),
                 "no-store": kwargs.get("no_store"),
@@ -123,19 +117,19 @@ class LLMUsage(ScopedConfig):
                 "s-maxage": kwargs.get("s_maxage"),
             },
             presence_penalty=kwargs.get("presence_penalty")
-            or self.llm_presence_penalty
-            or configs.llm.presence_penalty,
+                             or self.llm_presence_penalty
+                             or CONFIG.llm.presence_penalty,
             frequency_penalty=kwargs.get("frequency_penalty")
-            or self.llm_frequency_penalty
-            or configs.llm.frequency_penalty,
+                              or self.llm_frequency_penalty
+                              or CONFIG.llm.frequency_penalty,
         )
 
     async def ainvoke(
-        self,
-        question: str,
-        system_message: str = "",
-        n: PositiveInt | None = None,
-        **kwargs: Unpack[LLMKwargs],
+            self,
+            question: str,
+            system_message: str = "",
+            n: PositiveInt | None = None,
+            **kwargs: Unpack[LLMKwargs],
     ) -> Sequence[TextChoices | Choices | StreamingChoices]:
         """Asynchronously invokes the language model with a question and optional system message.
 
@@ -156,8 +150,6 @@ class LLMUsage(ScopedConfig):
         if isinstance(resp, ModelResponse):
             return resp.choices
         if isinstance(resp, CustomStreamWrapper):
-            if not configs.debug.streaming_visible and (pack := stream_chunk_builder(await asyncstdlib.list())):
-                return pack.choices
             if pack := stream_chunk_builder(await asyncstdlib.list(resp)):
                 return pack.choices
         logger.critical(err := f"Unexpected response type: {type(resp)}")
@@ -165,40 +157,46 @@ class LLMUsage(ScopedConfig):
 
     @overload
     async def aask(
-        self,
-        question: List[str],
-        system_message: List[str],
-        **kwargs: Unpack[LLMKwargs],
-    ) -> List[str]: ...
+            self,
+            question: List[str],
+            system_message: List[str],
+            **kwargs: Unpack[LLMKwargs],
+    ) -> List[str]:
+        ...
+
     @overload
     async def aask(
-        self,
-        question: str,
-        system_message: List[str],
-        **kwargs: Unpack[LLMKwargs],
-    ) -> List[str]: ...
+            self,
+            question: str,
+            system_message: List[str],
+            **kwargs: Unpack[LLMKwargs],
+    ) -> List[str]:
+        ...
+
     @overload
     async def aask(
-        self,
-        question: List[str],
-        system_message: Optional[str] = None,
-        **kwargs: Unpack[LLMKwargs],
-    ) -> List[str]: ...
+            self,
+            question: List[str],
+            system_message: Optional[str] = None,
+            **kwargs: Unpack[LLMKwargs],
+    ) -> List[str]:
+        ...
 
     @overload
     async def aask(
-        self,
-        question: str,
-        system_message: Optional[str] = None,
-        **kwargs: Unpack[LLMKwargs],
-    ) -> str: ...
+            self,
+            question: str,
+            system_message: Optional[str] = None,
+            **kwargs: Unpack[LLMKwargs],
+    ) -> str:
+        ...
 
     @logging_exec_time
     async def aask(
-        self,
-        question: str | List[str],
-        system_message: Optional[str | List[str]] = None,
-        **kwargs: Unpack[LLMKwargs],
+            self,
+            question: str | List[str],
+            system_message: Optional[str | List[str]] = None,
+            **kwargs: Unpack[LLMKwargs],
     ) -> str | List[str]:
         """Asynchronously asks the language model a question and returns the response content.
 
@@ -226,60 +224,68 @@ class LLMUsage(ScopedConfig):
                 res = await gather(*[self.ainvoke(n=1, question=q, system_message=sm, **kwargs) for sm in sm_seq])
                 out = [r[0].message.content for r in res]  # pyright: ignore [reportAttributeAccessIssue]
             case (str(q), str(sm)):
-                out = ((await self.ainvoke(n=1, question=q, system_message=sm, **kwargs))[0]).message.content  # pyright: ignore [reportAttributeAccessIssue]
+                out = ((await self.ainvoke(n=1, question=q, system_message=sm, **kwargs))[
+                    0]).message.content  # pyright: ignore [reportAttributeAccessIssue]
             case _:
                 raise RuntimeError("Should not reach here.")
 
         logger.debug(
-            f"Response Token Count: {token_counter(text=out) if isinstance(out, str) else sum(token_counter(text=o) for o in out)}"  # pyright: ignore [reportOptionalIterable]
+            f"Response Token Count: {token_counter(text=out) if isinstance(out, str) else sum(token_counter(text=o) for o in out)}"
+            # pyright: ignore [reportOptionalIterable]
         )
         return out  # pyright: ignore [reportReturnType]
 
     @overload
     async def aask_validate[T](
-        self,
-        question: str,
-        validator: Callable[[str], T | None],
-        default: T = ...,
-        max_validations: PositiveInt = 2,
-        **kwargs: Unpack[GenerateKwargs],
-    ) -> T: ...
+            self,
+            question: str,
+            validator: Callable[[str], T | None],
+            default: T = ...,
+            max_validations: PositiveInt = 2,
+            **kwargs: Unpack[GenerateKwargs],
+    ) -> T:
+        ...
+
     @overload
     async def aask_validate[T](
-        self,
-        question: List[str],
-        validator: Callable[[str], T | None],
-        default: T = ...,
-        max_validations: PositiveInt = 2,
-        **kwargs: Unpack[GenerateKwargs],
-    ) -> List[T]: ...
+            self,
+            question: List[str],
+            validator: Callable[[str], T | None],
+            default: T = ...,
+            max_validations: PositiveInt = 2,
+            **kwargs: Unpack[GenerateKwargs],
+    ) -> List[T]:
+        ...
+
     @overload
     async def aask_validate[T](
-        self,
-        question: str,
-        validator: Callable[[str], T | None],
-        default: None = None,
-        max_validations: PositiveInt = 2,
-        **kwargs: Unpack[GenerateKwargs],
-    ) -> Optional[T]: ...
+            self,
+            question: str,
+            validator: Callable[[str], T | None],
+            default: None = None,
+            max_validations: PositiveInt = 2,
+            **kwargs: Unpack[GenerateKwargs],
+    ) -> Optional[T]:
+        ...
 
     @overload
     async def aask_validate[T](
-        self,
-        question: List[str],
-        validator: Callable[[str], T | None],
-        default: None = None,
-        max_validations: PositiveInt = 2,
-        **kwargs: Unpack[GenerateKwargs],
-    ) -> List[Optional[T]]: ...
+            self,
+            question: List[str],
+            validator: Callable[[str], T | None],
+            default: None = None,
+            max_validations: PositiveInt = 2,
+            **kwargs: Unpack[GenerateKwargs],
+    ) -> List[Optional[T]]:
+        ...
 
     async def aask_validate[T](
-        self,
-        question: str | List[str],
-        validator: Callable[[str], T | None],
-        default: Optional[T] = None,
-        max_validations: PositiveInt = 3,
-        **kwargs: Unpack[GenerateKwargs],
+            self,
+            question: str | List[str],
+            validator: Callable[[str], T | None],
+            default: Optional[T] = None,
+            max_validations: PositiveInt = 3,
+            **kwargs: Unpack[GenerateKwargs],
     ) -> Optional[T] | List[Optional[T]] | List[T] | T:
         """Asynchronously asks a question and validates the response using a given validator.
 
@@ -319,7 +325,7 @@ class LLMUsage(ScopedConfig):
         return await (gather(*[_inner(q) for q in question]) if isinstance(question, list) else _inner(question))
 
     async def alist_str(
-        self, requirement: str, k: NonNegativeInt = 0, **kwargs: Unpack[ValidateKwargs[List[str]]]
+            self, requirement: str, k: NonNegativeInt = 0, **kwargs: Unpack[ValidateKwargs[List[str]]]
     ) -> Optional[List[str]]:
         """Asynchronously generates a list of strings based on a given requirement.
 
@@ -333,7 +339,7 @@ class LLMUsage(ScopedConfig):
         """
         return await self.aask_validate(
             TEMPLATE_MANAGER.render_template(
-                configs.templates.liststr_template,
+                CONFIG.templates.liststr_template,
                 {"requirement": requirement, "k": k},
             ),
             lambda resp: JsonCapture.validate_with(resp, target_type=list, elements_type=str, length=k),
@@ -352,7 +358,7 @@ class LLMUsage(ScopedConfig):
         """
         return await self.alist_str(
             TEMPLATE_MANAGER.render_template(
-                configs.templates.pathstr_template,
+                CONFIG.templates.pathstr_template,
                 {"requirement": requirement},
             ),
             **kwargs,
@@ -369,9 +375,9 @@ class LLMUsage(ScopedConfig):
             Optional[str]: The validated response as a single string.
         """
         if paths := await self.apathstr(
-            requirement,
-            k=1,
-            **kwargs,
+                requirement,
+                k=1,
+                **kwargs,
         ):
             return paths.pop()
 
@@ -389,7 +395,7 @@ class LLMUsage(ScopedConfig):
         """
         return await self.aask_validate(  # pyright: ignore [reportReturnType]
             TEMPLATE_MANAGER.render_template(
-                configs.templates.generic_string_template,
+                CONFIG.templates.generic_string_template,
                 {"requirement": requirement, "language": GenericCapture.capture_type},
             ),
             validator=lambda resp: GenericCapture.capture(resp),
@@ -397,11 +403,11 @@ class LLMUsage(ScopedConfig):
         )
 
     async def achoose[T: WithBriefing](
-        self,
-        instruction: str,
-        choices: List[T],
-        k: NonNegativeInt = 0,
-        **kwargs: Unpack[ValidateKwargs[List[T]]],
+            self,
+            instruction: str,
+            choices: List[T],
+            k: NonNegativeInt = 0,
+            **kwargs: Unpack[ValidateKwargs[List[T]]],
     ) -> Optional[List[T]]:
         """Asynchronously executes a multi-choice decision-making process, generating a prompt based on the instruction and options, and validates the returned selection results.
 
@@ -418,7 +424,7 @@ class LLMUsage(ScopedConfig):
             logger.error(err := f"Redundant choices: {dup}")
             raise ValueError(err)
         prompt = TEMPLATE_MANAGER.render_template(
-            configs.templates.make_choice_template,
+            CONFIG.templates.make_choice_template,
             {
                 "instruction": instruction,
                 "options": [m.model_dump(include={"name", "briefing"}) for m in choices],
@@ -444,10 +450,10 @@ class LLMUsage(ScopedConfig):
         )
 
     async def apick[T: WithBriefing](
-        self,
-        instruction: str,
-        choices: List[T],
-        **kwargs: Unpack[ValidateKwargs[List[T]]],
+            self,
+            instruction: str,
+            choices: List[T],
+            **kwargs: Unpack[ValidateKwargs[List[T]]],
     ) -> T:
         """Asynchronously picks a single choice from a list of options using AI validation.
 
@@ -472,11 +478,11 @@ class LLMUsage(ScopedConfig):
         )[0]
 
     async def ajudge(
-        self,
-        prompt: str,
-        affirm_case: str = "",
-        deny_case: str = "",
-        **kwargs: Unpack[ValidateKwargs[bool]],
+            self,
+            prompt: str,
+            affirm_case: str = "",
+            deny_case: str = "",
+            **kwargs: Unpack[ValidateKwargs[bool]],
     ) -> Optional[bool]:
         """Asynchronously judges a prompt using AI validation.
 
@@ -491,7 +497,7 @@ class LLMUsage(ScopedConfig):
         """
         return await self.aask_validate(
             question=TEMPLATE_MANAGER.render_template(
-                configs.templates.make_judgment_template,
+                CONFIG.templates.make_judgment_template,
                 {"prompt": prompt, "affirm_case": affirm_case, "deny_case": deny_case},
             ),
             validator=lambda resp: JsonCapture.validate_with(resp, target_type=bool),
@@ -506,12 +512,12 @@ class EmbeddingUsage(LLMUsage):
     """
 
     async def aembedding(
-        self,
-        input_text: List[str],
-        model: Optional[str] = None,
-        dimensions: Optional[int] = None,
-        timeout: Optional[PositiveInt] = None,
-        caching: Optional[bool] = False,
+            self,
+            input_text: List[str],
+            model: Optional[str] = None,
+            dimensions: Optional[int] = None,
+            timeout: Optional[PositiveInt] = None,
+            caching: Optional[bool] = False,
     ) -> EmbeddingResponse:
         """Asynchronously generates embeddings for the given input text.
 
@@ -526,29 +532,29 @@ class EmbeddingUsage(LLMUsage):
             EmbeddingResponse: The response containing the embeddings.
         """
         # check seq length
-        max_len = self.embedding_max_sequence_length or configs.embedding.max_sequence_length
+        max_len = self.embedding_max_sequence_length or CONFIG.embedding.max_sequence_length
         if max_len and any(length := (token_counter(text=t)) > max_len for t in input_text):
             logger.error(err := f"Input text exceeds maximum sequence length {max_len}, got {length}.")
             raise ValueError(err)
 
         return await litellm.aembedding(
             input=input_text,
-            caching=caching or self.embedding_caching or configs.embedding.caching,
-            dimensions=dimensions or self.embedding_dimensions or configs.embedding.dimensions,
-            model=model or self.embedding_model or configs.embedding.model or self.llm_model or configs.llm.model,
+            caching=caching or self.embedding_caching or CONFIG.embedding.caching,
+            dimensions=dimensions or self.embedding_dimensions or CONFIG.embedding.dimensions,
+            model=model or self.embedding_model or CONFIG.embedding.model or self.llm_model or CONFIG.llm.model,
             timeout=timeout
-            or self.embedding_timeout
-            or configs.embedding.timeout
-            or self.llm_timeout
-            or configs.llm.timeout,
+                    or self.embedding_timeout
+                    or CONFIG.embedding.timeout
+                    or self.llm_timeout
+                    or CONFIG.llm.timeout,
             api_key=ok(
-                self.embedding_api_key or configs.embedding.api_key or self.llm_api_key or configs.llm.api_key
+                self.embedding_api_key or CONFIG.embedding.api_key or self.llm_api_key or CONFIG.llm.api_key
             ).get_secret_value(),
             api_base=ok(
                 self.embedding_api_endpoint
-                or configs.embedding.api_endpoint
+                or CONFIG.embedding.api_endpoint
                 or self.llm_api_endpoint
-                or configs.llm.api_endpoint
+                or CONFIG.llm.api_endpoint
             )
             .unicode_string()
             .rstrip("/"),
@@ -556,12 +562,15 @@ class EmbeddingUsage(LLMUsage):
         )
 
     @overload
-    async def vectorize(self, input_text: List[str], **kwargs: Unpack[EmbeddingKwargs]) -> List[List[float]]: ...
+    async def vectorize(self, input_text: List[str], **kwargs: Unpack[EmbeddingKwargs]) -> List[List[float]]:
+        ...
+
     @overload
-    async def vectorize(self, input_text: str, **kwargs: Unpack[EmbeddingKwargs]) -> List[float]: ...
+    async def vectorize(self, input_text: str, **kwargs: Unpack[EmbeddingKwargs]) -> List[float]:
+        ...
 
     async def vectorize(
-        self, input_text: List[str] | str, **kwargs: Unpack[EmbeddingKwargs]
+            self, input_text: List[str] | str, **kwargs: Unpack[EmbeddingKwargs]
     ) -> List[List[float]] | List[float]:
         """Asynchronously generates vector embeddings for the given input text.
 
@@ -597,9 +606,9 @@ class ToolBoxUsage(LLMUsage):
         return [toolbox.name for toolbox in self.toolboxes]
 
     async def choose_toolboxes(
-        self,
-        task: Task,
-        **kwargs: Unpack[ChooseKwargs[List[ToolBox]]],
+            self,
+            task: Task,
+            **kwargs: Unpack[ChooseKwargs[List[ToolBox]]],
     ) -> Optional[List[ToolBox]]:
         """Asynchronously executes a multi-choice decision-making process to choose toolboxes.
 
@@ -620,10 +629,10 @@ class ToolBoxUsage(LLMUsage):
         )
 
     async def choose_tools(
-        self,
-        task: Task,
-        toolbox: ToolBox,
-        **kwargs: Unpack[ChooseKwargs[List[Tool]]],
+            self,
+            task: Task,
+            toolbox: ToolBox,
+            **kwargs: Unpack[ChooseKwargs[List[Tool]]],
     ) -> Optional[List[Tool]]:
         """Asynchronously executes a multi-choice decision-making process to choose tools.
 
@@ -645,10 +654,10 @@ class ToolBoxUsage(LLMUsage):
         )
 
     async def gather_tools_fine_grind(
-        self,
-        task: Task,
-        box_choose_kwargs: Optional[ChooseKwargs] = None,
-        tool_choose_kwargs: Optional[ChooseKwargs] = None,
+            self,
+            task: Task,
+            box_choose_kwargs: Optional[ChooseKwargs] = None,
+            tool_choose_kwargs: Optional[ChooseKwargs] = None,
     ) -> List[Tool]:
         """Asynchronously gathers tools based on the provided task and toolbox and tool selection criteria.
 

fabricatio/parser.py

@@ -6,10 +6,10 @@ from re import Pattern, compile
 from typing import Any, Callable, Iterable, List, Optional, Self, Tuple, Type
 
 import ujson
+from fabricatio.rust import CONFIG
 from json_repair import repair_json
 from pydantic import BaseModel, ConfigDict, Field, PositiveInt, PrivateAttr, ValidationError
 
-from fabricatio.config import configs
 from fabricatio.journal import logger
 
 
@@ -46,7 +46,7 @@ class Capture(BaseModel):
             str | List[str]: The fixed text with the same type as input.
         """
         match self.capture_type:
-            case "json" if configs.general.use_json_repair:
+            case "json" if CONFIG.general.use_json_repair:
                 logger.debug("Applying json repair to text.")
                 if isinstance(text, str):
                     return repair_json(text, ensure_ascii=False)  # pyright: ignore [reportReturnType]