fabricatio 0.2.6.dev6__cp312-cp312-manylinux_2_34_x86_64.whl → 0.2.6.dev8__cp312-cp312-manylinux_2_34_x86_64.whl

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/capabilities/rag.py

@@ -15,7 +15,7 @@ from fabricatio.config import configs
 from fabricatio.journal import logger
 from fabricatio.models.kwargs_types import (
     ChooseKwargs,
-    CollectionSimpleConfigKwargs,
+    CollectionConfigKwargs,
     EmbeddingKwargs,
     FetchKwargs,
     LLMKwargs,
@@ -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]
@@ -102,17 +110,24 @@ class RAG(EmbeddingUsage):
         ]
 
     def view(
-        self, collection_name: Optional[str], create: bool = False, **kwargs: Unpack[CollectionSimpleConfigKwargs]
+        self, collection_name: Optional[str], create: bool = False, **kwargs: Unpack[CollectionConfigKwargs]
     ) -> Self:
         """View the specified collection.
 
         Args:
             collection_name (str): The name of the collection.
             create (bool): Whether to create the collection if it does not exist.
-            **kwargs (Unpack[CollectionSimpleConfigKwargs]): Additional keyword arguments for collection configuration.
+            **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/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/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/models/extra.py

@@ -1,11 +1,12 @@
 """Extra models for built-in actions."""
 
-from typing import List
+from typing import List, Self
 
 from fabricatio.models.generic import Base, Display, FinalizedDumpAble, PrepareVectorization, ProposedAble
 from pydantic import Field
 
 
+# <editor-fold desc="ArticleEssence">
 class Equation(Base):
     """Mathematical formalism specification for research contributions.
 
@@ -108,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:
@@ -200,6 +198,9 @@ class ArticleEssence(ProposedAble, Display, PrepareVectorization):
         return self.model_dump_json()
 
 
+# </editor-fold>
+
+
 class ArticleProposal(ProposedAble, Display):
     """Structured proposal for academic paper development with core research elements.
 
@@ -221,119 +222,434 @@ class ArticleProposal(ProposedAble, Display):
     """Methodological components (list of techniques/tools).
     Example: ['Differentiable architecture search', 'Transformer-based search space', 'Multi-lingual perplexity evaluation']"""
 
+    technical_approaches: List[str] = Field(default_factory=list)
 
-class ArticleSubsectionOutline(Base):
-    """Atomic content unit within academic paper sections.
 
-    Provides structured content specification for LLM-generated subsections.
-    """
+# <editor-fold desc="ArticleOutline">
+class ArticleSubsectionOutline(Base):
+    """Atomic research component specification for academic paper generation."""
 
     title: str = Field(...)
-    """Subsection title reflecting specific content focus (Title Case, 3-8 words).
-    Example: 'Differentiable Search Space Design'"""
+    """Technical focus descriptor following ACL title conventions:
+    - Title Case with 4-8 word limit
+    - Contains method and domain components
+    Example: 'Differentiable Search Space Optimization'"""
 
     description: str = Field(...)
-    """Content specification with three required elements:
-    1. Core technical content
-    2. Structural purpose in section
-    3. Research significance
-    Example: 'Introduces continuous relaxation method for search space, enabling gradient-based optimization. Forms technical foundation for Section 3. Critical for reducing search complexity.'"""
+    """Tripartite content specification with strict structure:
+    1. Technical Core: Method/algorithm/formalism (1 sentence)
+    2. Structural Role: Placement rationale in section (1 clause)
+    3. Research Value: Contribution to paper's thesis (1 clause)
 
+    Example: 'Introduces entropy-constrained architecture parameters enabling
+    gradient-based NAS. Serves as foundation for Section 3.2. Critical for
+    maintaining search space diversity while ensuring convergence.'"""
 
-class ArticleSectionOutline(Base):
-    """Primary organizational unit within paper chapters.
 
-    Defines section-level structure with nested subsections for hierarchical content organization.
-    """
+class ArticleSectionOutline(Base):
+    """Methodological unit organizing related technical components."""
 
     title: str = Field(...)
