fabricatio 0.2.5.dev4__cp312-cp312-win_amd64.whl → 0.2.6.dev0__cp312-cp312-win_amd64.whl

fabricatio/journal.py

@@ -18,6 +18,7 @@ logger.add(
 )
 logger.add(sys.stderr, level=configs.debug.log_level)
 
+__all__ = ["logger"]
 if __name__ == "__main__":
     logger.debug("This is a trace message.")
     logger.info("This is an information message.")

fabricatio/models/action.py

@@ -3,7 +3,7 @@
 import traceback
 from abc import abstractmethod
 from asyncio import Queue, create_task
-from typing import Any, Dict, Self, Tuple, Type, Union, Unpack, final
+from typing import Any, Dict, Self, Tuple, Type, Union, final
 
 from fabricatio.capabilities.review import Review
 from fabricatio.capabilities.task import HandleTask, ProposeTask
@@ -37,7 +37,7 @@ class Action(HandleTask, ProposeTask, Review):
         self.description = self.description or self.__class__.__doc__ or ""
 
     @abstractmethod
-    async def _execute(self, **cxt: Unpack) -> Any:
+    async def _execute(self, **cxt) -> Any:
         """Execute the action with the provided arguments.
 
         Args:
@@ -75,7 +75,7 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
     _context: Queue[Dict[str, Any]] = PrivateAttr(default_factory=lambda: Queue(maxsize=1))
     """ The context dictionary to be used for workflow execution."""
 
-    _instances: Tuple[Action, ...] = PrivateAttr(...)
+    _instances: Tuple[Action, ...] = PrivateAttr(default_factory=tuple)
     """ The instances of the workflow steps."""
 
     steps: Tuple[Union[Type[Action], Action], ...] = Field(...)

fabricatio/models/events.py

@@ -18,7 +18,7 @@ class Event(BaseModel):
     """ The segments of the namespaces."""
 
     @classmethod
-    def instantiate_from(cls, event: EventLike) -> Self:
+    def instantiate_from(cls, event: EventLike) -> "Event":
         """Create an Event instance from a string or list of strings or an Event instance.
 
         Args:
@@ -35,7 +35,7 @@ class Event(BaseModel):
         return cls(segments=event)
 
     @classmethod
-    def quick_instantiate(cls, event: EventLike) -> Self:
+    def quick_instantiate(cls, event: EventLike) -> "Event":
         """Create an Event instance from a string or list of strings or an Event instance and push a wildcard and pending segment.
 
         Args:
@@ -59,7 +59,7 @@ class Event(BaseModel):
 
     def clone(self) -> Self:
         """Clone the event."""
-        return Event(segments=list(self.segments))
+        return self.__class__(segments=list(self.segments))
 
     def push(self, segment: str) -> Self:
         """Push a segment to the event."""
@@ -113,6 +113,8 @@ class Event(BaseModel):
         """Return the hash of the event, using the collapsed string."""
         return hash(self.collapse())
 
-    def __eq__(self, other: str | List[str] | Self) -> bool:
+    def __eq__(self, other: object) -> bool:
         """Check if the event is equal to another event or a string."""
+        if not isinstance(other, (str , list , Event)):
+            return False
         return self.collapse() == Event.instantiate_from(other).collapse()

fabricatio/models/extra.py

@@ -9,23 +9,23 @@ from pydantic import Field
 class Equation(Base):
     """Structured representation of mathematical equations (including their physical or conceptual meanings)."""
 
-    description: str = Field(...)
+    description: str
     """A concise explanation of the equation's meaning, purpose, and relevance in the context of the research."""
 
-    latex_code: str = Field(...)
+    latex_code: str
     """The LaTeX code used to represent the equation in a publication-ready format."""
 
 
 class Figure(Base):
     """Structured representation of figures (including their academic significance and explanatory captions)."""
 
-    description: str = Field(...)
+    description: str
     """A detailed explanation of the figure's content and its role in conveying key insights."""
 
-    figure_caption: str = Field(...)
+    figure_caption: str
     """The caption accompanying the figure, summarizing its main points and academic value."""
 
