fabricatio 0.2.4.dev0__cp312-cp312-win_amd64.whl → 0.2.4.dev1__cp312-cp312-win_amd64.whl

fabricatio/__init__.py

@@ -9,6 +9,7 @@ from fabricatio.fs import magika
 from fabricatio.journal import logger
 from fabricatio.models.action import Action, WorkFlow
 from fabricatio.models.events import Event
+from fabricatio.models.extra import ArticleEssence
 from fabricatio.models.role import Role
 from fabricatio.models.task import Task
 from fabricatio.models.tool import ToolBox
@@ -18,6 +19,7 @@ from fabricatio.toolboxes import arithmetic_toolbox, basic_toolboxes, fs_toolbox
 
 __all__ = [
     "Action",
+    "ArticleEssence",
     "Capture",
     "CodeBlockCapture",
     "Event",

fabricatio/actions/article.py

@@ -4,95 +4,12 @@ from os import PathLike
 from pathlib import Path
 from typing import Callable, List
 
-from pydantic import BaseModel, Field
-from pydantic.config import ConfigDict
-
 from fabricatio.journal import logger
 from fabricatio.models.action import Action
-from fabricatio.models.generic import ProposedAble
+from fabricatio.models.extra import ArticleEssence
 from fabricatio.models.task import Task
 
 
-class Equation(BaseModel):
-    """Structured representation of mathematical equations (including their physical or conceptual meanings)."""
-
-    model_config = ConfigDict(use_attribute_docstrings=True)
-
-    description: str = Field(...)
-    """A concise explanation of the equation's meaning, purpose, and relevance in the context of the research."""
-
-    latex_code: str = Field(...)
-    """The LaTeX code used to represent the equation in a publication-ready format."""
-
-
-class Figure(BaseModel):
-    """Structured representation of figures (including their academic significance and explanatory captions)."""
-
-    model_config = ConfigDict(use_attribute_docstrings=True)
-
-    description: str = Field(...)
-    """A detailed explanation of the figure's content and its role in conveying key insights."""
-
-    figure_caption: str = Field(...)
-    """The caption accompanying the figure, summarizing its main points and academic value."""
-
-
-class ArticleEssence(ProposedAble):
-    """Structured representation of the core elements of an academic paper(providing a comprehensive digital profile of the paper's essential information)."""
-
-    # Basic Metadata
-    title: str = Field(...)
-    """The full title of the paper, including any subtitles if applicable."""
-
-    authors: List[str] = Field(default_factory=list)
-    """A list of the paper's authors, typically in the order of contribution."""
-
-    keywords: List[str] = Field(default_factory=list)
-    """A list of keywords that summarize the paper's focus and facilitate indexing."""
-
-    publication_year: int = Field(None)
-    """The year in which the paper was published."""
-
-    # Core Content Elements
-    domain: List[str] = Field(default_factory=list)
-    """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)
-    """Key academic contributions that distinguish the paper from prior work in the field."""
-
-    technical_novelty: List[str] = Field(default_factory=list)
-    """Specific technical innovations introduced by the research, listed as individual points."""
-
-    # 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."""
-
-    highlighted_algorithms: List[str] = Field(default_factory=list)
-    """Pseudocode for key algorithms, annotated to highlight innovative components."""
-
-    highlighted_figures: List[Figure] = Field(default_factory=list)
-    """Critical diagrams or illustrations, each accompanied by a caption explaining their academic importance."""
-
-    highlighted_tables: List[str] = Field(default_factory=list)
-    """Important data tables, annotated to indicate statistical significance or other notable findings."""
-
-    # Academic Discussion Dimensions
-    research_problem: str = Field("")
-    """A clearly defined research question or problem addressed by the study."""
-
-    limitations: List[str] = Field(default_factory=list)
-    """An analysis of the methodological or experimental limitations of the research."""
-
-    future_work: List[str] = Field(default_factory=list)
-    """Suggestions for potential directions or topics for follow-up studies."""
-
-    impact_analysis: str = Field("")
-    """An assessment of the paper's potential influence on the development of the field."""
-
-
 class ExtractArticleEssence(Action):
     """Extract the essence of article(s)."""
 

fabricatio/capabilities/rating.py

@@ -131,8 +131,7 @@ class GiveRating(WithBriefing, LLMUsage):
 
         def _validator(response: str) -> Dict[str, str] | None:
             if (
-                (json_data := JsonCapture.convert_with(response, orjson.loads)) is not None
-                and isinstance(json_data, dict)
+                (json_data := JsonCapture.validate_with(response, target_type=dict, elements_type=str)) is not None
                 and json_data.keys() == criteria
                 and all(isinstance(v, str) for v in json_data.values())
             ):
@@ -173,11 +172,10 @@ class GiveRating(WithBriefing, LLMUsage):
 
         def _validator(response: str) -> Set[str] | None:
             if (
-                (json_data := JsonCapture.convert_with(response, orjson.loads)) is not None
-                and isinstance(json_data, list)
-                and all(isinstance(v, str) for v in json_data)
-                and (criteria_count == 0 or len(json_data) == criteria_count)
-            ):
+                json_data := JsonCapture.validate_with(
+                    response, target_type=list, elements_type=str, length=criteria_count
+                )
+            ) is not None:
                 return set(json_data)
             return None
 
