fabricatio 0.2.4.dev0__cp312-cp312-manylinux_2_34_x86_64.whl → 0.2.4.dev2__cp312-cp312-manylinux_2_34_x86_64.whl

fabricatio/__init__.py

@@ -3,12 +3,13 @@
 from importlib.util import find_spec
 
 from fabricatio._rust_instances import template_manager
-from fabricatio.actions import ExtractArticleEssence
+from fabricatio.actions.article import ExtractArticleEssence
 from fabricatio.core import env
 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",
@@ -42,6 +44,8 @@ __all__ = [
 
 
 if find_spec("pymilvus"):
+    from fabricatio.actions.rag import InjectToDB
     from fabricatio.capabilities.rag import RAG
+    from fabricatio.workflows.articles import StoreArticle
 
-    __all__ += ["RAG"]
+    __all__ += ["RAG", "InjectToDB", "StoreArticle"]

fabricatio/actions/article.py

@@ -4,101 +4,23 @@ 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)."""
+    """Extract the essence of article(s) in text format from the paths specified in the task dependencies.
+
+    Notes:
+        This action is designed to extract vital information from articles with Markdown format, which is pure text, and
+        which is converted from pdf files using `magic-pdf` from the `MinerU` project, see https://github.com/opendatalab/MinerU
+    """
 
     name: str = "extract article essence"
     """The name of the action."""
-    description: str = "Extract the essence of an article. output as json"
+    description: str = "Extract the essence of article(s) from the paths specified in the task dependencies."
     """The description of the action."""
 
     output_key: str = "article_essence"

fabricatio/actions/rag.py

@@ -0,0 +1,25 @@
+"""Inject data into the database."""
+
+from typing import List, Optional, Unpack
+
+from fabricatio.capabilities.rag import RAG
+from fabricatio.models.action import Action
+from fabricatio.models.generic import PrepareVectorization
+
+
+class InjectToDB(Action, RAG):
+    """Inject data into the database."""
+
+    output_key: str = "collection_name"
+
+    async def _execute[T: PrepareVectorization](
+        self, to_inject: T | List[T], collection_name: Optional[str] = "my_collection", **cxt: Unpack
+    ) -> str:
+        if not isinstance(to_inject, list):
+            to_inject = [to_inject]
+
+        await self.view(collection_name, create=True).consume_string(
+            [t.prepare_vectorization(self.embedding_max_sequence_length) for t in to_inject],
+        )
+
+        return collection_name

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/fs/__init__.py

@@ -1,5 +1,17 @@
 """FileSystem manipulation module for Fabricatio."""
 
-from fabricatio.fs.readers import magika
+from fabricatio.fs.curd import copy_file, create_directory, delete_directory, delete_file, dump_text, move_file, tree
+from fabricatio.fs.readers import magika, safe_json_read, safe_text_read
 
-__all__ = ["magika"]
+__all__ = [
+    "copy_file",
+    "create_directory",
+    "delete_directory",
+    "delete_file",
+    "dump_text",
+    "magika",
+    "move_file",
+    "safe_json_read",
+    "safe_text_read",
+    "tree",
+]

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
+from typing import Any, Dict, Self, Tuple, Type, Union, Unpack, final
 
 from fabricatio.capabilities.rating import GiveRating
 from fabricatio.capabilities.task import HandleTask, ProposeTask
@@ -17,11 +17,26 @@ from pydantic import Field, PrivateAttr
 class Action(HandleTask, ProposeTask, GiveRating):
     """Class that represents an action to be executed in a workflow."""
 
+    name: str = Field(default="")
+    """The name of the action."""
+    description: str = Field(default="")
+    """The description of the action."""
     personality: str = Field(default="")
     """The personality of whom the action belongs to."""
     output_key: str = Field(default="")
     """The key of the output data."""
 
+    @final
+    def model_post_init(self, __context: Any) -> None:
+        """Initialize the action by setting the name if not provided.
+
+        Args:
+            __context: The context to be used for initialization.
+        """
+        self.name = self.name or self.__class__.__name__
+
+        self.description = self.description or self.__class__.__doc__ or ""
+
     @abstractmethod
     async def _execute(self, **cxt: Unpack) -> Any:
         """Execute the action with the provided arguments.
@@ -34,6 +49,7 @@ class Action(HandleTask, ProposeTask, GiveRating):
         """
         pass
 
+    @final
     async def act(self, cxt: Dict[str, Any]) -> Dict[str, Any]:
         """Perform the action by executing it and setting the output data.
 
@@ -92,9 +108,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/workflows/articles.py