-    figure_path: str = Field(...)
+    figure_path: str
     """The file path to the figure"""
 
 
@@ -34,7 +34,7 @@ class Highlightings(Base):
 
     # Academic Achievements Showcase
     highlighted_equations: List[Equation] = Field(default_factory=list)
-    """Core mathematical equations that represent breakthroughs in the field, accompanied by explanations of their physical or conceptual significance."""
+    """Core mathematical equations that represent breakthroughs in the field, accompanied by explanations of their physical or conceptual significance,Should always be in LaTeX format wrapped in $ or $$ signs."""
 
     highlighted_algorithms: List[str] = Field(default_factory=list)
     """Pseudocode for key algorithms, annotated to highlight innovative components."""
@@ -53,39 +53,42 @@ class ArticleEssence(ProposedAble, Display, PrepareVectorization):
     title: str = Field(...)
     """The full title of the paper, including any subtitles if applicable."""
 
-    authors: List[str] = Field(default_factory=list)
+    authors: List[str]
     """A list of the paper's authors, typically in the order of contribution."""
 
-    keywords: List[str] = Field(default_factory=list)
+    keywords: List[str]
     """A list of keywords that summarize the paper's focus and facilitate indexing."""
 
-    publication_year: int = Field(None)
+    publication_year: int
     """The year in which the paper was published."""
 
     # Core Content Elements
-    domain: List[str] = Field(default_factory=list)
+    highlightings: Highlightings = Field(default_factory=Highlightings)
+    """A collection of highlighted elements in the paper, including equations, algorithms, figures, and tables."""
+
+    domain: List[str]
     """The research domains or fields addressed by the paper (e.g., ['Natural Language Processing', 'Computer Vision'])."""
 
     abstract: str = Field(...)
     """A structured abstract that outlines the research problem, methodology, and conclusions in three distinct sections."""
 
-    core_contributions: List[str] = Field(default_factory=list)
+    core_contributions: List[str]
     """Key academic contributions that distinguish the paper from prior work in the field."""
 
-    technical_novelty: List[str] = Field(default_factory=list)
+    technical_novelty: List[str]
     """Specific technical innovations introduced by the research, listed as individual points."""
 
     # Academic Discussion Dimensions
-    research_problem: str = Field("")
+    research_problems: List[str]
     """A clearly defined research question or problem addressed by the study."""
 
-    limitations: List[str] = Field(default_factory=list)
+    limitations: List[str]
     """An analysis of the methodological or experimental limitations of the research."""
 
-    future_work: List[str] = Field(default_factory=list)
+    future_work: List[str]
     """Suggestions for potential directions or topics for follow-up studies."""
 
-    impact_analysis: str = Field("")
+    impact_analysis: List[str]
     """An assessment of the paper's potential influence on the development of the field."""
 
     def _prepare_vectorization_inner(self) -> str:

fabricatio/models/generic.py

@@ -2,7 +2,7 @@
 
 from abc import abstractmethod
 from pathlib import Path
-from typing import Callable, Iterable, List, Optional, Self, Union, final
+from typing import Any, Callable, Dict, Iterable, List, Optional, Self, Union, final, overload
 
 import orjson
 from fabricatio._rust import blake3_hash
@@ -67,6 +67,18 @@ class WithBriefing(Named, Described):
         """
         return f"{self.name}: {self.description}" if self.description else self.name
 
+    def prepend[D: Dict[str, Any]](self, kwargs: D) -> D:
+        """Prepend the briefing to the system message in the kwargs.
+
+        Args:
+            kwargs (Dict[str, Any]): The keyword arguments to modify.
+
+        Returns:
+            Dict[str, Any]: The modified keyword arguments.
+        """
+        kwargs["system_message"] = f"# your personal briefing: \n{self.briefing}\n" + kwargs.get("system_message", "")
+        return kwargs
+
 
 class WithFormatedJsonSchema(Base):
     """Class that provides a formatted JSON schema of the model."""
@@ -88,7 +100,15 @@ class CreateJsonObjPrompt(WithFormatedJsonSchema):
     """Class that provides a prompt for creating a JSON object."""
 
     @classmethod
-    def create_json_prompt(cls, requirement: str) -> str:
+    @overload
+    def create_json_prompt(cls, requirement: List[str]) -> List[str]: ...
+
+    @classmethod
+    @overload
+    def create_json_prompt(cls, requirement: str) -> str: ...
+
+    @classmethod
+    def create_json_prompt(cls, requirement: str | List[str]) -> str | List[str]:
         """Create the prompt for creating a JSON object with given requirement.
 
         Args:
@@ -97,10 +117,18 @@ class CreateJsonObjPrompt(WithFormatedJsonSchema):
         Returns:
             str: The prompt for creating a JSON object with given requirement.
         """
-        return template_manager.render_template(
-            configs.templates.create_json_obj_template,
-            {"requirement": requirement, "json_schema": cls.formated_json_schema()},
-        )
+        if isinstance(requirement, str):
+            return template_manager.render_template(
+                configs.templates.create_json_obj_template,
+                {"requirement": requirement, "json_schema": cls.formated_json_schema()},
+            )
+        return [
+            template_manager.render_template(
+                configs.templates.create_json_obj_template,
+                {"requirement": r, "json_schema": cls.formated_json_schema()},
+            )
+            for r in requirement
+        ]
 
 
 class InstantiateFromString(Base):
@@ -295,6 +323,12 @@ class ScopedConfig(Base):
     llm_max_tokens: Optional[PositiveInt] = None
     """The maximum number of tokens to generate."""
 
+    llm_tpm: Optional[PositiveInt] = None
+    """The tokens per minute of the LLM model."""
+
+    llm_rpm: Optional[PositiveInt] = None
+    """The requests per minute of the LLM model."""
+
     embedding_api_endpoint: Optional[HttpUrl] = None
     """The OpenAI API endpoint."""
 
@@ -361,3 +395,4 @@ class ScopedConfig(Base):
             for attr_name in ScopedConfig.model_fields:
                 if (attr := getattr(self, attr_name)) is not None and getattr(other, attr_name) is None:
                     setattr(other, attr_name, attr)
+        return self

fabricatio/models/kwargs_types.py

@@ -1,92 +1,90 @@
 """This module contains the types for the keyword arguments of the methods in the models module."""
 
-from typing import Any, List, NotRequired, Set, TypedDict
+from typing import Any, TypedDict
 
 from litellm.caching.caching import CacheMode
 from litellm.types.caching import CachingSupportedCallTypes
-from pydantic import NonNegativeFloat, NonNegativeInt, PositiveInt
 
 
-class CollectionSimpleConfigKwargs(TypedDict):
+class CollectionSimpleConfigKwargs(TypedDict, total=False):
     """Configuration parameters for a vector collection.
 
     These arguments are typically used when configuring connections to vector databases.
     """
 
-    dimension: NotRequired[int]
-    timeout: NotRequired[float]
+    dimension: int|None
+    timeout: float
 
 
-class FetchKwargs(TypedDict):
+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.
     """
 
-    collection_name: NotRequired[str]
-    similarity_threshold: NotRequired[float]
-    result_per_query: NotRequired[int]
+    collection_name: str|None
+    similarity_threshold: float
+    result_per_query: int
 
 
-class EmbeddingKwargs(TypedDict):
+class EmbeddingKwargs(TypedDict, total=False):
     """Configuration parameters for text embedding operations.
 
     These settings control the behavior of embedding models that convert text
     to vector representations.
     """
 
-    model: NotRequired[str]
-    dimensions: NotRequired[int]
-    timeout: NotRequired[PositiveInt]
-    caching: NotRequired[bool]
+    model: str
+    dimensions: int
+    timeout: int
+    caching: bool
 
 
-class LLMKwargs(TypedDict):
+class LLMKwargs(TypedDict, total=False):
     """Configuration parameters for language model inference.
 
     These arguments control the behavior of large language model calls,
     including generation parameters and caching options.
     """
 