@@ -219,27 +217,6 @@ class GiveRating(WithBriefing, LLMUsage):
         Returns:
             Set[str]: A set of drafted rating criteria.
         """
-
-        def _reasons_validator(response: str) -> List[str] | None:
-            if (
-                (json_data := JsonCapture.convert_with(response, orjson.loads)) is not None
-                and isinstance(json_data, list)
-                and all(isinstance(v, str) for v in json_data)
-                and len(json_data) == reasons_count
-            ):
-                return json_data
-            return None
-
-        def _criteria_validator(response: str) -> Set[str] | None:
-            if (
-                (json_data := JsonCapture.convert_with(response, orjson.loads)) is not None
-                and isinstance(json_data, list)
-                and all(isinstance(v, str) for v in json_data)
-                and len(json_data) == criteria_count
-            ):
-                return set(json_data)
-            return None
-
         kwargs = GenerateKwargs(system_message=f"# your personal briefing: \n{self.briefing}", **kwargs)
         # extract reasons from the comparison of ordered pairs of extracted from examples
         reasons = flatten(
@@ -256,7 +233,9 @@ class GiveRating(WithBriefing, LLMUsage):
                     )
                     for pair in (permutations(examples, 2))
                 ],
-                validator=_reasons_validator,
+                validator=lambda resp: JsonCapture.validate_with(
+                    resp, target_type=list, elements_type=str, length=reasons_count
+                ),
                 **kwargs,
             )
         )
@@ -272,7 +251,9 @@ class GiveRating(WithBriefing, LLMUsage):
                     },
                 )
             ),
-            validator=_criteria_validator,
+            validator=lambda resp: set(out)
+            if (out := JsonCapture.validate_with(resp, target_type=list, elements_type=str, length=criteria_count))
+            else None,
             **kwargs,
         )
 
@@ -295,11 +276,6 @@ class GiveRating(WithBriefing, LLMUsage):
         if len(criteria) < 2:  # noqa: PLR2004
             raise ValueError("At least two criteria are required to draft rating weights")
 
-        def _validator(resp: str) -> float | None:
-            if (cap := JsonCapture.convert_with(resp, orjson.loads)) is not None and isinstance(cap, float):
-                return cap
-            return None
-
         criteria = list(criteria)  # freeze the order
         windows = windowed(criteria, 2)
 
@@ -316,7 +292,7 @@ class GiveRating(WithBriefing, LLMUsage):
                 )
                 for pair in windows
             ],
-            validator=_validator,
+            validator=lambda resp: JsonCapture.validate_with(resp, target_type=float),
             **GenerateKwargs(system_message=f"# your personal briefing: \n{self.briefing}", **kwargs),
         )
         weights = [1]

fabricatio/models/action.py

@@ -92,9 +92,8 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
         Returns:
             Self: The instance of the workflow with the injected personality.
         """
