fabricatio 0.2.13.dev3__cp312-cp312-win_amd64.whl → 0.3.14.dev0__cp312-cp312-win_amd64.whl

fabricatio/models/generic.py

@@ -6,14 +6,7 @@ from pathlib import Path
 from typing import Any, Callable, Dict, Iterable, List, Mapping, Optional, Self, Type, Union, final, overload
 
 import ujson
-from fabricatio.config import configs
-from fabricatio.fs.readers import safe_text_read
-from fabricatio.journal import logger
-from fabricatio.parser import JsonCapture
-from fabricatio.rust import blake3_hash, detect_language
-from fabricatio.rust_instances import TEMPLATE_MANAGER
-from fabricatio.utils import ok
-from litellm.utils import token_counter
+from fabricatio.rust import CONFIG, TEMPLATE_MANAGER, blake3_hash, detect_language
 from pydantic import (
     BaseModel,
     ConfigDict,
@@ -27,6 +20,12 @@ from pydantic import (
 )
 from pydantic.json_schema import GenerateJsonSchema, JsonSchemaValue
 
+from fabricatio.fs import dump_text
+from fabricatio.fs.readers import safe_text_read
+from fabricatio.journal import logger
+from fabricatio.parser import JsonCapture
+from fabricatio.utils import ok
+
 
 class Base(BaseModel):
     """Base class for all models with Pydantic configuration.
@@ -74,9 +73,9 @@ class Display(Base):
             str: Combined display output with boundary markers
         """
         return (
-            "--- Start of Extra Info Sequence ---"
-            + "\n".join(d.compact() if compact else d.display() for d in seq)
-            + "--- End of Extra Info Sequence ---"
+                "--- Start of Extra Info Sequence ---"
+                + "\n".join(d.compact() if compact else d.display() for d in seq)
+                + "--- End of Extra Info Sequence ---"
         )
 
 
@@ -117,7 +116,7 @@ class WordCount(Base):
     """Expected word count of this research component."""
 
 
-class FromMapping(Base):
+class FromMapping:
     """Class that provides a method to generate a list of objects from a mapping."""
 
     @classmethod
@@ -126,7 +125,7 @@ class FromMapping(Base):
         """Generate a list of objects from a mapping."""
 
 
-class AsPrompt(Base):
+class AsPrompt:
     """Class that provides a method to generate a prompt from the model.
 
     This class includes a method to generate a prompt based on the model's attributes.
@@ -140,7 +139,7 @@ class AsPrompt(Base):
             str: The generated prompt.
         """
         return TEMPLATE_MANAGER.render_template(
-            configs.templates.as_prompt_template,
+            CONFIG.templates.as_prompt_template,
             self._as_prompt_inner(),
         )
 
@@ -178,13 +177,16 @@ class WithRef[T](Base):
         )
 
     @overload
-    def update_ref[S: WithRef](self: S, reference: T) -> S: ...
+    def update_ref[S: WithRef](self: S, reference: T) -> S:
+        ...
 
     @overload
-    def update_ref[S: WithRef](self: S, reference: "WithRef[T]") -> S: ...
+    def update_ref[S: WithRef](self: S, reference: "WithRef[T]") -> S:
+        ...
 
     @overload
-    def update_ref[S: WithRef](self: S, reference: None = None) -> S: ...
+    def update_ref[S: WithRef](self: S, reference: None = None) -> S:
+        ...
 
     def update_ref[S: WithRef](self: S, reference: Union[T, "WithRef[T]", None] = None) -> S:
         """Update the reference of the object.
@@ -201,19 +203,6 @@ class WithRef[T](Base):
             self._reference = reference  # pyright: ignore [reportAttributeAccessIssue]
         return self
 
-    def derive[S: WithRef](self: S, reference: Any) -> S:
-        """Derive a new object from the current object.
-
-        Args:
-            reference (Any): The reference for the new object.
-
-        Returns:
-            S: A new instance derived from the current object with the provided reference.
-        """
-        new = self.model_copy()
-        new._reference = reference
-        return new
-
 
 class PersistentAble(Base):
     """Class providing file persistence capabilities.
