fabricatio 0.2.4.dev2__cp312-cp312-win_amd64.whl → 0.2.5__cp312-cp312-win_amd64.whl

fabricatio/models/kwargs_types.py

@@ -1,59 +1,147 @@
 """This module contains the types for the keyword arguments of the methods in the models module."""
 
-from typing import List, NotRequired, TypedDict
+from typing import Any, TypedDict
 
-from pydantic import NonNegativeFloat, NonNegativeInt, PositiveInt
+from litellm.caching.caching import CacheMode
+from litellm.types.caching import CachingSupportedCallTypes
 
 
-class CollectionSimpleConfigKwargs(TypedDict):
-    """A type representing the configuration for a collection."""
+class CollectionSimpleConfigKwargs(TypedDict, total=False):
+    """Configuration parameters for a vector collection.
 
-    dimension: NotRequired[int]
-    timeout: NotRequired[float]
+    These arguments are typically used when configuring connections to vector databases.
+    """
 
+    dimension: int|None
+    timeout: float
 
-class FetchKwargs(TypedDict):
-    """A type representing the keyword arguments for the fetch method."""
 
-    similarity_threshold: NotRequired[float]
-    result_per_query: NotRequired[int]
+class FetchKwargs(TypedDict, total=False):
+    """Arguments for fetching data from vector collections.
 
+    Controls how data is retrieved from vector databases, including filtering
+    and result limiting parameters.
+    """
 
-class EmbeddingKwargs(TypedDict):
-    """A type representing the keyword arguments for the embedding method."""
+    collection_name: str|None
+    similarity_threshold: float
+    result_per_query: int
 
-    model: NotRequired[str]
-    dimensions: NotRequired[int]
-    timeout: NotRequired[PositiveInt]
-    caching: NotRequired[bool]
 
+class EmbeddingKwargs(TypedDict, total=False):
+    """Configuration parameters for text embedding operations.
 
-class LLMKwargs(TypedDict):
-    """A type representing the keyword arguments for the LLM (Large Language Model) usage."""
+    These settings control the behavior of embedding models that convert text
+    to vector representations.
+    """
 
-    model: NotRequired[str]
-    temperature: NotRequired[NonNegativeFloat]
-    stop: NotRequired[str | List[str]]
-    top_p: NotRequired[NonNegativeFloat]
-    max_tokens: NotRequired[PositiveInt]
-    stream: NotRequired[bool]
-    timeout: NotRequired[PositiveInt]
-    max_retries: NotRequired[PositiveInt]
+    model: str
+    dimensions: int
+    timeout: int
+    caching: bool
 
 
-class ValidateKwargs(LLMKwargs):
-    """A type representing the keyword arguments for the validate method."""
+class LLMKwargs(TypedDict, total=False):
+    """Configuration parameters for language model inference.
 
-    max_validations: NotRequired[PositiveInt]
+    These arguments control the behavior of large language model calls,
+    including generation parameters and caching options.
+    """
 
+    model: str
+    temperature: float
+    stop: str | list[str]
+    top_p: float
+    max_tokens: int
+    stream: bool
+    timeout: int
+    max_retries: int
+    no_cache: bool  # if the req uses cache in this call
+    no_store: bool  # If store the response of this call to cache
+    cache_ttl: int  # how long the stored cache is alive, in seconds
+    s_maxage: int  # max accepted age of cached response, in seconds
 
-class GenerateKwargs(ValidateKwargs):
-    """A type representing the keyword arguments for the generate method."""
 
-    system_message: NotRequired[str]
+class GenerateKwargs(LLMKwargs, total=False):
+    """Arguments for content generation operations.
 
+    Extends LLMKwargs with additional parameters specific to generation tasks,
+    such as the number of generated items and the system message.
+    """
 
-class ChooseKwargs(GenerateKwargs):
-    """A type representing the keyword arguments for the choose method."""
+    system_message: str
 
-    k: NotRequired[NonNegativeInt]
+
+class ValidateKwargs[T](GenerateKwargs, total=False):
+    """Arguments for content validation operations.
+
+    Extends LLMKwargs with additional parameters specific to validation tasks,
+    such as limiting the number of validation attempts.
+    """
+
+    default: T
+    max_validations: int
+
+
+# noinspection PyTypedDict
+class ReviewKwargs[T](ValidateKwargs[T], total=False):
+    """Arguments for content review operations.
+
+    Extends GenerateKwargs with parameters for evaluating content against
+    specific topics and review criteria.
+    """
+
+    topic: str
+    criteria: set[str]
+
+
+# noinspection PyTypedDict
+class ChooseKwargs[T](ValidateKwargs[T], total=False):
+    """Arguments for selection operations.
+
+    Extends GenerateKwargs with parameters for selecting among options,
+    such as the number of items to choose.
+    """
+
+    k: int
+
+
+class CacheKwargs(TypedDict, total=False):
+    """Configuration parameters for the caching system.
+
+    These arguments control the behavior of various caching backends,
+    including in-memory, Redis, S3, and vector database caching options.
+    """
+
+    mode: CacheMode  # when default_on cache is always on, when default_off cache is opt in
+    host: str
+    port: str
+    password: str
+    namespace: str
+    ttl: float
+    default_in_memory_ttl: float
+    default_in_redis_ttl: float
+    similarity_threshold: float
+    supported_call_types: list[CachingSupportedCallTypes]
+    # s3 Bucket, boto3 configuration
+    s3_bucket_name: str
+    s3_region_name: str
+    s3_api_version: str
+    s3_use_ssl: bool
+    s3_verify: bool | str
+    s3_endpoint_url: str
+    s3_aws_access_key_id: str
+    s3_aws_secret_access_key: str
+    s3_aws_session_token: str
+    s3_config: Any
+    s3_path: str
+    redis_semantic_cache_use_async: bool
+    redis_semantic_cache_embedding_model: str
+    redis_flush_size: int
+    redis_startup_nodes: list
+    disk_cache_dir: Any
+    qdrant_api_base: str
+    qdrant_api_key: str
+    qdrant_collection_name: str
+    qdrant_quantization_config: str
+    qdrant_semantic_cache_embedding_model: str