-        for a in self._instances:
-            if not a.personality:
-                a.personality = personality
+        for a in filter(lambda action: not action.personality, self._instances):
+            a.personality = personality
         return self
 
     async def serve(self, task: Task) -> None:

fabricatio/models/extra.py

@@ -0,0 +1,96 @@
+"""Extra models for built-in actions."""
+
+from typing import List
+
+from fabricatio.models.generic import Display, PrepareVectorization, ProposedAble
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class Equation(BaseModel):
+    """Structured representation of mathematical equations (including their physical or conceptual meanings)."""
+
+    model_config = ConfigDict(use_attribute_docstrings=True)
+
+    description: str = Field(...)
+    """A concise explanation of the equation's meaning, purpose, and relevance in the context of the research."""
+
+    latex_code: str = Field(...)
+    """The LaTeX code used to represent the equation in a publication-ready format."""
+
+
+class Figure(BaseModel):
+    """Structured representation of figures (including their academic significance and explanatory captions)."""
+
+    model_config = ConfigDict(use_attribute_docstrings=True)
+
+    description: str = Field(...)
+    """A detailed explanation of the figure's content and its role in conveying key insights."""
+
+    figure_caption: str = Field(...)
+    """The caption accompanying the figure, summarizing its main points and academic value."""
+
+    figure_path: str = Field(...)
+    """The file path to the figure"""
+
+
+class Highlightings(BaseModel):
+    """Structured representation of highlighted elements in an academic paper (including equations, algorithms, figures, and tables)."""
+
+    # 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."""
+
+    highlighted_algorithms: List[str] = Field(default_factory=list)
+    """Pseudocode for key algorithms, annotated to highlight innovative components."""
+
+    highlighted_figures: List[Figure] = Field(default_factory=list)
+    """Critical diagrams or illustrations, each accompanied by a caption explaining their academic importance."""
+
+    highlighted_tables: List[str] = Field(default_factory=list)
+    """Important data tables, annotated to indicate statistical significance or other notable findings."""
+
+
+class ArticleEssence(ProposedAble, Display, PrepareVectorization):
+    """Structured representation of the core elements of an academic paper(providing a comprehensive digital profile of the paper's essential information)."""
+
+    # Basic Metadata
+    title: str = Field(...)
+    """The full title of the paper, including any subtitles if applicable."""
+
+    authors: List[str] = Field(default_factory=list)
+    """A list of the paper's authors, typically in the order of contribution."""
+
+    keywords: List[str] = Field(default_factory=list)
+    """A list of keywords that summarize the paper's focus and facilitate indexing."""
+
+    publication_year: int = Field(None)
+    """The year in which the paper was published."""
+
+    # Core Content Elements
+    domain: List[str] = Field(default_factory=list)
+    """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)
+    """Key academic contributions that distinguish the paper from prior work in the field."""
+
+    technical_novelty: List[str] = Field(default_factory=list)
+    """Specific technical innovations introduced by the research, listed as individual points."""
+
+    # Academic Discussion Dimensions
+    research_problem: str = Field("")
+    """A clearly defined research question or problem addressed by the study."""
+
+    limitations: List[str] = Field(default_factory=list)
+    """An analysis of the methodological or experimental limitations of the research."""
+
+    future_work: List[str] = Field(default_factory=list)
+    """Suggestions for potential directions or topics for follow-up studies."""
+
+    impact_analysis: str = Field("")
+    """An assessment of the paper's potential influence on the development of the field."""
+
+    def _prepare_vectorization_inner(self) -> str:
+        return self.model_dump_json()

fabricatio/models/generic.py

@@ -1,5 +1,6 @@
 """This module defines generic classes for models in the Fabricatio library."""
 
+from abc import abstractmethod
 from pathlib import Path
 from typing import Callable, Iterable, List, Optional, Self, Union, final
 
@@ -8,6 +9,7 @@ from fabricatio._rust import blake3_hash
 from fabricatio._rust_instances import template_manager
 from fabricatio.config import configs
 from fabricatio.fs.readers import magika, safe_text_read