@@ -306,7 +295,7 @@ class PersistentAble(Base):
         return cls.model_validate_json(safe_text_read(path))
 
 
-class Language(Base):
+class Language:
     """Class that provides a language attribute."""
 
     @property
@@ -318,8 +307,7 @@ class Language(Base):
             return detect_language(self.title)
         if isinstance(self, Named) and self.name:
             return detect_language(self.name)
-
-        return detect_language(self.model_dump_json(by_alias=True))
+        raise RuntimeError(f"Cannot determine language! class that not support language: {self.__class__.__name__}")
 
 
 class ModelHash(Base):
@@ -337,7 +325,7 @@ class ModelHash(Base):
         return hash(self.model_dump_json())
 
 
-class UpdateFrom(Base):
+class UpdateFrom:
     """Class that provides a method to update the object from another object.
 
     This class includes methods to update the current object with the attributes of another object.
@@ -386,25 +374,7 @@ class UpdateFrom(Base):
         return self.update_pre_check(other).update_from_inner(other)
 
 
-class ResolveUpdateConflict(Base):
-    """Class that provides a method to update the object from another object.
-
-    This class includes a method to resolve conflicts when updating the object from another object.
-    """
-
-    @abstractmethod
-    def resolve_update_conflict(self, other: Self) -> str:
-        """Resolve the update conflict between two objects.
-
-        Args:
-            other (Self): The other object to resolve the update conflict with.
-
-        Returns:
-            str: The resolved update conflict.
-        """
-
-
-class Introspect(Base):
+class Introspect:
     """Class that provides a method to introspect the object.
 
     This class includes a method to perform internal introspection of the object.
@@ -498,12 +468,12 @@ class CreateJsonObjPrompt(WithFormatedJsonSchema):
         """
         if isinstance(requirement, str):
             return TEMPLATE_MANAGER.render_template(
-                configs.templates.create_json_obj_template,
+                CONFIG.templates.create_json_obj_template,
                 {"requirement": requirement, "json_schema": cls.formated_json_schema()},
             )
         return [
             TEMPLATE_MANAGER.render_template(
-                configs.templates.create_json_obj_template,
+                CONFIG.templates.create_json_obj_template,
                 {"requirement": r, "json_schema": cls.formated_json_schema()},
             )
             for r in requirement
@@ -575,7 +545,7 @@ class FinalizedDumpAble(Base):
         Returns:
             Self: The current instance of the object.
         """
-        Path(path).write_text(self.finalized_dump(), encoding="utf-8")
+        dump_text(path, self.finalized_dump())
         return self
 
 
