fabricatio 0.2.6.dev7__tar.gz → 0.2.6.dev8__tar.gz

{fabricatio-0.2.6.dev7 → fabricatio-0.2.6.dev8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.6.dev7
+Version: 0.2.6.dev8
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12

{fabricatio-0.2.6.dev7 → fabricatio-0.2.6.dev8}/examples/extract_and_inject/extract_and_inject.py

@@ -2,23 +2,28 @@
 
 import asyncio
 from pathlib import Path
-from typing import List
+from typing import List, Optional
 
 from fabricatio import Action, Event, Role, Task, WorkFlow, logger
 from fabricatio.actions.article import ExtractArticleEssence
 from fabricatio.actions.rag import InjectToDB
 from fabricatio.fs.curd import dump_text, gather_files
 from fabricatio.models.extra import ArticleEssence
-from pydantic import HttpUrl
 
 
 class SaveToFS(Action):
     """Save to file system."""
 
-    async def _execute(self, to_inject: List[ArticleEssence], output_dir: Path, **_) -> None:
+    async def _execute(self, to_inject: List[Optional[ArticleEssence]], output_dir: Path, **_) -> None:
         output_dir.mkdir(parents=True, exist_ok=True)
+        empty_count = 0
         for i, e in enumerate(to_inject):
+            if e is None:
+                empty_count += 1
+                logger.error(f"Invalid essence at index {i}")
+                continue
             dump_text(output_dir / f"{i}.json", e.display())
+        logger.info(f"Passed {empty_count} empty essence ")
 
 
 async def main() -> None:
@@ -26,12 +31,13 @@ async def main() -> None:
     role = Role(
         name="Researcher",
         description="Extract article essence",
-        llm_api_endpoint=HttpUrl("https://dashscope.aliyuncs.com/compatible-mode/v1"),
-        llm_model="deepseek-r1-distill-llama-70b",
+        llm_model="openai/deepseek-r1-distill-llama-70b",
+        llm_rpm=50,
+        llm_tpm=100000,
         registry={
             Event.quick_instantiate("article"): WorkFlow(
                 name="extract",
-                steps=(ExtractArticleEssence(output_key="to_inject"), InjectToDB(output_key="task_output")),
+                steps=(ExtractArticleEssence(output_key="to_inject"), SaveToFS, InjectToDB(output_key="task_output")),
                 extra_init_context={"collection_name": "article_essence", "output_dir": Path("output")},
             )
         },

{fabricatio-0.2.6.dev7 → fabricatio-0.2.6.dev8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fabricatio"
-version = "0.2.6-dev7"
+version = "0.2.6-dev8"
 description = "A LLM multi-agent framework."
 readme = "README.md"
 license = { file = "LICENSE" }

{fabricatio-0.2.6.dev7 → fabricatio-0.2.6.dev8}/python/fabricatio/actions/rag.py

@@ -3,6 +3,7 @@
 from typing import List, Optional
 
 from fabricatio.capabilities.rag import RAG
+from fabricatio.journal import logger
 from fabricatio.models.action import Action
 from fabricatio.models.generic import PrepareVectorization
 
@@ -13,13 +14,13 @@ class InjectToDB(Action, RAG):
     output_key: str = "collection_name"
 
     async def _execute[T: PrepareVectorization](
-        self, to_inject: T | List[T], collection_name: Optional[str] = "my_collection", **_
+        self, to_inject: Optional[T] | List[Optional[T]], collection_name: Optional[str] = "my_collection", **_
     ) -> Optional[str]:
         if not isinstance(to_inject, list):
             to_inject = [to_inject]
-
+        logger.info(f"Injecting {len(to_inject)} items into the collection '{collection_name}'")
         await self.view(collection_name, create=True).consume_string(
-            [t.prepare_vectorization(self.embedding_max_sequence_length) for t in to_inject],
+            [t.prepare_vectorization(self.embedding_max_sequence_length) for t in to_inject if isinstance(t,PrepareVectorization)],
         )
 
         return collection_name

{fabricatio-0.2.6.dev7 → fabricatio-0.2.6.dev8}/python/fabricatio/capabilities/rag.py

@@ -63,10 +63,18 @@ class RAG(EmbeddingUsage):
             uri=milvus_uri or ok(self.milvus_uri or configs.rag.milvus_uri).unicode_string(),
             token=milvus_token
             or (token.get_secret_value() if (token := (self.milvus_token or configs.rag.milvus_token)) else ""),
-            timeout=milvus_timeout or self.milvus_timeout,
+            timeout=milvus_timeout or self.milvus_timeout or configs.rag.milvus_timeout,
         )
         return self
 
+    def check_client(self, init: bool = True) -> Self:
+        """Check if the client is initialized, and if not, initialize it."""
+        if self._client is None and init:
+            return self.init_client()
+        if self._client is None and not init:
+            raise RuntimeError("Client is not initialized. Have you called `self.init_client()`?")
+        return self
+
     @overload
     async def pack(
         self, input_text: List[str], subject: Optional[str] = None, **kwargs: Unpack[EmbeddingKwargs]
@@ -111,8 +119,15 @@ class RAG(EmbeddingUsage):
             create (bool): Whether to create the collection if it does not exist.
             **kwargs (Unpack[CollectionConfigKwargs]): Additional keyword arguments for collection configuration.
         """
-        if create and collection_name and self.client.has_collection(collection_name):
-            kwargs["dimension"] = kwargs.get("dimension") or self.milvus_dimensions or configs.rag.milvus_dimensions
+        if create and collection_name and not self.check_client().client.has_collection(collection_name):
+            kwargs["dimension"] = ok(
+                kwargs.get("dimension")
+                or self.milvus_dimensions
+                or configs.rag.milvus_dimensions
+                or self.embedding_dimensions
+                or configs.embedding.dimensions,
+                "`dimension` is not set at any level.",
+            )
             self.client.create_collection(collection_name, auto_id=True, **kwargs)
             logger.info(f"Creating collection {collection_name}")
 
@@ -158,7 +173,7 @@ class RAG(EmbeddingUsage):
         else:
             raise TypeError(f"Expected MilvusData or list of MilvusData, got {type(data)}")
         c_name = collection_name or self.safe_target_collection
-        self.client.insert(c_name, prepared_data)
+        self.check_client().client.insert(c_name, prepared_data)
 
         if flush:
             logger.debug(f"Flushing collection {c_name}")
@@ -219,7 +234,7 @@ class RAG(EmbeddingUsage):
             List[Dict[str, Any]] | List[Any]: The retrieved data.
         """
         # Step 1: Search for vectors
-        search_results = self.client.search(
+        search_results = self.check_client().client.search(
             collection_name or self.safe_target_collection,
             vecs,
             search_params={"radius": similarity_threshold},

{fabricatio-0.2.6.dev7 → fabricatio-0.2.6.dev8}/python/fabricatio/config.py

@@ -277,7 +277,7 @@ class RagConfig(BaseModel):
 
     milvus_uri: Optional[HttpUrl] = Field(default=HttpUrl("http://localhost:19530"))
     """The URI of the Milvus server."""
-    milvus_timeout: Optional[PositiveFloat] = Field(default=None)
+    milvus_timeout: Optional[PositiveFloat] = Field(default=30.0)
     """The timeout of the Milvus server."""
     milvus_token: Optional[SecretStr] = Field(default=None)
     """The token of the Milvus server."""
@@ -303,11 +303,13 @@ class RoutingConfig(BaseModel):
 
     model_config = ConfigDict(use_attribute_docstrings=True)
 
-    allowed_fails: Optional[int] = 1
+    max_parallel_requests: Optional[int] = 60
+    """The maximum number of parallel requests. None means not checked."""
+    allowed_fails: Optional[int] = 3
     """The number of allowed fails before the routing is considered failed."""
     retry_after: int = 15
     """The time in seconds to wait before retrying the routing after a fail."""
-    cooldown_time: Optional[int] = 120
+    cooldown_time: Optional[int] = 30
     """The time in seconds to wait before retrying the routing after a cooldown."""
 
 

{fabricatio-0.2.6.dev7 → fabricatio-0.2.6.dev8}/python/fabricatio/models/action.py

@@ -216,3 +216,15 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
         """
         self.provide_tools_to(self._instances)
         return self
+
+    def update_init_context(self, **kwargs) -> Self:
+        """Update the initial context with additional key-value pairs.
+
+        Args:
+            **kwargs: Key-value pairs to add to the initial context.
+
+        Returns:
+            Self: The workflow instance for method chaining.
+        """
+        self.extra_init_context.update(kwargs)
+        return self

{fabricatio-0.2.6.dev7 → fabricatio-0.2.6.dev8}/python/fabricatio/models/extra.py

@@ -109,28 +109,25 @@ class ArticleEssence(ProposedAble, Display, PrepareVectorization):
 
     Encodes research artifacts with dual human-machine interpretability.
     """
-
     title: str = Field(...)
-    """Complete title with technical specificity (12-18 words).
-    Must contain:
-    1. Methodology focus
-    2. Application domain
-    3. Performance metric
-    Example: 'EfficientViT: Multi-Scale Linear Attention for High-Resolution Dense Prediction'"""
+    """Exact title of the original article without any modification.
+    Must be preserved precisely from the source material without:
+    - Translation
+    - Paraphrasing
+    - Adding/removing words
+    - Altering style or formatting
+    Example: The exact published title as it appears in the original document"""
 
     authors: List[str]
-    """Author list with institutional annotations.
-    Format: [First Last¹, First Last²]
-    Superscripts mapping to affiliations.
-    Example: ['Yuanhao Zhou¹', 'Lei Chen²']"""
+    """Original author names exactly as they appear in the source document. No translation or paraphrasing.
+    Extract complete list without any modifications or formatting changes."""
 
     keywords: List[str]
-    """5-8 ACM CCS concepts in camel case.
-    Example: ['Computing methodologies~Neural networks', 'Hardware~Emerging technologies']"""
+    """Original keywords exactly as they appear in the source document. No translation or paraphrasing.
+    Extract the complete set without modifying format or terminology."""
 
     publication_year: int
-    """Publication timestamp in ISO 8601 (YYYY format).
-    Constraint: 2017 ≤ year ≤ current_year"""
+    """Publication timestamp in ISO 8601 (YYYY format)."""
 
     highlightings: Highlightings = Field(default_factory=Highlightings)
     """Technical highlight reel containing:

{fabricatio-0.2.6.dev7 → fabricatio-0.2.6.dev8}/python/fabricatio/models/usages.py

@@ -14,7 +14,7 @@ from fabricatio.models.task import Task
 from fabricatio.models.tool import Tool, ToolBox
 from fabricatio.models.utils import Messages, ok
 from fabricatio.parser import GenericCapture, JsonCapture
-from litellm import Router, stream_chunk_builder  # pyright: ignore [reportPrivateImportUsage]
+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 (
     Choices,
@@ -33,6 +33,7 @@ if configs.cache.enabled and configs.cache.type:
 
 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,
@@ -305,6 +306,9 @@ class LLMUsage(ScopedConfig):
                     ):
                         logger.debug(f"Successfully validated the co-response at {lap}th attempt.")
                         return validated
+                except RateLimitError as e:
+                    logger.warning(f"Rate limit error: {e}")
+                    continue
                 except Exception as e:  # noqa: BLE001
                     logger.error(f"Error during validation: \n{e}")
                     break

{fabricatio-0.2.6.dev7 → fabricatio-0.2.6.dev8}/python/fabricatio/models/utils.py

@@ -172,6 +172,10 @@ def override_kwargs[T](kwargs: Dict[str, T], **overrides) -> Dict[str, T]:
     kwargs.update({k: v for k, v in overrides.items() if v is not None})
     return kwargs
 
+def fallback_kwargs[T](kwargs: Dict[str, T], **overrides) -> Dict[str, T]:
+    """Fallback the values in kwargs with the provided overrides."""
+    kwargs.update({k: v for k, v in overrides.items() if  k not in kwargs})
+    return kwargs
 
 def ok[T](val: Optional[T], msg:str="Value is None") -> T:
     """Check if a value is None and raise a ValueError with the provided message if it is.

{fabricatio-0.2.6.dev7 → fabricatio-0.2.6.dev8}/templates/built-in/create_json_obj.hbs

@@ -64,11 +64,11 @@ To satisfy the given requirements, Generate a JSON object that strictly adheres
 ----- END of RESPONSE -----
 
 # Critical Constraints:
-‼️ Output MUST contain ONLY the JSON object within the code block
+‼️ Output MUST contain ONLY the JSON object within the Markdown format codeblock
 ‼️ STRICTLY FOLLOW schema-defined formats (quotes, indentation, etc.)
 ‼️ PROPERLY ESCAPE special characters in strings (quotes, newlines, etc.)
 ‼️ Numerical values MUST SATISFY comparison operators (e.g., >N for exclusiveMinimum)
 ‼️ Handle optional parameters context-appropriately
-
+‼️ Your response MUST be a valid JSON object wrapped in a Markdown codeblock, not `--- BEGIN of RESPONSE ---` and `--- END of RESPONSE ---` or any other format.
 # Validation:
 The generated JSON within the code block MUST pass JSON Schema validation. Any non-compliant response will be rejected by the system.

{fabricatio-0.2.6.dev7 → fabricatio-0.2.6.dev8}/uv.lock

@@ -216,7 +216,7 @@ wheels = [
 
 [[package]]
 name = "fabricatio"
-version = "0.2.6.dev7"
+version = "0.2.6.dev8"
 source = { editable = "." }
 dependencies = [
     { name = "appdirs" },