+from fabricatio.journal import logger
 from fabricatio.parser import JsonCapture
 from pydantic import (
     BaseModel,
@@ -27,6 +29,18 @@ class Base(BaseModel):
     model_config = ConfigDict(use_attribute_docstrings=True)
 
 
+class Display(Base):
+    """Class that provides a method to display the model in a formatted JSON string."""
+
+    def display(self) -> str:
+        """Display the model in a formatted JSON string.
+
+        Returns:
+            str: The formatted JSON string of the model.
+        """
+        return self.model_dump_json(indent=1)
+
+
 class Named(Base):
     """Class that includes a name attribute."""
 
@@ -199,6 +213,28 @@ class WithDependency(Base):
         )
 
 
+class PrepareVectorization(Base):
+    """Class that prepares the vectorization of the model."""
+
+    @abstractmethod
+    def _prepare_vectorization_inner(self) -> str:
+        """Prepare the vectorization of the model."""
+
+    def prepare_vectorization(self, max_length: Optional[int] = None) -> str:
+        """Prepare the vectorization of the model.
+
+        Returns:
+            str: The prepared vectorization of the model.
+        """
+        max_length = max_length or configs.embedding.max_sequence_length
+        chunk = self._prepare_vectorization_inner()
+        if len(chunk) > max_length:
+            logger.error(err := f"Chunk exceeds maximum sequence length {max_length}.")
+            raise ValueError(err)
+
+        return chunk
+
+
 class ScopedConfig(Base):
     """Class that manages a scoped configuration."""
 

fabricatio/models/usages.py

@@ -5,7 +5,6 @@ from typing import Callable, Dict, Iterable, List, Optional, Self, Set, Type, Un
 
 import asyncstdlib
 import litellm
-import orjson
 from fabricatio._rust_instances import template_manager
 from fabricatio.config import configs
 from fabricatio.journal import logger
@@ -23,6 +22,7 @@ from litellm.types.utils import (
     StreamingChoices,
 )
 from litellm.utils import CustomStreamWrapper
+from more_itertools import duplicates_everseen
 from pydantic import Field, NonNegativeInt, PositiveInt
 
 
@@ -212,11 +212,10 @@ class LLMUsage(ScopedConfig):
                     **kwargs,
                 )
             ) and (validated := validator(response)):
-                logger.debug(f"Successfully validated the response at {i}th attempt. response: \n{response}")
+                logger.debug(f"Successfully validated the response at {i}th attempt.")
                 return validated
-            logger.debug(f"Failed to validate the response at {i}th attempt. response: \n{response}")
-        logger.error(f"Failed to validate the response after {max_validations} attempts.")
-        raise ValueError("Failed to validate the response.")
+        logger.error(err := f"Failed to validate the response after {max_validations} attempts.")
+        raise ValueError(err)
 
     async def aask_validate_batch[T](
         self,
@@ -255,7 +254,7 @@ class LLMUsage(ScopedConfig):
                 configs.templates.liststr_template,
                 {"requirement": requirement, "k": k},
             ),
-            lambda resp: JsonCapture.validate_with(resp, orjson.loads, list, str, k),
+            lambda resp: JsonCapture.validate_with(resp, target_type=list, elements_type=str, length=k),
             **kwargs,
         )
 
@@ -282,6 +281,9 @@ class LLMUsage(ScopedConfig):
             - Ensures response compliance through JSON parsing and format validation.
             - Relies on `aask_validate` to implement retry mechanisms with validation.
         """
+        if dup := duplicates_everseen(choices, key=lambda x: x.name):
+            logger.error(err := f"Redundant choices: {dup}")
+            raise ValueError(err)
         prompt = template_manager.render_template(
             configs.templates.make_choice_template,
             {
@@ -291,19 +293,16 @@ class LLMUsage(ScopedConfig):
             },
         )
         names = {c.name for c in choices}
+
         logger.debug(f"Start choosing between {names} with prompt: \n{prompt}")
 
         def _validate(response: str) -> List[T] | None:
-            ret = JsonCapture.convert_with(response, orjson.loads)
-
-            if not isinstance(ret, List) or (0 < k != len(ret)):
-                logger.error(f"Incorrect Type or length of response: \n{ret}")
-                return None
-            if any(n not in names for n in ret):
-                logger.error(f"Invalid choice in response: \n{ret}")
+            ret = JsonCapture.validate_with(response, target_type=List, elements_type=str, length=k)
+            if ret is None or set(ret) - names:
                 return None
-
-            return [next(toolbox for toolbox in choices if toolbox.name == toolbox_str) for toolbox_str in ret]
+            return [
+                next(candidate for candidate in choices if candidate.name == candidate_name) for candidate_name in ret
+            ]
 
         return await self.aask_validate(
             question=prompt,
@@ -357,19 +356,12 @@ class LLMUsage(ScopedConfig):
         Returns:
             bool: The judgment result (True or False) based on the AI's response.
         """