-    """Section title indicating methodological phase or conceptual component (Title Case).
-    Example: 'Architecture Search Methodology'"""
+    """Process-oriented header with phase identification:
+    - Title Case with 5-10 word limit
+    - Indicates research stage/methodological focus
+    Example: 'Cross-Lingual Evaluation Protocol'"""
 
     description: str = Field(...)
-    """Functional description covering:
-    1. Section's research stage
-    2. Key contributions
-    3. Flow relationship with adjacent sections
-    Example: 'Presents core NAS framework building on literature from Section 2. Introduces novel constrained search space. Leads to implementation details in Section 4.'"""
-
-    subsections: List[ArticleSubsectionOutline]
-    """Ordered sequence of 3-5 subsections implementing IMRaD structure within section. Maintains logical flow from problem statement to technical solution."""
+    """Functional specification with four required elements:
+    1. Research Stage: Paper progression position
+    2. Technical Innovations: Novel components
+    3. Scholarly Context: Relationship to prior work
+    4. Forward Flow: Connection to subsequent sections
+
+    Example: 'Implements constrained NAS framework building on Section 2's
+    theoretical foundations. Introduces dynamic resource allocation mechanism.
+    Directly supports Results section through ablation study parameters.'"""
+
+    subsections: List[ArticleSubsectionOutline] = Field(..., min_length=3, max_length=5)
+    """IMRaD-compliant substructure with technical progression:
+    1. Conceptual Framework
+    2. Methodological Details
+    3. Implementation Strategy
+    4. Validation Approach
+    5. Transition Logic
+
+    Example Flow:
+    [
+        'Search Space Constraints',
+        'Gradient Optimization Protocol',
+        'Multi-GPU Implementation',
+        'Convergence Validation',
+        'Cross-Lingual Extension'
+    ]"""
 
 
 class ArticleChapterOutline(Base):
-    """Macro-level paper organization unit.
-
-    Represents major paper divisions (Introduction, Methodology, etc.) with hierarchical section structure.
-    """
+    """Macro-structural unit implementing standard academic paper organization."""
 
     title: str = Field(...)
-    """Chapter title reflecting standard academic sections (Title Case).
-    Example: 'Experimental Evaluation', 'Theoretical Framework'"""
+    """IMRaD-compliant chapter title with domain specification:
+    - Title Case with 2-4 word limit
+    - Matches standard paper sections
+    Example: 'Multilingual Evaluation Results'"""
 
     description: str = Field(...)
-    """Chapter role specification containing:
-    1. Research phase covered
-    2. Chapter-specific objectives
-    3. Relationship to overall paper thesis
-    Example: 'Validates NAS framework through multilingual experiments. Demonstrates method effectiveness across 10 language pairs. Supports core thesis of parameter-efficient architecture search.'"""
-
-    sections: List[ArticleSectionOutline]
-    """3-5 sections implementing chapter's main function. Ordered to maintain academic paper logic:
-    Introduction → Related Work → Methods → Experiments → Analysis"""
+    """Strategic chapter definition containing:
+    1. Research Phase: Introduction/Methods/Results/etc.
+    2. Chapter Objectives: 3-5 specific goals
+    3. Thesis Alignment: Supported claims/contributions
+    4. Structural Flow: Adjacent chapter relationships
+
+    Example: 'Presents cross-lingual NAS results across 10 language pairs.
+    Validates efficiency claims from Introduction. Provides empirical basis
+    for Discussion chapter. Contrasts with single-language baselines.'"""
+
+    sections: List[ArticleSectionOutline] = Field(..., min_length=3, max_length=5)
+    """Standard academic progression implementing chapter goals:
+    1. Context Establishment
+    2. Technical Presentation
+    3. Empirical Validation
+    4. Comparative Analysis
+    5. Synthesis
+
+    Example Structure:
+    [
+        'Experimental Setup',
+        'Monolingual Baselines',
+        'Cross-Lingual Transfer',
+        'Low-Resource Scaling',
+        'Error Analysis'
+    ]"""
 
 
 class ArticleOutline(ProposedAble, Display, FinalizedDumpAble):
