fabricatio 0.3.14.dev1__cp312-cp312-win_amd64.whl → 0.3.14.dev4__cp312-cp312-win_amd64.whl

fabricatio/models/role.py

@@ -1,20 +1,18 @@
 """Module that contains the Role class for managing workflows and their event registrations."""
+
 from functools import partial
 from typing import Any, Dict, Self
 
-from fabricatio.rust import Event
-from pydantic import ConfigDict, Field
-
-from fabricatio.core import env
+from fabricatio.emitter import env
 from fabricatio.journal import logger
 from fabricatio.models.action import WorkFlow
 from fabricatio.models.generic import WithBriefing
+from fabricatio.rust import Event
 from fabricatio.utils import is_subclass_of_base
+from pydantic import ConfigDict, Field
 
-is_toolbox_usage = partial(is_subclass_of_base, base_module="fabricatio.models.usages",
-                           base_name="ToolBoxUsage")
-is_scoped_config = partial(is_subclass_of_base, base_module="fabricatio.models.generic",
-                           base_name="ScopedConfig")
+is_toolbox_usage = partial(is_subclass_of_base, base_module="fabricatio.models.usages", base_name="ToolBoxUsage")
+is_scoped_config = partial(is_subclass_of_base, base_module="fabricatio.models.generic", base_name="ScopedConfig")
 
 
 class Role(WithBriefing):
@@ -23,7 +21,10 @@ class Role(WithBriefing):
     A Role serves as a container for workflows, managing their registration to events
     and providing them with shared configuration like tools and personality.
     """
+
     model_config = ConfigDict(use_attribute_docstrings=True, arbitrary_types_allowed=True)
+    name: str = ""
+    """The name of the role."""
     description: str = ""
     """A brief description of the role's responsibilities and capabilities."""
 
@@ -36,6 +37,8 @@ class Role(WithBriefing):
         Args:
             __context: The context used for initialization
         """
+        self.name = self.name or self.__class__.__name__
+
         self.resolve_configuration().register_workflows()
 
     def register_workflows(self) -> Self:
@@ -45,9 +48,7 @@ class Role(WithBriefing):
             Self: The role instance for method chaining
         """
         for event, workflow in self.registry.items():
-            logger.debug(
-                f"Registering workflow: `{workflow.name}` for event: `{event.collapse()}`"
-            )
+            logger.debug(f"Registering workflow: `{workflow.name}` for event: `{event.collapse()}`")
             env.on(event, workflow.serve)
         return self
 
@@ -67,7 +68,7 @@ class Role(WithBriefing):
             workflow.inject_personality(self.briefing)
         return self
 
-    def _configure_scoped_config(self, workflow) -> None:
+    def _configure_scoped_config(self, workflow: WorkFlow) -> None:
         """Configure scoped configuration for workflow and its actions."""
         if not is_scoped_config(self.__class__):
             return
@@ -80,7 +81,7 @@ class Role(WithBriefing):
         for action in (a for a in workflow.iter_actions() if is_scoped_config(a)):
             action.fallback_to(fallback_target)
 
-    def _configure_toolbox_usage(self, workflow) -> None:
+    def _configure_toolbox_usage(self, workflow: WorkFlow) -> None:
         """Configure toolbox usage for workflow and its actions."""
         if not is_toolbox_usage(self.__class__):
             return

fabricatio/models/task.py

@@ -6,12 +6,11 @@ It includes methods to manage the task's lifecycle, such as starting, finishing,
 from asyncio import Queue
 from typing import Any, Dict, List, Optional, Self, Union
 
-from fabricatio.rust import CONFIG, TEMPLATE_MANAGER, Event, TaskStatus
-from pydantic import Field, PrivateAttr
-
-from fabricatio.core import env
+from fabricatio.emitter import env
 from fabricatio.journal import logger
 from fabricatio.models.generic import ProposedAble, WithBriefing, WithDependency