@@ -0,0 +1,11 @@
+"""Store article essence in the database."""
+
+from fabricatio.actions.article import ExtractArticleEssence
+from fabricatio.actions.rag import InjectToDB
+from fabricatio.models.action import WorkFlow
+
+StoreArticle = WorkFlow(
+    name="Extract Article Essence",
+    description="Extract the essence of an article in the given path, and store it in the database.",
+    steps=(ExtractArticleEssence(output_key="to_inject"), InjectToDB(output_key="task_output")),
+)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.4.dev0
+Version: 0.2.4.dev2
 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.dev2.dist-info}/RECORD

@@ -1,17 +1,18 @@
-fabricatio-0.2.4.dev0.dist-info/METADATA,sha256=hICA67yn6cUUPalAXtrEkZCyhF1VHSk3MG0gg4up78c,8589
-fabricatio-0.2.4.dev0.dist-info/WHEEL,sha256=RIvmwLDYujv60MYBx2jxyP4vdn1DD7X0kBgz1TQvZuc,108
-fabricatio-0.2.4.dev0.dist-info/licenses/LICENSE,sha256=yDZaTLnOi03bi3Dk6f5IjhLUc5old2yOsihHWU0z-i0,1067
+fabricatio-0.2.4.dev2.dist-info/METADATA,sha256=vhANe4uPf0Sg_UmcfdmjBD9GI44lY6XrlLz0OFf4bQk,8589
+fabricatio-0.2.4.dev2.dist-info/WHEEL,sha256=RIvmwLDYujv60MYBx2jxyP4vdn1DD7X0kBgz1TQvZuc,108
+fabricatio-0.2.4.dev2.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=IYqVXgWFl0P_lfWyT7AwZszT0FOkeLbDZb0xrno86q8,10356
+fabricatio/models/generic.py,sha256=bjAD8g4tz1VjnIfnpTD6sRu1dBuBoswmUrn6pCnL6aY,11504
 fabricatio/models/tool.py,sha256=wgNXtobDSWZTVmIrSSaS5oyxhSUYWXhS0S2o9acE2ls,6800
 fabricatio/models/role.py,sha256=fAYH8EYpt8ad2uKRV9PVjDNqHuGLxY6_s36mXM0S5I0,1782
+fabricatio/models/extra.py,sha256=MC6l23iKv-DRkHDAZryFY9Rsvs244YVqe4VOHvO0-u8,4232
 fabricatio/models/kwargs_types.py,sha256=ZxqJhLnwMhrV0La_q8IBi3DfRd9bHDS8vI_kukZaeUE,1727
 fabricatio/models/utils.py,sha256=vahILaesw50ofFft-wZ9kZ_Qogqi6vIOISWczvwVXxk,4311
-fabricatio/models/usages.py,sha256=ZsHCBixB1lgWbmcGjaavF92dtAec3hRb9ku4imFCyrE,25204
+fabricatio/models/usages.py,sha256=iXh4MbDhrzshOxH704NY_5nbt7Lx5ckyBCs_nboxlM8,24943
 fabricatio/models/events.py,sha256=sBCKeNoYc4TFDoke-jhFEyA11RcdGu-wdF5ynAuVOMM,3983
 fabricatio/models/task.py,sha256=A0xdbrMeqhWqpmoMplTuaZmsKKHl93InZJ2iKjaRNBA,10683
-fabricatio/models/action.py,sha256=QkF9pWwotXzb276EzjHRm9pJbrPv8dsiiLnWmhvLa8A,5794
+fabricatio/models/action.py,sha256=CYg4YPOo_NhAl8Nm8bCoEJkF4xPZZ-ZsVJmABrx2u_Q,6335
 fabricatio/toolboxes/fs.py,sha256=oZjGOmtN8ZbkMXxCMatqvdPavVXyQ87AEDc1lx9jimY,483
 fabricatio/toolboxes/__init__.py,sha256=iEBsH0aRPLccIe6eyZ6iH5GdK8yYNQTnCwLzw4pWXAA,465
 fabricatio/toolboxes/arithmetic.py,sha256=sSTPkKI6-mb278DwQKFO9jKyzc9kCx45xNH7V6bGBpE,1307
@@ -19,19 +20,20 @@ fabricatio/toolboxes/task.py,sha256=9J3W-48CCEUh5PFz0XEC47Hv23Ugn1BEg-J_woQE1UA,
 fabricatio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fabricatio/fs/readers.py,sha256=lqMrM5Nt3l6QJmPDoBno2PSaN2BbFwfUjBqaghrbK3A,1002
 fabricatio/fs/curd.py,sha256=g74Pc2WPSkPlCXX0cWj2jyiDYTfkLwpwM480eyCkmc8,3851