-    """Complete hierarchical structure for academic paper generation.
-
-    Provides multi-level outline specification for LLM-based paper drafting with strict academic conventions.
-    """
+    """Complete academic paper blueprint with hierarchical validation."""
 
     title: str = Field(...)
-    """Full paper title with technical specificity (Title Case, 12-18 words).
-    Example: 'Parameter-Efficient Neural Architecture Search for Low-Resource Machine Translation: A Cross-Lingual Transfer Approach'"""
+    """Full technical title following ACL 2024 guidelines:
+    - Title Case with 12-18 word limit
+    - Structure: [Method] for [Task] via [Approach] in [Domain]
+    Example: 'Efficient Differentiable NAS for Low-Resource MT Through
+    Parameter-Sharing: A Cross-Lingual Study'"""
 
     prospect: str = Field(...)
-    """Unified problem-solution statement combining:
-    1. Core research gap
-    2. Proposed methodology
-    3. Expected contribution
-    Example: 'Addressing NAS computational barriers in low-resource NLP through differentiable constrained search spaces and cross-lingual transfer metrics, enabling efficient architecture discovery for 50+ languages.'"""
-
-    chapters: List[ArticleChapterOutline]
-    """Standard academic structure (5-8 chapters):
-    1. Introduction
-    2. Related Work
-    3. Methodology
-    4. Experiments
-    5. Results
-    6. Discussion
-    7. Conclusion
-    Maintains IMRaD logical flow with clear inter-chapter transitions."""
+    """Consolidated research statement with four pillars:
+    1. Problem Identification: Current limitations
+    2. Methodological Response: Technical approach
+    3. Empirical Validation: Evaluation strategy
+    4. Scholarly Impact: Field contributions
+
+    Example: 'Addressing NAS computational barriers through constrained
+    differentiable search spaces, validated via cross-lingual MT experiments
+    across 50+ languages, enabling efficient architecture discovery with
+    60% reduced search costs.'"""
+
+    chapters: List[ArticleChapterOutline] = Field(..., min_length=5, max_length=8)
+    """IMRaD structure with enhanced academic validation:
+    1. Introduction: Problem Space & Contributions
+    2. Background: Theoretical Foundations
+    3. Methods: Technical Innovations
+    4. Experiments: Protocol Design
+    5. Results: Empirical Findings
+    6. Discussion: Interpretation & Limitations
+    7. Conclusion: Synthesis & Future Work
+    8. Appendices: Supplementary Materials"""
 
     def finalized_dump(self) -> str:
-        """Generates standardized hierarchical markup for paper drafting systems.
+        """Generates standardized hierarchical markup for academic publishing systems.
+
+        Implements ACL 2024 outline conventions with four-level structure:
+        = Chapter Title (Level 1)
+        == Section Title (Level 2)
+        === Subsection Title (Level 3)
+        ==== Subsubsection Title (Level 4)
 
         Returns:
-            str: Multi-level outline using academic markup conventions:
-            = Chapter Title
-            == Section Title
-            === Subsection Title
-            ==== Subsubsection Title (if needed)
+            str: Strictly formatted outline with academic sectioning
 
         Example:
             = Methodology
             == Neural Architecture Search Framework
             === Differentiable Search Space