-
-        def _validate(response: str) -> bool | None:
-            ret = JsonCapture.convert_with(response, orjson.loads)
-            if not isinstance(ret, bool):
-                return None
-            return ret
-
         return await self.aask_validate(
             question=template_manager.render_template(
                 configs.templates.make_judgment_template,
                 {"prompt": prompt, "affirm_case": affirm_case, "deny_case": deny_case},
             ),
-            validator=_validate,
+            validator=lambda resp: JsonCapture.validate_with(resp, target_type=bool),
             **kwargs,
         )
 

fabricatio/parser.py

@@ -2,6 +2,7 @@
 
 from typing import Any, Callable, Optional, Self, Tuple, Type
 
+import orjson
 import regex
 from pydantic import BaseModel, ConfigDict, Field, PositiveInt, PrivateAttr, ValidationError
 from regex import Pattern, compile
@@ -27,11 +28,7 @@ class Capture(BaseModel):
     _compiled: Pattern = PrivateAttr()
 
     def model_post_init(self, __context: Any) -> None:
-        """Initialize the compiled regular expression pattern after the model is initialized.
-
-        Args:
-            __context (Any): The context in which the model is initialized.
-        """
+        """Initialize the compiled pattern."""
         self._compiled = compile(self.pattern, self.flags)
 
     def capture(self, text: str) -> Tuple[str, ...] | str | None:
@@ -69,7 +66,6 @@ class Capture(BaseModel):
         if (cap := self.capture(text)) is None:
             return None
         try:
-            logger.debug(f"Trying to convert: \n{cap}")
             return convertor(cap)
         except (ValueError, SyntaxError, ValidationError) as e:
             logger.error(f"Failed to convert text using {convertor.__name__} to convert.\nerror: {e}\n {cap}")