fabricatio/models/role.py

@@ -2,7 +2,7 @@
 
 from typing import Any, Self, Set
 
-from fabricatio.capabilities.rating import GiveRating
+from fabricatio.capabilities.review import Review
 from fabricatio.capabilities.task import HandleTask, ProposeTask
 from fabricatio.core import env
 from fabricatio.journal import logger
@@ -12,10 +12,10 @@ from fabricatio.models.tool import ToolBox
 from pydantic import Field
 
 
-class Role(ProposeTask, HandleTask, GiveRating):
+class Role(ProposeTask, HandleTask, Review):
     """Class that represents a role with a registry of events and workflows."""
 
-    registry: dict[Event | str, WorkFlow] = Field(...)
+    registry: dict[Event | str, WorkFlow] = Field(default_factory=dict)
     """ The registry of events and workflows."""
 
     toolboxes: Set[ToolBox] = Field(default_factory=set)

fabricatio/models/task.py

@@ -83,20 +83,6 @@ class Task[T](WithBriefing, ProposedAble, WithDependency):
         self.namespace = self._namespace.segments
         return self
 
-    @classmethod
-    def simple_task(cls, name: str, goal: List[str], description: str) -> Self:
-        """Create a simple task with a name, goal, and description.
-
-        Args:
-            name (str): The name of the task.
-            goal (List[str]): The goal of the task.
-            description (str): The description of the task.
-
-        Returns:
-            Task: A new instance of the `Task` class.
-        """
-        return cls(name=name, goals=goal, description=description)
-
     def update_task(self, goal: Optional[List[str] | str] = None, description: Optional[str] = None) -> Self:
         """Update the goal and description of the task.
 

fabricatio/models/tool.py

@@ -4,10 +4,10 @@ from importlib.machinery import ModuleSpec
 from importlib.util import module_from_spec
 from inspect import iscoroutinefunction, signature
 from types import CodeType, ModuleType
-from typing import Any, Callable, Dict, List, Optional, Self, overload
+from typing import Any, Callable, Dict, List, Optional, Self, cast, overload
 
 from fabricatio.config import configs
-from fabricatio.decorators import use_temp_module
+from fabricatio.decorators import logging_execution_info, use_temp_module
 from fabricatio.journal import logger
 from fabricatio.models.generic import WithBriefing
 from pydantic import BaseModel, ConfigDict, Field
@@ -31,6 +31,7 @@ class Tool[**P, R](WithBriefing):
 
         if not self.name:
             raise RuntimeError("The tool must have a source function.")
+
         self.description = self.description or self.source.__doc__ or ""
         self.description = self.description.strip()
 
@@ -84,7 +85,7 @@ class ToolBox(WithBriefing):
         Returns:
             Self: The current instance of the toolbox.
         """
-        self.tools.append(Tool(source=func))
+        self.collect_tool(logging_execution_info(func))
         return self
 
     @property
@@ -135,7 +136,7 @@ class ToolExecutor(BaseModel):
 
     def inject_tools[M: ModuleType](self, module: Optional[M] = None) -> M:
         """Inject the tools into the provided module or default."""
-        module = module or module_from_spec(spec=ModuleSpec(name=configs.toolbox.tool_module_name, loader=None))
+        module = module or cast(M, module_from_spec(spec=ModuleSpec(name=configs.toolbox.tool_module_name, loader=None)))
         for tool in self.candidates:
             logger.debug(f"Injecting tool: {tool.name}")
             setattr(module, tool.name, tool.invoke)
@@ -143,7 +144,7 @@ class ToolExecutor(BaseModel):
 
     def inject_data[M: ModuleType](self, module: Optional[M] = None) -> M:
         """Inject the data into the provided module or default."""
-        module = module or module_from_spec(spec=ModuleSpec(name=configs.toolbox.data_module_name, loader=None))
+        module = module or cast(M,module_from_spec(spec=ModuleSpec(name=configs.toolbox.data_module_name, loader=None)))
         for key, value in self.data.items():
             logger.debug(f"Injecting data: {key}")
             setattr(module, key, value)
@@ -183,6 +184,6 @@ class ToolExecutor(BaseModel):
         tools = []
         while tool_name := recipe.pop(0):
             for toolbox in toolboxes:
-                tools.append(toolbox[tool_name])
+                tools.append(toolbox.get(tool_name))
 
         return cls(candidates=tools)