-            === Constrained Optimization Approach
+            ==== Constrained Optimization Parameters
+            === Implementation Details
+            == Evaluation Protocol
         """
         lines: List[str] = []
+        for i, chapter in enumerate(self.chapters, 1):
+            lines.append(f"= Chapter {i}: {chapter.title}")
+            for j, section in enumerate(chapter.sections, 1):
+                lines.append(f"== {i}.{j} {section.title}")
+                for k, subsection in enumerate(section.subsections, 1):
+                    lines.append(f"=== {i}.{j}.{k} {subsection.title}")
+        return "\n".join(lines)
+
+
+# </editor-fold>
+
+
+# <editor-fold desc="Article">
+class Paragraph(ProposedAble):
+    """Structured academic paragraph blueprint for controlled content generation."""
+
+    description: str
+    """Functional summary of the paragraph's role in document structure.
+    Example: 'Establishes NAS efficiency improvements through differentiable methods'"""
+
+    writing_aim: List[str]
+    """Specific communicative objectives for this paragraph's content.
+    Example: ['Introduce gradient-based NAS', 'Compare computational costs',
+             'Link efficiency to practical applications']"""
+
+    lines: List[str]
+    """Hierarchically structured content with enforced rhetorical elements:
+    1. Topic Sentence: Principal claim/position (1 sentence)
+    2. Development: Evidence chain with citations (2-4 sentences)
+    3. Synthesis: Interpretation & significance (1 sentence)
+    4. Transition: Logical bridge to next paragraph (optional)
+
+    Example: [
+        'Differentiable NAS revolutionized architecture search efficiency.',
+        'DARTS reduced search costs from 2000+ to 4 GPU days (Liu et al., 2019) while maintaining competitive ImageNet accuracy.',
+        'This order-of-magnitude improvement enables NAS deployment in resource-constrained research contexts.',
+        'These efficiency gains directly impact our framework's design choices as detailed in Section 3.'
+    ]"""
+
+
+class SectionRef(ProposedAble):
+    """Cross-component reference system for maintaining document consistency."""
+
+    ref_chapter_title: str
+    """Title of referenced chapter (e.g., 'Methodology')"""
+
+    ref_section_title: str
+    """Exact section header text (e.g., '3.2 Gradient Optimization')"""
 
-        for chapter in self.chapters:
-            lines.append(f"= {chapter.title}")
-            for section in chapter.sections:
-                lines.append(f"== {section.title}")
-                for subsection in section.subsections:
-                    lines.append(f"=== {subsection.title}")
+    ref_subsection_title: str
+    """Specific subsection identifier (e.g., '3.2.1 Learning Rate Scheduling')"""
 
-        return "\n\n".join(lines)
+
+class ArticleBase(ProposedAble, Display):
+    """Foundation for hierarchical document components with dependency tracking."""
+
+    description: str
+    """Functional purpose statement for this component's role in the paper.
+    Example: 'Defines evaluation metrics for cross-lingual transfer experiments'"""
+
+    writing_aim: List[str]
+    """Author intentions mapped to rhetorical moves:
+    Example: ['Establish metric validity', 'Compare with baseline approaches',
+             'Justify threshold selection']"""
+
+    title: str = Field(...)
+    """Standardized academic header following ACL style guidelines:
+    - Title Case with maximal 12-word length
+    - No abbreviations without prior definition
+    Example: 'Multilingual Benchmark Construction'"""
+
+    support_to: List[SectionRef]
+    """Upstream dependencies requiring this component's validation.
+    Format: List of hierarchical references to supported claims/sections
+    Example: [SectionRef(chapter='Results', section='4.1', subsection='4.1.2')]"""
+
+    depend_on: List[SectionRef]
+    """Downstream prerequisites for content validity.
+    Format: List of references to foundational components
+    Example: [SectionRef(chapter='Methods', section='2.3', subsection='2.3.4')]"""
+
+
+class ArticleSubsection(ArticleBase):
+    """Atomic argumentative unit with technical specificity."""
+
+    title: str = Field(...)
+    """Technical descriptor with maximal information density:
+    Format: [Method]-[Domain]-[Innovation]
+    Example: 'Transformer-Based Architecture Search Space'"""
+
+    support_to: List[SectionRef]
+    """Immediate parent components and supported hypotheses.
+    Example: [SectionRef(chapter='Methods', section='3', subsection='3.1')]"""
+
+    depend_on: List[SectionRef]
+    """Technical dependencies including equations, algorithms, and datasets.
+    Example: [SectionRef(chapter='Background', section='2.2', subsection='2.2.3')]"""
+
+    paragraphs: List[Paragraph] = Field(..., min_length=3, max_length=5)
+    """Technical exposition following ACM writing guidelines:
+    1. Contextualization: Position in research design
+    2. Technical Detail: Equations/algorithms/code
+    3. Validation: Citations/experimental confirmation
+    4. Interpretation: Scholarly significance
+    5. Transition: Logical connection to subsequent content
+
+    Example Paragraph Chain:
+    [
+        'Our search space builds on standard CNN architectures...',
+        'Formally, we define architecture parameters $\\alpha \\in R^d$ where...',
+        'This parameterization reduces search complexity by 42% compared to...',
+        'The efficiency gains validate our approach to...'
+    ]"""
+
+
+class ArticleSection(ArticleBase):
+    """Methodological complete unit presenting cohesive research phase."""
+
+    title: str = Field(...)
+    """Process-oriented header indicating methodological scope.
+    Example: 'Cross-Lingual Transfer Evaluation Protocol'"""
+
+    support_to: List[SectionRef]
+    """Supported research questions and paper-level claims.
+    Example: [SectionRef(chapter='Introduction', section='1', subsection='1.2')]"""
+
+    depend_on: List[SectionRef]
+    """Required methodological components and theoretical frameworks.
+    Example: [SectionRef(chapter='Background', section='2', subsection='2.4')]"""
+
+    subsections: List[ArticleSubsection] = Field(..., min_length=3, max_length=5)
+    """Thematic progression implementing section's research function:
+    1. Conceptual Framework
+    2. Technical Implementation
+    3. Experimental Validation
+    4. Comparative Analysis
+    5. Synthesis
+
+    Example Subsection Flow:
+    [
+        'Evaluation Metrics',
+        'Dataset Preparation',
+        'Baseline Comparisons',
+        'Ablation Studies',
+        'Interpretation Framework'
+    ]"""
+
+
+class ArticleChapter(ArticleBase):
+    """Macro-structural unit implementing IMRaD document architecture."""
+
+    title: str = Field(...)
+    """Standard IMRaD chapter title with domain specification.
+    Example: 'Neural Architecture Search for Low-Resource Languages'"""
+
+    support_to: List[SectionRef]
+    """Supported thesis statements and paper-level contributions.
+    Example: [SectionRef(chapter='Abstract', section='', subsection='')]"""
+
+    depend_on: List[SectionRef]
+    """Foundational chapters and external knowledge prerequisites.
+    Example: [SectionRef(chapter='Related Work', section='2', subsection='2.3')]"""
+
+    sections: List[ArticleSection] = Field(..., min_length=3, max_length=5)
+    """Complete research narrative implementing chapter objectives:
+    1. Context Establishment
+    2. Methodology Exposition
+    3. Results Presentation
+    4. Critical Analysis
+    5. Synthesis
+
+    Example Section Hierarchy:
+    [
+        'Theoretical Framework',
+        'Experimental Design',
+        'Results Analysis',
+        'Threats to Validity',
+        'Comparative Discussion'
+    ]"""
+
+
+class Article(ProposedAble, Display):
+    """Complete academic paper specification with validation constraints."""
+
+    title: str = Field(...)
+    """Full technical descriptor following ACL 2024 guidelines:
+    Structure: [Method] for [Task] in [Domain]: [Subtitle with Technical Focus]
+    Example: 'Efficient Differentiable NAS for Low-Resource MT:
+             A Parameter-Sharing Approach to Cross-Lingual Transfer'"""
+
+    abstract: str = Field(...)
+    """Structured summary with controlled natural language:
+    1. Context: 2 clauses (problem + gap)
+    2. Methods: 3 clauses (approach + innovation + implementation)
+    3. Results: 3 clauses (metrics + comparisons + significance)
+    4. Impact: 2 clauses (theoretical + practical)
+
+    Example: 'Neural architecture search (NAS) faces prohibitive... [150 words]'"""
+
+    chapters: List[ArticleChapter] = Field(..., min_length=5, max_length=8)
+    """IMRaD-compliant document structure with enhanced validation:
+    1. Introduction: Motivation & Contributions
+    2. Background: Literature & Theory
+    3. Methods: Technical Implementation
+    4. Experiments: Protocols & Setup
+    5. Results: Empirical Findings
+    6. Discussion: Interpretation & Limitations
+    7. Conclusion: Summary & Future Work
+
+    Additional: Appendices, Ethics Review, Reproducibility Statements"""
+
+    def init_from_outline(self, outline: ArticleOutline) -> Self:
+        """Initialize the article from a given outline.
+
+        Args:
+            outline (ArticleOutline): The outline to initialize from.
+
+        Returns:
+            Self: The current instance of the article.
+        """
+        # Set the title from the outline
+        self.title = outline.title
+
+        # Initialize chapters based on outline's chapters
+        self.chapters = []
+
+        for chapter_outline in outline.chapters:
+            # Create a new chapter
+            chapter = ArticleChapter(
+                title=chapter_outline.title,
+                description=chapter_outline.description,
+                writing_aim=["Implement " + chapter_outline.description],
+                support_to=[],
+                depend_on=[],
+                sections=[],
+            )
+
+            # Create sections for each chapter
+            for section_outline in chapter_outline.sections:
+                section = ArticleSection(
+                    title=section_outline.title,
+                    description=section_outline.description,
+                    writing_aim=["Address " + section_outline.description],
+                    support_to=[],
+                    depend_on=[],
+                    subsections=[],
+                )
+
+                # Create subsections for each section
+                for subsection_outline in section_outline.subsections:
+                    subsection = ArticleSubsection(
+                        title=subsection_outline.title,
+                        description=subsection_outline.description,
+                        writing_aim=["Explain " + subsection_outline.description],
+                        support_to=[],
+                        depend_on=[],
+                        paragraphs=[
+                            Paragraph(
+                                description=f"Implementation of {subsection_outline.title}",
+                                writing_aim=["Present key concepts", "Support main arguments"],
+                                lines=[],
+                            )
+                        ],
+                    )
+                    section.subsections.append(subsection)
+
+                chapter.sections.append(section)
+
+            self.chapters.append(chapter)
+
+        # Generate a placeholder abstract from the outline's prospect
+        self.abstract = f"Abstract: {outline.prospect}"
+
+        return self
+
+
+# </editor-fold>