@@ -78,19 +74,19 @@ class Capture(BaseModel):
     def validate_with[K, T, E](
         self,
         text: str,
-        deserializer: Callable[[Tuple[str, ...]], K] | Callable[[str], K],
         target_type: Type[T],
         elements_type: Optional[Type[E]] = None,
         length: Optional[int] = None,
+        deserializer: Callable[[Tuple[str, ...]], K] | Callable[[str], K] = orjson.loads,
     ) -> T | None:
         """Validate the given text using the pattern.
 
         Args:
             text (str): The text to search the pattern in.
-            deserializer (Callable[[Tuple[str, ...]], K] | Callable[[str], K]): The function to deserialize the captured text.
-            target_type (Type[T]): The expected type of the output.
-            elements_type (Optional[Type[E]]): The expected type of the elements in the output.
+            target_type (Type[T]): The expected type of the output, dict or list.
+            elements_type (Optional[Type[E]]): The expected type of the elements in the output dict keys or list elements.
             length (Optional[int]): The expected length of the output, bool(length)==False means no length validation.
+            deserializer (Callable[[Tuple[str, ...]], K] | Callable[[str], K]): The function to deserialize the captured text.
 
         Returns:
             T | None: The validated text if the pattern is found and the output is of the expected type, otherwise None.

{fabricatio-0.2.4.dev0.dist-info → fabricatio-0.2.4.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.4.dev0
+Version: 0.2.4.dev1
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12

{fabricatio-0.2.4.dev0.dist-info → fabricatio-0.2.4.dev1.dist-info}/RECORD

@@ -1,11 +1,11 @@
-fabricatio-0.2.4.dev0.dist-info/METADATA,sha256=1sPsuFY-rBXRPE-zNVr6RXMNQ_f9q0idfNN3aUVG6Tw,8861
-fabricatio-0.2.4.dev0.dist-info/WHEEL,sha256=tpW5AN9B-9qsM9WW2FXG2r193YXiqexDadpKp0A2daI,96
-fabricatio-0.2.4.dev0.dist-info/licenses/LICENSE,sha256=do7J7EiCGbq0QPbMAL_FqLYufXpHnCnXBOuqVPwSV8Y,1088
-fabricatio/actions/article.py,sha256=WEKGqSx7tAhCMB0ziHVlDIYQywnUAH0R_Ha49xuJSdY,5483
+fabricatio-0.2.4.dev1.dist-info/METADATA,sha256=_gk2kBD669jBzVql6w4SSnaMHDkJlQ393i-7QyJBock,8861
+fabricatio-0.2.4.dev1.dist-info/WHEEL,sha256=tpW5AN9B-9qsM9WW2FXG2r193YXiqexDadpKp0A2daI,96
+fabricatio-0.2.4.dev1.dist-info/licenses/LICENSE,sha256=do7J7EiCGbq0QPbMAL_FqLYufXpHnCnXBOuqVPwSV8Y,1088
+fabricatio/actions/article.py,sha256=8T_ZqNs8OPxL2nTQ5D0YsOMQ7R5_TBf7oM5dbPmMbe8,1654
 fabricatio/actions/__init__.py,sha256=CjlbRaRqqKWPxqZEtk7tQt3Mul17CY9O4alo6VjWGNk,130
 fabricatio/capabilities/propose.py,sha256=nahXjB6_nP0Fru880oh_9oINrjrL0Qs-SLHA-d3CFUE,1769
 fabricatio/capabilities/rag.py,sha256=paq2zUOfw6whIBFkKDo1Kg5Ft5YXgWiJBNKq-6uGhuU,13295
-fabricatio/capabilities/rating.py,sha256=zmTUvsUfxFgovRQzy4djL2zKRYTHmN6JY7A4lyT5uVQ,14907
+fabricatio/capabilities/rating.py,sha256=PcUpKxPfVO-vitgA6py1xg9iLJZdf7Fru--18ZUFKKA,14026
 fabricatio/capabilities/task.py,sha256=s6FiC9Wg_l-qSa2LgsoKV9f6wXZN6Q_FlWn3XbSnrys,4618
 fabricatio/config.py,sha256=yPJjrGhvoWyXfLBTJp2pMvHt9F-0uskE-va7QDo0rxI,13525
 fabricatio/core.py,sha256=VQ_JKgUGIy2gZ8xsTBZCdr_IP7wC5aPg0_bsOmjQ588,6458
@@ -14,16 +14,17 @@ fabricatio/fs/curd.py,sha256=faMstgGUiQ4k2AW3OXfvvWWTldTtKXco7QINYaMjmyA,3981
 fabricatio/fs/readers.py,sha256=Pz1-cdZYtmqr032dsroImlkFXAd0kCYY_9qVpD4UrG4,1045
 fabricatio/fs/__init__.py,sha256=lWcKYg0v3mv2LnnSegOQaTtlVDODU0vtw_s6iKU5IqQ,122
 fabricatio/journal.py,sha256=siqimKF0M_QaaOCMxtjr_BJVNyUIAQWILzE9Q4T6-7c,781
-fabricatio/models/action.py,sha256=VhSXPmHjICaypz6qB-RE7dzvdrL9lbvhY4og32Q-DPI,5939
+fabricatio/models/action.py,sha256=HVU0cAOuiBszRJrOskFASwt1yxSO7HCP4epS03p92WU,5947
 fabricatio/models/events.py,sha256=pt-WkFhhA5SXmp6-3Vb_o_7I5xbKoTCJ22GAK7YYwpA,4101
-fabricatio/models/generic.py,sha256=_9GawiKlNMumLH0DqjSkG-ZJ2oKa-8Vcyi2yw-R6lUk,10659
+fabricatio/models/extra.py,sha256=0v5v0a_xcXcDTeIDmwtzUO68HjrmVvLHM6ALWvl9h6w,4328
+fabricatio/models/generic.py,sha256=3S16T7nZEDhDF-VLSmRPa7NEtapZjU5WQHosoisqbTw,11843
 fabricatio/models/kwargs_types.py,sha256=Xhy5LcTB1oWBGVGipLf5y_dTb7tBzMO5QAQdEfZeI9I,1786
 fabricatio/models/role.py,sha256=gYvleTeKUGDUNKPAC5B0EPMLC4jZ4vHsFHmHiVXkU6c,1830
 fabricatio/models/task.py,sha256=BRE3XBQXTXH7UHsJDN7UzxIBRQbDVf7T4a00_111inw,10996
 fabricatio/models/tool.py,sha256=WTFnpF6xZ1nJbmIOonLsGQcM-kkDCeZiAFqyil9xg2U,6988
-fabricatio/models/usages.py,sha256=wLKzJ6dzik6RBgyK-sLdmzginPeuBOcsB7RQXO0Nvjo,25804
+fabricatio/models/usages.py,sha256=EdQrjAltM_D-WBvzPtzF11npGA1fpF1JGwDLDHYxCyQ,25535
 fabricatio/models/utils.py,sha256=QI3bYrKBbzLbKvyzVrZXGcWq3trOOTE-hQAC_WNvjMg,4457
-fabricatio/parser.py,sha256=BKYaXieHveo99xFay8YyYBa9Uo1-DwCZ-Fzx-k_CMeI,5051
+fabricatio/parser.py,sha256=qNYshYtuwbZHZG1kQKYYHZOzYhDO4DZJJYh2k4Imz3s,4911
 fabricatio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fabricatio/toolboxes/arithmetic.py,sha256=WLqhY-Pikv11Y_0SGajwZx3WhsLNpHKf9drzAqOf_nY,1369
 fabricatio/toolboxes/fs.py,sha256=YkNgon5-bvCiPVEND9971W-6wj8btKNL6nGry2otn9I,498
@@ -31,7 +32,7 @@ fabricatio/toolboxes/task.py,sha256=kU4a501awIDV7GwNDuSlK3_Ym-5OhCp5sS-insTmUmQ,
 fabricatio/toolboxes/__init__.py,sha256=b13KmASO8q5fBLwew964fn9oH86ER5g-S1PgA4fZ_xs,482
 fabricatio/_rust.pyi,sha256=0wCqtwWkVxxoqprvk8T27T8QYKIAKHS7xgsmdMNjQKc,1756
 fabricatio/_rust_instances.py,sha256=dl0-yZ4UvT5g20tQgnPJpmqtkjFGXNG_YK4eLfi_ugQ,279
-fabricatio/__init__.py,sha256=cj0E_rYiyGckvMy-hiXSKxNWwF-drkj4NGOXq5eZHuw,1330
-fabricatio/_rust.cp312-win_amd64.pyd,sha256=6jqod91J-z0dk_plffA1H5DPttEA1Ksfy5ZFM-87GQE,1256448
-fabricatio-0.2.4.dev0.data/scripts/tdown.exe,sha256=7sUpScFur_OgeyVJKmyP4HHzRk2pnPHVAtG8VAUNlNE,3395584
-fabricatio-0.2.4.dev0.dist-info/RECORD,,
+fabricatio/__init__.py,sha256=lk9xEYWoiGdsIPjTCdoZ85tz0a7SDjXm6ORaxGx-dYw,1405
+fabricatio/_rust.cp312-win_amd64.pyd,sha256=OyB3QxCCDgBSoyWf_sseCWdRhXrQ9HqBrb7Vk7QEN7Y,1256448
+fabricatio-0.2.4.dev1.data/scripts/tdown.exe,sha256=aRm7EGhU3Mr6brN3iWId7kCKojnttdHnjI0M7Ap2vr0,3397632
+fabricatio-0.2.4.dev1.dist-info/RECORD,,