+from fabricatio.rust import CONFIG, TEMPLATE_MANAGER, Event, TaskStatus
+from pydantic import Field, PrivateAttr
 
 type EventLike = Union[str, Event, List[str]]
 

fabricatio/models/tool.py

@@ -3,7 +3,6 @@
 This module provides classes for defining tools and toolboxes, which can be used to manage and execute callable functions
 with additional functionalities such as logging, execution info, and briefing.
 """
-
 from importlib.machinery import ModuleSpec
 from importlib.util import module_from_spec
 from inspect import iscoroutinefunction, signature
@@ -11,11 +10,11 @@ from types import CodeType, ModuleType
 from typing import Any, Callable, Dict, List, Optional, Self, cast, overload
 
 from fabricatio.rust import CONFIG
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import Field
 
 from fabricatio.decorators import logging_execution_info, use_temp_module
 from fabricatio.journal import logger
-from fabricatio.models.generic import WithBriefing
+from fabricatio.models.generic import Base, WithBriefing
 
 
 class Tool[**P, R](WithBriefing):
@@ -182,7 +181,7 @@ class ToolBox(WithBriefing):
         return hash(self.briefing)
 
 
-class ToolExecutor(BaseModel):
+class ToolExecutor(Base):
     """A class representing a tool executor with a sequence of tools to execute.
 
     This class manages a sequence of tools and provides methods to inject tools and data into a module, execute the tools,
@@ -192,7 +191,7 @@ class ToolExecutor(BaseModel):
         candidates (List[Tool]): The sequence of tools to execute.
         data (Dict[str, Any]): The data that could be used when invoking the tools.
     """
-    model_config = ConfigDict(use_attribute_docstrings=True)
+
     candidates: List[Tool] = Field(default_factory=list, frozen=True)
     """The sequence of tools to execute."""
 
@@ -230,7 +229,7 @@ class ToolExecutor(BaseModel):
             M: The module with injected data.
         """
         module = module or cast(
-            'M', module_from_spec(spec=ModuleSpec(name=CONFIG.toolbox.data_module_name, loader=None))
+            "M", module_from_spec(spec=ModuleSpec(name=CONFIG.toolbox.data_module_name, loader=None))
         )
         for key, value in self.data.items():
             logger.debug(f"Injecting data: {key}")

fabricatio/models/usages.py

@@ -1,13 +1,25 @@
 """This module contains classes that manage the usage of language models and tools in tasks."""
 
 import traceback
+from abc import ABC
 from asyncio import gather
 from typing import Callable, Dict, Iterable, List, Literal, Optional, Self, Sequence, Set, Union, Unpack, overload
 
 import asyncstdlib