fabricatio/models/kwargs_types.py

@@ -1,19 +1,29 @@
 """This module contains the types for the keyword arguments of the methods in the models module."""
 
+from importlib.util import find_spec
 from typing import Any, Required, TypedDict
 
 from litellm.caching.caching import CacheMode
 from litellm.types.caching import CachingSupportedCallTypes
 
+if find_spec("pymilvus"):
+    from pymilvus import CollectionSchema
+    from pymilvus.milvus_client import IndexParams
 
-class CollectionSimpleConfigKwargs(TypedDict, total=False):
-    """Configuration parameters for a vector collection.
+    class CollectionConfigKwargs(TypedDict, total=False):
+        """Configuration parameters for a vector collection.
 
-    These arguments are typically used when configuring connections to vector databases.
-    """
+        These arguments are typically used when configuring connections to vector databases.
+        """
 
-    dimension: int | None
-    timeout: float
+        dimension: int | None
+        primary_field_name: str
+        id_type: str
+        vector_field_name: str
+        metric_type: str
+        timeout: float | None
+        schema: CollectionSchema | None
+        index_params: IndexParams | None
 
 
 class FetchKwargs(TypedDict, total=False):

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/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.dev6.dist-info → fabricatio-0.2.6.dev8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.6.dev6
+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.dev6.dist-info → fabricatio-0.2.6.dev8.dist-info}/RECORD