@@ -655,7 +625,7 @@ class WithDependency(Base):
         from fabricatio.fs import MAGIKA
 
         return TEMPLATE_MANAGER.render_template(
-            configs.templates.dependencies_template,
+            CONFIG.templates.dependencies_template,
             {
                 (pth := Path(p)).name: {
                     "path": pth.as_posix(),
@@ -672,7 +642,7 @@ class WithDependency(Base):
         )
 
 
-class Vectorizable(Base):
+class Vectorizable:
     """Class that prepares the vectorization of the model.
 
     This class includes methods to prepare the model for vectorization, ensuring it fits within a specified token length.
@@ -695,7 +665,9 @@ class Vectorizable(Base):
         Raises:
             ValueError: If the chunk exceeds the maximum sequence length.
         """
-        max_length = max_length or configs.embedding.max_sequence_length
+        from litellm.utils import token_counter
+
+        max_length = max_length or CONFIG.embedding.max_sequence_length
         chunk = self._prepare_vectorization_inner()
         if max_length and (length := token_counter(text=chunk)) > max_length:
             raise ValueError(f"Chunk exceeds maximum sequence length {max_length}, got {length}, see \n{chunk}")
@@ -883,7 +855,8 @@ class Patch[T](ProposedAble):
             # copy the desc info of each corresponding fields from `ref_cls`
             for field_name in [f for f in cls.model_fields if f in ref_cls.model_fields]:
                 my_schema["properties"][field_name]["description"] = (
-                    ref_cls.model_fields[field_name].description or my_schema["properties"][field_name]["description"]
+                        ref_cls.model_fields[field_name].description or my_schema["properties"][field_name][
+                    "description"]
                 )
             my_schema["description"] = ref_cls.__doc__
 

fabricatio/models/kwargs_types.py

@@ -1,9 +1,6 @@
 """This module contains the types for the keyword arguments of the methods in the models module."""
 
-from typing import Any, Dict, List, Literal, NotRequired, Optional, Required, TypedDict
-
-from litellm.caching.caching import CacheMode
-from litellm.types.caching import CachingSupportedCallTypes
+from typing import Dict, List, Literal, NotRequired, Optional, Required, TypedDict
 
 
 class ChunkKwargs(TypedDict):
@@ -70,7 +67,6 @@ class ValidateKwargs[T](GenerateKwargs, total=False):
     max_validations: int
 
 
-
 class CompositeScoreKwargs(ValidateKwargs[List[Dict[str, float]]], total=False):
     """Arguments for composite score generation operations.
 
@@ -125,47 +121,6 @@ class ChooseKwargs[T](ValidateKwargs[T], total=False):
     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
-
-
 class RerankOptions(TypedDict, total=False):
     """Optional keyword arguments for the rerank method."""
 

fabricatio/models/role.py

@@ -1,38 +1,35 @@
 """Module that contains the Role class for managing workflows and their event registrations."""
+from functools import partial
+from typing import Any, Self, Dict
 
-from typing import Any, Self, Set
+from fabricatio.rust import Event
+from pydantic import Field, ConfigDict
 
-from fabricatio.capabilities.propose import Propose
 from fabricatio.core import env
 from fabricatio.journal import logger
 from fabricatio.models.action import WorkFlow
-from fabricatio.models.events import Event
 from fabricatio.models.generic import WithBriefing
-from fabricatio.models.tool import ToolBox
-from fabricatio.models.usages import ToolBoxUsage
-from pydantic import Field
+from fabricatio.utils import is_subclass_of_base
 
+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, Propose, ToolBoxUsage):
+
+class Role(WithBriefing):
     """Class that represents a role with a registry of events and workflows.
 
     A Role serves as a container for workflows, managing their registration to events
     and providing them with shared configuration like tools and personality.
-
-    Attributes:
-        registry: Mapping of events to workflows that handle them
-        toolboxes: Set of toolboxes available to this role and its workflows
     """
-
+    model_config = ConfigDict(use_attribute_docstrings=True, arbitrary_types_allowed=True)
     description: str = ""
     """A brief description of the role's responsibilities and capabilities."""
 
-    registry: dict[Event | str, WorkFlow] = Field(default_factory=dict)
+    registry: Dict[Event, WorkFlow] = Field(default_factory=dict)
     """The registry of events and workflows."""
 
-    toolboxes: Set[ToolBox] = Field(default_factory=set)
-    """Collection of tools available to this role."""
-
     def model_post_init(self, __context: Any) -> None:
         """Initialize the role by resolving configurations and registering workflows.
 
@@ -49,7 +46,7 @@ class Role(WithBriefing, Propose, ToolBoxUsage):
         """
         for event, workflow in self.registry.items():
             logger.debug(
-                f"Registering workflow: `{workflow.name}` for event: `{Event.instantiate_from(event).collapse()}`"
+                f"Registering workflow: `{workflow.name}` for event: `{event.collapse()}`"
             )
             env.on(event, workflow.serve)
         return self
@@ -65,12 +62,35 @@ class Role(WithBriefing, Propose, ToolBoxUsage):
         """
         for workflow in self.registry.values():
             logger.debug(f"Resolving config for workflow: `{workflow.name}`")
-            (
-                workflow.fallback_to(self)
-                .steps_fallback_to_self()
-                .inject_personality(self.briefing)
-                .supply_tools_from(self)
-                .steps_supply_tools_from_self()
-            )
-
+            self._configure_scoped_config(workflow)
+            self._configure_toolbox_usage(workflow)
+            workflow.inject_personality(self.briefing)
         return self
+
+    def _configure_scoped_config(self, workflow) -> None:
+        """Configure scoped configuration for workflow and its actions."""
+
+        if not is_scoped_config(self.__class__):
+            return
+
+        fallback_target = self
+        if is_scoped_config(workflow):
+            workflow.fallback_to(self)
+            fallback_target = workflow
+
+        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:
+        """Configure toolbox usage for workflow and its actions."""
+
+        if not is_toolbox_usage(self.__class__):
+            return
+
+        supply_target = self
+        if is_toolbox_usage(workflow):
+            workflow.supply_tools_from(self)
+            supply_target = workflow
+
+        for action in (a for a in workflow.iter_actions() if is_toolbox_usage(a)):
+            action.supply_tools_from(supply_target)

fabricatio/models/task.py

@@ -4,16 +4,16 @@ 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
+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.config import configs
-from fabricatio.constants import TaskStatus
 from fabricatio.core import env
 from fabricatio.journal import logger
-from fabricatio.models.events import Event, EventLike
 from fabricatio.models.generic import ProposedAble, WithBriefing, WithDependency
-from fabricatio.rust_instances import TEMPLATE_MANAGER
-from pydantic import Field, PrivateAttr
+
+type EventLike = Union[str, Event, List[str]]
 
 
 class Task[T](WithBriefing, ProposedAble, WithDependency):
@@ -33,7 +33,7 @@ class Task[T](WithBriefing, ProposedAble, WithDependency):
     description: str = Field(default="")
     """A detailed explanation of the task that includes all necessary information. Should be clear and answer what, why, when, where, who, and how questions."""
 
-    goals: List[str] = Field(default=[])
+    goals: List[str] = Field(default_factory=list)
     """A list of objectives that the task aims to accomplish. Each goal should be clear and specific. Complex tasks should be broken into multiple smaller goals."""
 
     namespace: List[str] = Field(default_factory=list)
@@ -65,7 +65,7 @@ class Task[T](WithBriefing, ProposedAble, WithDependency):
 
     def model_post_init(self, __context: Any) -> None:
         """Initialize the task with a namespace event."""
-        self._namespace.segments.extend(self.namespace)
+        self._namespace.concat(self.namespace)
 
     def move_to(self, new_namespace: EventLike) -> Self:
         """Move the task to a new namespace.
@@ -266,7 +266,7 @@ class Task[T](WithBriefing, ProposedAble, WithDependency):
             str: The briefing of the task.
         """
         return TEMPLATE_MANAGER.render_template(
-            configs.templates.task_briefing_template,
+            CONFIG.templates.task_briefing_template,
             self.model_dump(),
         )
 

fabricatio/models/tool.py

@@ -10,11 +10,12 @@ from inspect import iscoroutinefunction, signature
 from types import CodeType, ModuleType
 from typing import Any, Callable, Dict, List, Optional, Self, cast, overload
 
-from fabricatio.config import configs
+from fabricatio.rust import CONFIG
+from pydantic import BaseModel, ConfigDict, Field
+
 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
 
 
 class Tool[**P, R](WithBriefing):
@@ -210,7 +211,7 @@ class ToolExecutor(BaseModel):
             M: The module with injected tools.
         """
         module = module or cast(
-            "M", module_from_spec(spec=ModuleSpec(name=configs.toolbox.tool_module_name, loader=None))
+            "M", module_from_spec(spec=ModuleSpec(name=CONFIG.toolbox.tool_module_name, loader=None))
         )
         for tool in self.candidates:
             logger.debug(f"Injecting tool: {tool.name}")
@@ -229,7 +230,7 @@ class ToolExecutor(BaseModel):
             M: The module with injected data.
         """
         module = module or cast(
-            'M', module_from_spec(spec=ModuleSpec(name=configs.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}")