-import litellm
+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.rust import CONFIG, TEMPLATE_MANAGER
-from litellm import RateLimitError, Router, stream_chunk_builder  # pyright: ignore [reportPrivateImportUsage]
+from fabricatio.utils import first_available, ok
+from litellm import (  # pyright: ignore [reportPrivateImportUsage]
+    RateLimitError,
+    Router,
+    aembedding,
+    stream_chunk_builder,
+)
 from litellm.types.router import Deployment, LiteLLM_Params, ModelInfo
 from litellm.types.utils import (
     Choices,
@@ -20,14 +32,6 @@ from litellm.utils import CustomStreamWrapper, token_counter  # pyright: ignore
 from more_itertools import duplicates_everseen
 from pydantic import BaseModel, ConfigDict, Field, NonNegativeInt, PositiveInt
 
-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.utils import first_available, ok
-
 ROUTER = Router(
     routing_strategy="usage-based-routing-v2",
     default_max_parallel_requests=CONFIG.routing.max_parallel_requests,
@@ -37,7 +41,7 @@ ROUTER = Router(
 )
 
 
-class LLMUsage(ScopedConfig):
+class LLMUsage(ScopedConfig, ABC):
     """Class that manages LLM (Large Language Model) usage parameters and methods.
 
     This class provides methods to deploy LLMs, query them for responses, and handle various configurations
@@ -58,10 +62,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.
 
@@ -108,28 +112,27 @@ class LLMUsage(ScopedConfig):
             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=first_available((kwargs.get("stream"), self.llm_stream, CONFIG.llm.stream),
-                                   "stream is not set at any place"),
+            stream=first_available(
+                (kwargs.get("stream"), self.llm_stream, CONFIG.llm.stream), "stream is not set at any place"
+            ),
             cache={
                 "no-cache": kwargs.get("no_cache"),
                 "no-store": kwargs.get("no_store"),
                 "cache-ttl": kwargs.get("cache_ttl"),
                 "s-maxage": kwargs.get("s_maxage"),
             },
-            presence_penalty=kwargs.get("presence_penalty")
-                             or self.llm_presence_penalty
-                             or CONFIG.llm.presence_penalty,
+            presence_penalty=kwargs.get("presence_penalty") or self.llm_presence_penalty or CONFIG.llm.presence_penalty,
             frequency_penalty=kwargs.get("frequency_penalty")
-                              or self.llm_frequency_penalty
-                              or CONFIG.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.
 
@@ -149,54 +152,49 @@ class LLMUsage(ScopedConfig):
         )
         if isinstance(resp, ModelResponse):
             return resp.choices
-        if isinstance(resp, CustomStreamWrapper):
-            if pack := stream_chunk_builder(await asyncstdlib.list(resp)):
-                return pack.choices
+        if isinstance(resp, CustomStreamWrapper) and (pack := stream_chunk_builder(await asyncstdlib.list(resp))):
+            return pack.choices
         logger.critical(err := f"Unexpected response type: {type(resp)}")
         raise ValueError(err)
 
     @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.
 
@@ -224,8 +222,7 @@ 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.")
 
@@ -237,55 +234,51 @@ class LLMUsage(ScopedConfig):
 
     @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.
 
@@ -325,7 +318,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.
 
@@ -377,9 +370,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()
 
@@ -407,11 +400,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.
 
@@ -456,10 +449,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.
 
@@ -484,11 +477,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.
 
@@ -513,19 +506,19 @@ class LLMUsage(ScopedConfig):
         )
 
 
-class EmbeddingUsage(LLMUsage):
+class EmbeddingUsage(LLMUsage, ABC):
     """A class representing the embedding model.
 
     This class extends LLMUsage and provides methods to generate embeddings for input text using various models.
     """
 
     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.
 
@@ -545,16 +538,16 @@ class EmbeddingUsage(LLMUsage):
             logger.error(err := f"Input text exceeds maximum sequence length {max_len}, got {length}.")
             raise ValueError(err)
 
-        return await litellm.aembedding(
+        return await aembedding(
             input=input_text,
             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 CONFIG.embedding.timeout
-                    or self.llm_timeout
-                    or CONFIG.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 CONFIG.embedding.api_key or self.llm_api_key or CONFIG.llm.api_key
             ).get_secret_value(),
@@ -563,21 +556,18 @@ class EmbeddingUsage(LLMUsage):
                 or CONFIG.embedding.api_endpoint
                 or self.llm_api_endpoint
                 or CONFIG.llm.api_endpoint
-            )
-            .rstrip("/"),
+            ).rstrip("/"),
             # seems embedding function takes no base_url end with a slash
         )
 
     @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.
 
@@ -594,7 +584,7 @@ class EmbeddingUsage(LLMUsage):
         return [o.get("embedding") for o in (await self.aembedding(input_text, **kwargs)).data]
 
 
-class ToolBoxUsage(LLMUsage):
+class ToolBoxUsage(LLMUsage, ABC):
     """A class representing the usage of tools in a task.
 
     This class extends LLMUsage and provides methods to manage and use toolboxes and tools within tasks.
@@ -613,9 +603,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.
 
@@ -636,10 +626,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.
 
@@ -661,10 +651,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.