@@ -1,18 +1,18 @@
-fabricatio-0.2.6.dev6.dist-info/METADATA,sha256=9pqI0pxZslMJl25ehrBbGfOGeCikqwFGDVWNYwaAYXs,13693
-fabricatio-0.2.6.dev6.dist-info/WHEEL,sha256=7FgAcpQES0h1xhfN9Ugve9FTUilU6sRAr1WJ5ph2cuw,108
-fabricatio-0.2.6.dev6.dist-info/licenses/LICENSE,sha256=yDZaTLnOi03bi3Dk6f5IjhLUc5old2yOsihHWU0z-i0,1067
+fabricatio-0.2.6.dev8.dist-info/METADATA,sha256=GTgXD_uf_Sq2d3rQqEDNMSgnoEWI17uRXZqmUF53Ff4,13693
+fabricatio-0.2.6.dev8.dist-info/WHEEL,sha256=7FgAcpQES0h1xhfN9Ugve9FTUilU6sRAr1WJ5ph2cuw,108
+fabricatio-0.2.6.dev8.dist-info/licenses/LICENSE,sha256=yDZaTLnOi03bi3Dk6f5IjhLUc5old2yOsihHWU0z-i0,1067
 fabricatio/decorators.py,sha256=cJHsxxbnMhc4SzPl4454CPLuDP3H0qbTrzV_U2rLPrs,6372
 fabricatio/core.py,sha256=MaEKZ6DDmbdScAY-7F1gwGA6fr7ADX6Mz5rNVi2msFA,6277
 fabricatio/models/generic.py,sha256=WxT4KBGGZTpqGPSPVwD5mkmhYBjxggZ7n-HKi-Hed4M,13619
 fabricatio/models/tool.py,sha256=ATwbOyvOTzrfAKcbOmCqdG3je4-T5jrM6FIw4cDPRDY,6863
 fabricatio/models/role.py,sha256=UgIfGdfIBu4cOug8Nm1a04JCEwjXR_MDZUQhumwMptk,2710