-fabricatio/fs/__init__.py,sha256=bYE9r8uR0dtknzbg_YaGv_6Wwa27ntkQt0Tl7Kb3HFI,117
+fabricatio/fs/__init__.py,sha256=Jlzk4AvBFgcgQ6nIgGRSUIh2UZHtpl27eyu395lR3c0,448
 fabricatio/config.py,sha256=ZUUJ5rb6ZBq8Vrkk9wqfMU8ncomRoHgarW7YuThEJK4,13188
 fabricatio/journal.py,sha256=bzxZay48ZWI0VIkkDXm4Wc_Cc9lBQYa2VGx3Hxy_PtA,753
-fabricatio/__init__.py,sha256=VzAmPXKs_X3BTrIxghx2mPJpBUTCJXW-Taj3Jh3aOaY,1283
-fabricatio/actions/__init__.py,sha256=ggTW1wZntPjWP-JHEZe1vqoyImmUnCt15h40zC5rx98,125
-fabricatio/actions/article.py,sha256=OEM73Tl0dDQ6tv_Mo5IPgIkxBXmP0pPzlIXraA8VVFw,5356
+fabricatio/__init__.py,sha256=gakP6hzHIQccKu9ByHhUP-cN36wCPEr11s13iTdO6EY,1503
+fabricatio/actions/rag.py,sha256=tP1uKLq7mo19YhsJzFbGYryrcMx6xcvBc3n_Wzh0hjg,796
+fabricatio/actions/article.py,sha256=ozqEa75_MS4OfCJZzcmF5_s3AJmAUrQGdHORWtZBsE0,1977
 fabricatio/_rust_instances.py,sha256=JAtO-vL8ihvduf1SHLNf0w7ZSVGCJeIv6zZ9Ekyy1hY,271
-fabricatio/parser.py,sha256=OfSydx0RuLpS6-LJn-SC07Ml-9LWDGYHQtTxw4a5sGk,4927
+fabricatio/workflows/articles.py,sha256=KlTaMSnxkQqHAIl-zZ8_wMqheka7IL99nt7XzQxDSF0,462
+fabricatio/parser.py,sha256=S-4p1mjvJZEgnQW6WKdkmE68MzqqWXGSiLbADdhE-W4,4791
 fabricatio/capabilities/rag.py,sha256=bF-SSZRQbG00QjzoAXrWCfzFxHxfvxV3al_G8T4jxL8,12985
-fabricatio/capabilities/rating.py,sha256=KLJlaufG74lHJ5hHI_tjhQgjWjHhO_38Q1ILW2cY9fA,14552
+fabricatio/capabilities/rating.py,sha256=E1obAS48B4j3Cf6rC6h-TyzRb4vQ2Hho2IM7630jSoI,13695
 fabricatio/capabilities/propose.py,sha256=oW9QKpY2mDkVPEvgsgqxXxDR2ylVqN5TEL8E0Wh_vJI,1714
 fabricatio/capabilities/task.py,sha256=BISAFbMgBI4udW0otE3-iyq0RXc05YN_30N0yI5qLxQ,4504
 fabricatio/_rust.pyi,sha256=clhcURuiB9zlFo4m3VyoWQ8Xs4tvg6KNHXpF-ok9h4o,1703
-fabricatio/_rust.cpython-312-x86_64-linux-gnu.so,sha256=eP8GSsTL0qiNnmvzSulYsxzpsZ2WyZsEGMlybWAw-pE,1337776
-fabricatio-0.2.4.dev0.data/scripts/tdown,sha256=uRk-kMQa9Vx1jBOxzJZ8j-Zj0d0Z-XUpmbrpgJ9bdzA,4557256
-fabricatio-0.2.4.dev0.dist-info/RECORD,,
+fabricatio/_rust.cpython-312-x86_64-linux-gnu.so,sha256=CDyz4oafWsO46rOc8DyHBfDVj4dY2LkheAQTGfSXmgs,1333952
+fabricatio-0.2.4.dev2.data/scripts/tdown,sha256=lUUKFHytXf1um4ZhtzvZlMqpBPWN7IjAsKKT9IgDwog,4560064
+fabricatio-0.2.4.dev2.dist-info/RECORD,,

fabricatio/actions/__init__.py

@@ -1,5 +0,0 @@
-"""module for actions."""
-
-from fabricatio.actions.article import ExtractArticleEssence
-
-__all__ = ["ExtractArticleEssence"]