-    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]
-    no_cache: NotRequired[bool]  # If use cache in this call
-    no_store: NotRequired[bool]  # If store the response of this call to cache
-    cache_ttl: NotRequired[int]  # how long the stored cache is alive, in seconds
-    s_maxage: NotRequired[int]  # max accepted age of cached response, in seconds
-
-
-class ValidateKwargs[T](LLMKwargs):
-    """Arguments for content validation operations.
+    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(LLMKwargs, total=False):
+    """Arguments for content generation operations.
 
-    Extends LLMKwargs with additional parameters specific to validation tasks,
-    such as limiting the number of validation attempts.
+    Extends LLMKwargs with additional parameters specific to generation tasks,
+    such as the number of generated items and the system message.
     """
 
-    default: NotRequired[T]
-    max_validations: NotRequired[PositiveInt]
+    system_message: str
 
 
-# noinspection PyTypedDict
-class GenerateKwargs[T](ValidateKwargs[T]):
-    """Arguments for content generation operations.
+class ValidateKwargs[T](GenerateKwargs, total=False):
+    """Arguments for content validation operations.
 
-    Extends ValidateKwargs with parameters specific to text generation,
-    including system prompt configuration.
+    Extends LLMKwargs with additional parameters specific to validation tasks,
+    such as limiting the number of validation attempts.
     """
 
-    system_message: NotRequired[str]
+    default: T
+    max_validations: int
 
 
 # noinspection PyTypedDict
-class ReviewKwargs[T](GenerateKwargs[T]):
+class ReviewKwargs[T](ValidateKwargs[T], total=False):
     """Arguments for content review operations.
 
     Extends GenerateKwargs with parameters for evaluating content against
@@ -94,18 +92,18 @@ class ReviewKwargs[T](GenerateKwargs[T]):
     """
 
     topic: str
-    criteria: NotRequired[Set[str]]
+    criteria: set[str]
 
 
 # noinspection PyTypedDict
-class ChooseKwargs[T](GenerateKwargs[T]):
+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: NotRequired[NonNegativeInt]
+    k: int
 
 
 class CacheKwargs(TypedDict, total=False):
@@ -115,35 +113,35 @@ class CacheKwargs(TypedDict, total=False):
     including in-memory, Redis, S3, and vector database caching options.
     """
 
-    mode: NotRequired[CacheMode]  # when default_on cache is always on, when default_off cache is opt in
-    host: NotRequired[str]
-    port: NotRequired[str]
-    password: NotRequired[str]
-    namespace: NotRequired[str]
-    ttl: NotRequired[float]
-    default_in_memory_ttl: NotRequired[float]
-    default_in_redis_ttl: NotRequired[float]
-    similarity_threshold: NotRequired[float]
-    supported_call_types: NotRequired[List[CachingSupportedCallTypes]]
+    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: NotRequired[str]
-    s3_region_name: NotRequired[str]
-    s3_api_version: NotRequired[str]
-    s3_use_ssl: NotRequired[bool]
-    s3_verify: NotRequired[bool | str]
-    s3_endpoint_url: NotRequired[str]
-    s3_aws_access_key_id: NotRequired[str]
-    s3_aws_secret_access_key: NotRequired[str]
-    s3_aws_session_token: NotRequired[str]
-    s3_config: NotRequired[Any]
-    s3_path: NotRequired[str]
+    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: NotRequired[int]
-    redis_startup_nodes: NotRequired[List]
+    redis_flush_size: int
+    redis_startup_nodes: list
     disk_cache_dir: Any
-    qdrant_api_base: NotRequired[str]
-    qdrant_api_key: NotRequired[str]
-    qdrant_collection_name: NotRequired[str]
-    qdrant_quantization_config: NotRequired[str]
+    qdrant_api_base: str
+    qdrant_api_key: str
+    qdrant_collection_name: str
+    qdrant_quantization_config: str
     qdrant_semantic_cache_embedding_model: str

fabricatio/models/tool.py

@@ -4,7 +4,7 @@ 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 logging_execution_info, use_temp_module
@@ -136,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)
@@ -144,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)
@@ -184,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)