-fabricatio/models/extra.py,sha256=tP58nLHlwgkM9F9EzVoDV7JP2n_1h-10uo2WRFouXuw,13448
-fabricatio/models/kwargs_types.py,sha256=VB_2X2cUdhD0syVl_5vPi0GU3qH5MjO7GiS44we9OO8,4468
-fabricatio/models/utils.py,sha256=snRuH81CQfTr9GZMSV_cW0JZocwfttgsKAqFWPk_Vc8,5480
-fabricatio/models/usages.py,sha256=ovuvDab9wvn9no4_a93HVcdo8Da1kF_eOnMoqph7LcY,30145
+fabricatio/models/extra.py,sha256=e6sWvmBG-U_ErxwITJ1wQGE3xsSuC18xnpxlU9gMY6M,25659
+fabricatio/models/kwargs_types.py,sha256=rqhCG2QLj4iyZ5WnLU4IT0xPdzFWvgsz9g6qau3bD1E,4839
+fabricatio/models/utils.py,sha256=E1Jz7oodbn09OkBspSpzCgKkv0AiuxyQElqCgHF7bVY,5718
+fabricatio/models/usages.py,sha256=ALB9V0Gfli2T9LDZ_gdvdChXwj6ieDeuK6Qye6NPXgE,30368
 fabricatio/models/events.py,sha256=UvOc6V3vfjKuvh7irDezJ8EGpsNo5yzLdq4xQexVonw,4063
 fabricatio/models/task.py,sha256=-EnzpEyM6Z687gF1lPcmA2szEUw6dFpu3lOtseaz95o,10193
-fabricatio/models/action.py,sha256=Y8fYLWi28edtmi9KZIlE9E7M9_G4GcWMeraTLPVjp_c,7992
+fabricatio/models/action.py,sha256=E8PELqsP9ZRwI7xQyXe5wqIPTGQsMk0sHKSnsic0S40,8359
 fabricatio/toolboxes/fs.py,sha256=OQMdeokYxSNVrCZJAweJ0cYiK4k2QuEiNdIbS5IHIV8,705
 fabricatio/toolboxes/__init__.py,sha256=dYm_Gd8XolSU_h4wnkA09dlaLDK146eeFz0CUgPZ8_c,380
 fabricatio/toolboxes/arithmetic.py,sha256=sSTPkKI6-mb278DwQKFO9jKyzc9kCx45xNH7V6bGBpE,1307
@@ -20,23 +20,23 @@ fabricatio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fabricatio/fs/readers.py,sha256=5bLlpqcdhIwWfysh7gvfVv0PPPVAeDlTPGwNTio6j9M,1156
 fabricatio/fs/curd.py,sha256=FuG75qco4dX8vhIK27gKz9rKUXbWHOFg5yK3nGLB25s,4469
 fabricatio/fs/__init__.py,sha256=hTuYtzmvIGtbg7PTdoqLEQJ0E63hOzZltCIrLlDKaSE,559
-fabricatio/config.py,sha256=6BXaIUZsfxuIvNOt74lmlBYoS_uBQhcCwGAmmxdvKZk,16232
+fabricatio/config.py,sha256=n5jU6j0SS8x3crJomwF8_6FI-UPGzEDsxL_zkxSZSkk,16352
 fabricatio/journal.py,sha256=Op0wC-JlZumnAc_aDmYM4ljnSNLoKEEMfcIRbCF69ow,455
 fabricatio/__init__.py,sha256=6EjK4SxbnvFxdO9ftkXD9rxSuoPEIITNzUkuMO9s3yU,1092
 fabricatio/actions/output.py,sha256=wNyLNxjqBlms0hyxap8XUPgN53izipJrCOtpX6aluFQ,626
-fabricatio/actions/rag.py,sha256=xCCNPM4pgjGlKaIl1J4SpWoNx3oWlSMxq6pQRSquXmc,788
+fabricatio/actions/rag.py,sha256=z1XJ8ZC1oJtVJvpUia8hSb0wnAA1uE61pRDt6QAzC3Y,980
 fabricatio/actions/article.py,sha256=m3ejPgLX7WXcg-CfqRjQmanc5qSvCsT_u02wW9Jb23w,4435
 fabricatio/_rust_instances.py,sha256=bQmlhUCcxTmRgvw1SfzYzNNpgW_UCjmkYw5f-VPAyg8,304
 fabricatio/workflows/articles.py,sha256=oHNV5kNKEcOKP55FA7I1SlxQRlk6N26cpem_QYu05g0,1021
 fabricatio/workflows/rag.py,sha256=uOZXprD479fUhLA6sYvEM8RWcVcUZXXtP0xRbTMPdHE,509
 fabricatio/parser.py,sha256=OV6bIAfLJ-GfaKoTeIOqS3X3GqCgyvzSJsgYMO3ogj4,6100
 fabricatio/capabilities/correct.py,sha256=BiLEAk6e1KbwUMhTexmDfgtlPUct_bG0igDK7CwHqao,5107
-fabricatio/capabilities/rag.py,sha256=hyQMgpFrefwMT84Huh728xsVQXNEYkUH2-98KJyfOas,15420
+fabricatio/capabilities/rag.py,sha256=FxhbHuEaeZudCSgqJD2S-hVZZAMG1Dro8dmLlRnXnEk,16075
 fabricatio/capabilities/rating.py,sha256=ZQrKKmmIgnN4zgNnG_GmWa5Nyxpk03JYW32RJ4R5vvQ,14067
 fabricatio/capabilities/review.py,sha256=TX7av4b2N7MRDHMowsIZfiujXRRNxjUMNHtCFVA1UTM,10824
 fabricatio/capabilities/propose.py,sha256=4QvONVVUp1rs34Te2Rjams6NioEt6FhEAxDWiveQnSg,1544
 fabricatio/capabilities/task.py,sha256=llFFKh8MAaTjsp8DtAGD_UUONROfFNxorh6NLys973U,4496
 fabricatio/_rust.pyi,sha256=1TvnaXK_QKM8Et05LkZ_vOGR4WISVd9X8lU6OTwFFaU,3376
-fabricatio/_rust.cpython-312-x86_64-linux-gnu.so,sha256=Qv4F28dducNx2GS8L8TmMWuk3MgBivQbzH_UmC-1P2w,1911376
-fabricatio-0.2.6.dev6.data/scripts/tdown,sha256=h7dazHQEgymw8fXo1ROyyUfwLMMw7l4JyMlt2xJyN-4,4576688
-fabricatio-0.2.6.dev6.dist-info/RECORD,,
+fabricatio/_rust.cpython-312-x86_64-linux-gnu.so,sha256=t1COw3bM_BmYYizdCwuFx_fq0PnhFPZO-zLJTJDkC40,1910320
+fabricatio-0.2.6.dev8.data/scripts/tdown,sha256=Y3fBi2TPyjMz2tt8bXf8yB263OBAHob40owbzNsJZvM,4578912
+fabricatio-0.2.6.dev8.dist-info/RECORD,,