fabricatio 0.2.5.dev2__tar.gz → 0.2.5.dev3__tar.gz

{fabricatio-0.2.5.dev2 → fabricatio-0.2.5.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.5.dev2
+Version: 0.2.5.dev3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12

fabricatio-0.2.5.dev3/examples/extract_and_review/.gitignore

@@ -0,0 +1 @@
+bpdf_out

fabricatio-0.2.5.dev3/examples/extract_and_review/extract_and_review.py

@@ -0,0 +1,37 @@
+"""Example of proposing a task to a role."""
+
+import asyncio
+from pathlib import Path
+from typing import List
+
+from fabricatio import ArticleEssence, Event, ExtractArticleEssence, Role, Task, WorkFlow, logger
+from fabricatio.fs.curd import dump_text, gather_files
+
+
+async def main() -> None:
+    """Main function."""
+    role = Role(
+        name="Researcher",
+        description="Extract article essence",
+        registry={
+            Event.quick_instantiate("article"): WorkFlow(
+                name="extract",
+                steps=(ExtractArticleEssence(output_key="task_output"),),
+            )
+        },
+    )
+
+    task: Task[List[ArticleEssence]] = await role.propose_task(
+        "Extract the essence of the article from the files in './bpdf_out'",
+    )
+
+    ess = await task.override_dependencies(gather_files("bpdf_out", "md")).delegate("article")
+    logger.success(f"Essence Count:{len(ess)}")
+
+    Path("output").mkdir(exist_ok=True)
+    for i, e in enumerate(ess):
+        dump_text(f"output/{i}.json", e.display())
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

{fabricatio-0.2.5.dev2 → fabricatio-0.2.5.dev3}/pyproject.toml

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

{fabricatio-0.2.5.dev2 → fabricatio-0.2.5.dev3}/python/fabricatio/_rust.pyi

@@ -99,4 +99,4 @@ class BibManager:
         Notes:
             Uses nucleo_matcher for high-quality fuzzy text searching
             See: https://crates.io/crates/nucleo-matcher
-        """
+        """

{fabricatio-0.2.5.dev2 → fabricatio-0.2.5.dev3}/python/fabricatio/_rust_instances.py

@@ -1,7 +1,6 @@
 """Some necessary instances."""
 
 from fabricatio._rust import TemplateManager
-
 from fabricatio.config import configs
 
 template_manager = TemplateManager(

{fabricatio-0.2.5.dev2 → fabricatio-0.2.5.dev3}/python/fabricatio/capabilities/propose.py

@@ -15,7 +15,7 @@ class Propose[M: ProposedAble](LLMUsage):
         self,
         cls: Type[M],
         prompt: List[str],
-        **kwargs: Unpack[GenerateKwargs],
+        **kwargs: Unpack[GenerateKwargs[M]],
     ) -> List[M]: ...
 
     @overload
@@ -23,14 +23,14 @@ class Propose[M: ProposedAble](LLMUsage):
         self,
         cls: Type[M],
         prompt: str,
-        **kwargs: Unpack[GenerateKwargs],
+        **kwargs: Unpack[GenerateKwargs[M]],
     ) -> M: ...
 
     async def propose(
         self,
         cls: Type[M],
         prompt: List[str] | str,
-        **kwargs: Unpack[GenerateKwargs],
+        **kwargs: Unpack[GenerateKwargs[M]],
     ) -> List[M] | M:
         """Asynchronously proposes a task based on a given prompt and parameters.
 

{fabricatio-0.2.5.dev2 → fabricatio-0.2.5.dev3}/python/fabricatio/capabilities/rating.py

@@ -2,6 +2,7 @@
 
 from asyncio import gather
 from itertools import permutations
+from random import sample
 from typing import Dict, List, Set, Tuple, Union, Unpack, overload
 
 from fabricatio._rust_instances import template_manager
@@ -16,7 +17,11 @@ from pydantic import NonNegativeInt, PositiveInt
 
 
 class GiveRating(WithBriefing, LLMUsage):
-    """A class that provides functionality to rate tasks based on a rating manual and score range."""
+    """A class that provides functionality to rate tasks based on a rating manual and score range.
+
+    References:
+        Lu X, Li J, Takeuchi K, et al. AHP-powered LLM reasoning for multi-criteria evaluation of open-ended responses[A/OL]. arXiv, 2024. DOI: 10.48550/arXiv.2410.01246.
+    """
 
     async def rate_fine_grind(
         self,
@@ -187,6 +192,7 @@ class GiveRating(WithBriefing, LLMUsage):
         self,
         topic: str,
         examples: List[str],
+        m: NonNegativeInt = 0,
         reasons_count: PositiveInt = 2,
         criteria_count: PositiveInt = 5,
         **kwargs: Unpack[ValidateKwargs],
@@ -199,13 +205,21 @@ class GiveRating(WithBriefing, LLMUsage):
         Parameters:
             topic (str): The subject topic for the rating criteria.
             examples (List[str]): A list of example texts to analyze.
+            m (NonNegativeInt, optional): The number of examples to sample from the provided list. Defaults to 0 (no sampling).
             reasons_count (PositiveInt, optional): The number of reasons to extract from each pair of examples. Defaults to 2.
             criteria_count (PositiveInt, optional): The final number of rating criteria to draft. Defaults to 5.
             **kwargs (Unpack[ValidateKwargs]): Additional keyword arguments for validation.
 
         Returns:
             Set[str]: A set of drafted rating criteria.
+
+        Warnings:
+            Since this function uses pairwise comparisons, it may not be suitable for large lists of examples.
+            For that reason, consider using a smaller list of examples or setting `m` to a non-zero value smaller than the length of the examples.
         """
+        if m:
+            examples = sample(examples, m)
+
         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(

{fabricatio-0.2.5.dev2 → fabricatio-0.2.5.dev3}/python/fabricatio/capabilities/review.py

@@ -11,6 +11,7 @@ from fabricatio.models.kwargs_types import GenerateKwargs, ReviewKwargs
 from fabricatio.models.task import Task
 from pydantic import PrivateAttr
 from questionary import Choice, checkbox
+from rich import print
 
 
 class ProblemSolutions(Base):
@@ -78,6 +79,18 @@ class ReviewResult[T](ProposedAble, Display):
     _ref: T = PrivateAttr(None)
     """Reference to the original object that was reviewed."""
 
+    def update_topic(self, topic: str) -> Self:
+        """Update the review topic.
+
+        Args:
+            topic (str): The new topic to be associated with this review.
+
+        Returns:
+            Self: The current instance with updated review topic.
+        """
+        self.review_topic = topic
+        return self
+
     def update_ref[K](self, ref: K) -> "ReviewResult[K]":
         """Update the reference to the reviewed object.
 
@@ -111,9 +124,18 @@ class ReviewResult[T](ProposedAble, Display):
         Returns:
             Self: The current instance with filtered problems and solutions.
         """
+        if isinstance(self._ref, str):
+            display = self._ref
+        elif isinstance(self._ref, WithBriefing):
+            display = self._ref.briefing
+        elif isinstance(self._ref, Display):
+            display = self._ref.display()
+        else:
+            raise TypeError(f"Unsupported type for review: {type(self._ref)}")
         # Choose the problems to retain
+        print(display)
         chosen_ones: List[ProblemSolutions] = await checkbox(
-            f"Please choose the problems you want to retain, under the topic of `{self.review_topic}`.(Default: retain all)",
+            f"Please choose the problems you want to retain.(Default: retain all)\n\t`{self.review_topic}`",
             choices=[Choice(p.problem, p, checked=True) for p in self.problem_solutions],
         ).ask_async()
         if not check_solutions:
@@ -124,7 +146,7 @@ class ReviewResult[T](ProposedAble, Display):
         for to_exam in chosen_ones:
             to_exam.update_solutions(
                 await checkbox(
-                    f"Please choose the solutions you want to retain, under the problem of `{to_exam.problem}`.(Default: retain all)",
+                    f"Please choose the solutions you want to retain.(Default: retain all)\n\t`{to_exam.problem}`",
                     choices=[Choice(s, s, checked=True) for s in to_exam.solutions],
                 ).ask_async()
             )
@@ -159,7 +181,11 @@ class Review(GiveRating, Propose):
         return await self.review_obj(task, **kwargs)
 
     async def review_string(
-        self, text: str, topic: str, criteria: Optional[Set[str]] = None, **kwargs: Unpack[GenerateKwargs]
+        self,
+        text: str,
+        topic: str,
+        criteria: Optional[Set[str]] = None,
+        **kwargs: Unpack[GenerateKwargs[ReviewResult[str]]],
     ) -> ReviewResult[str]:
         """Review a string based on specified topic and criteria.
 
@@ -186,7 +212,7 @@ class Review(GiveRating, Propose):
             ),
             **kwargs,
         )
-        return res.update_ref(text)
+        return res.update_ref(text).update_topic(topic)
 
     async def review_obj[M: (Display, WithBriefing)](self, obj: M, **kwargs: Unpack[ReviewKwargs]) -> ReviewResult[M]:
         """Review an object that implements Display or WithBriefing interface.

{fabricatio-0.2.5.dev2 → fabricatio-0.2.5.dev3}/python/fabricatio/fs/__init__.py

@@ -7,6 +7,7 @@ from fabricatio.fs.curd import (
     delete_directory,
     delete_file,
     dump_text,
+    gather_files,
     move_file,
     tree,
 )
@@ -19,6 +20,7 @@ __all__ = [
     "delete_directory",
     "delete_file",
     "dump_text",
+    "gather_files",
     "magika",
     "move_file",
     "safe_json_read",

{fabricatio-0.2.5.dev2 → fabricatio-0.2.5.dev3}/python/fabricatio/fs/curd.py

@@ -134,3 +134,16 @@ def absolute_path(path: str | Path | PathLike) -> str:
         str: The absolute path of the file or directory.
     """
     return Path(path).expanduser().resolve().as_posix()
+
+
+def gather_files(directory: str | Path | PathLike, extension: str) -> list[str]:
+    """Gather all files with a specific extension in a directory.
+
+    Args:
+        directory (str, Path, PathLike): The directory to search in.
+        extension (str): The file extension to look for.
+
+    Returns:
+        list[str]: A list of file paths with the specified extension.
+    """
+    return [file.as_posix() for file in Path(directory).rglob(f"*.{extension}")]

{fabricatio-0.2.5.dev2 → fabricatio-0.2.5.dev3}/python/fabricatio/journal.py

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

{fabricatio-0.2.5.dev2 → fabricatio-0.2.5.dev3}/python/fabricatio/models/action.py

@@ -122,17 +122,16 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
         current_action = None
         try:
             for step in self._instances:
-                logger.debug(f"Executing step: {step.name}")
+                logger.debug(f"Executing step: {(current_action := step.name)}")
                 act_task = create_task(step.act(await self._context.get()))
                 if task.is_cancelled():
                     act_task.cancel(f"Cancelled by task: {task.name}")
                     break
                 modified_ctx = await act_task
                 await self._context.put(modified_ctx)
-                current_action = step.name
             logger.info(f"Finished executing workflow: {self.name}")
-            final_ctx = await self._context.get()
-            if self.task_output_key not in final_ctx:
+
+            if self.task_output_key not in (final_ctx := await self._context.get()):
                 logger.warning(
                     f"Task output key: {self.task_output_key} not found in the context, None will be returned. You can check if `Action.output_key` is set the same as `WorkFlow.task_output_key`."
                 )

{fabricatio-0.2.5.dev2 → fabricatio-0.2.5.dev3}/python/fabricatio/models/kwargs_types.py

@@ -8,14 +8,21 @@ from pydantic import NonNegativeFloat, NonNegativeInt, PositiveInt
 
 
 class CollectionSimpleConfigKwargs(TypedDict):
-    """A type representing the configuration for a collection."""
+    """Configuration parameters for a vector collection.
+
+    These arguments are typically used when configuring connections to vector databases.
+    """
 
     dimension: NotRequired[int]
     timeout: NotRequired[float]
 
 
 class FetchKwargs(TypedDict):
-    """A type representing the keyword arguments for the fetch method."""
+    """Arguments for fetching data from vector collections.
+
+    Controls how data is retrieved from vector databases, including filtering
+    and result limiting parameters.
+    """
 
     collection_name: NotRequired[str]
     similarity_threshold: NotRequired[float]
@@ -23,7 +30,11 @@ class FetchKwargs(TypedDict):
 
 
 class EmbeddingKwargs(TypedDict):
-    """A type representing the keyword arguments for the embedding method."""
+    """Configuration parameters for text embedding operations.
+
+    These settings control the behavior of embedding models that convert text
+    to vector representations.
+    """
 
     model: NotRequired[str]
     dimensions: NotRequired[int]
@@ -32,7 +43,11 @@ class EmbeddingKwargs(TypedDict):
 
 
 class LLMKwargs(TypedDict):
-    """A type representing the keyword arguments for the LLM (Large Language Model) usage."""
+    """Configuration parameters for language model inference.
+
+    These arguments control the behavior of large language model calls,
+    including generation parameters and caching options.
+    """
 
     model: NotRequired[str]
     temperature: NotRequired[NonNegativeFloat]
@@ -42,35 +57,60 @@ class LLMKwargs(TypedDict):
     stream: NotRequired[bool]
     timeout: NotRequired[PositiveInt]
     max_retries: NotRequired[PositiveInt]
+    no_cache: NotRequired[bool]  # If use cache in this call
+    no_store: NotRequired[bool]  # If store the response of this call to cache
+    cache_ttl: NotRequired[int]  # how long the stored cache is alive, in seconds
+    s_maxage: NotRequired[int]  # max accepted age of cached response, in seconds
+
 
+class ValidateKwargs[T](LLMKwargs):
+    """Arguments for content validation operations.
 
-class ValidateKwargs(LLMKwargs):
-    """A type representing the keyword arguments for the validate method."""
+    Extends LLMKwargs with additional parameters specific to validation tasks,
+    such as limiting the number of validation attempts.
+    """
 
+    default: NotRequired[T]
     max_validations: NotRequired[PositiveInt]
 
 
 class GenerateKwargs(ValidateKwargs):
-    """A type representing the keyword arguments for the generate method."""
+    """Arguments for content generation operations.
+
+    Extends ValidateKwargs with parameters specific to text generation,
+    including system prompt configuration.
+    """
 
     system_message: NotRequired[str]
 
 
 class ReviewKwargs(GenerateKwargs):
-    """A type representing the keyword arguments for the review method."""
+    """Arguments for content review operations.
+
+    Extends GenerateKwargs with parameters for evaluating content against
+    specific topics and review criteria.
+    """
 
     topic: str
     criteria: NotRequired[Set[str]]
 
 
 class ChooseKwargs(GenerateKwargs):
-    """A type representing the keyword arguments for the choose method."""
+    """Arguments for selection operations.
+
+    Extends GenerateKwargs with parameters for selecting among options,
+    such as the number of items to choose.
+    """
 
     k: NotRequired[NonNegativeInt]
 
 
 class CacheKwargs(TypedDict, total=False):
-    """A type representing the keyword arguments for the cache method."""
+    """Configuration parameters for the caching system.
+
+    These arguments control the behavior of various caching backends,
+    including in-memory, Redis, S3, and vector database caching options.
+    """
 
     mode: NotRequired[CacheMode]  # when default_on cache is always on, when default_off cache is opt in
     host: NotRequired[str]

{fabricatio-0.2.5.dev2 → fabricatio-0.2.5.dev3}/python/fabricatio/models/usages.py

@@ -26,12 +26,8 @@ from more_itertools import duplicates_everseen
 from pydantic import Field, NonNegativeInt, PositiveInt
 
 if configs.cache.enabled:
-    from litellm.caching import Cache
-
-    if configs.cache.type is None:
-        Cache(**configs.cache.params)
-    else:
-        Cache(type=configs.cache.type, **configs.cache.params)
+    litellm.enable_cache(type=configs.cache.type, **configs.cache.params)
+    logger.success(f"{configs.cache.type.name} Cache enabled")
 
 
 class LLMUsage(ScopedConfig):
@@ -71,6 +67,12 @@ class LLMUsage(ScopedConfig):
             max_retries=kwargs.get("max_retries") or self.llm_max_retries or configs.llm.max_retries,
             api_key=(self.llm_api_key or configs.llm.api_key).get_secret_value(),
             base_url=(self.llm_api_endpoint or configs.llm.api_endpoint).unicode_string(),
+            cache={
+                "no-cache": kwargs.get("no_cache"),
+                "no-store": kwargs.get("no_store"),
+                "cache-ttl": kwargs.get("cache_ttl"),
+                "s-maxage": kwargs.get("s_maxage"),
+            },
         )
 
     async def ainvoke(
@@ -176,19 +178,32 @@ class LLMUsage(ScopedConfig):
             case _:
                 raise RuntimeError("Should not reach here.")
 
+    @overload
     async def aask_validate[T](
         self,
         question: str,
         validator: Callable[[str], T | None],
+        default: T,
         max_validations: PositiveInt = 2,
         system_message: str = "",
         **kwargs: Unpack[LLMKwargs],
-    ) -> T:
+    ) -> T: ...
+
+    async def aask_validate[T](
+        self,
+        question: str,
+        validator: Callable[[str], T | None],
+        default: Optional[T] = None,
+        max_validations: PositiveInt = 2,
+        system_message: str = "",
+        **kwargs: Unpack[LLMKwargs],
+    ) -> Optional[T]:
         """Asynchronously asks a question and validates the response using a given validator.
 
         Args:
             question (str): The question to ask.
             validator (Callable[[str], T | None]): A function to validate the response.
+            default (T | None): Default value to return if validation fails. Defaults to None.
             max_validations (PositiveInt): Maximum number of validation attempts. Defaults to 2.
             system_message (str): System message to include in the request. Defaults to an empty string.
             **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage.
@@ -196,8 +211,6 @@ class LLMUsage(ScopedConfig):
         Returns:
             T: The validated response.
 
-        Raises:
-            ValueError: If the response fails to validate after the maximum number of attempts.
         """
         for i in range(max_validations):
             if (
@@ -209,14 +222,17 @@ class LLMUsage(ScopedConfig):
             ) and (validated := validator(response)):
                 logger.debug(f"Successfully validated the response at {i}th attempt.")
                 return validated
-        logger.error(err := f"Failed to validate the response after {max_validations} attempts.")
-        raise ValueError(err)
+            kwargs["no_cache"] = True
+            logger.debug("Closed the cache for the next attempt")
+        if default is None:
+            logger.error(f"Failed to validate the response after {max_validations} attempts.")
+        return default
 
     async def aask_validate_batch[T](
         self,
         questions: List[str],
         validator: Callable[[str], T | None],
-        **kwargs: Unpack[GenerateKwargs],
+        **kwargs: Unpack[GenerateKwargs[T]],
     ) -> List[T]:
         """Asynchronously asks a batch of questions and validates the responses using a given validator.
 
@@ -233,7 +249,9 @@ class LLMUsage(ScopedConfig):
         """
         return await gather(*[self.aask_validate(question, validator, **kwargs) for question in questions])
 
-    async def aliststr(self, requirement: str, k: NonNegativeInt = 0, **kwargs: Unpack[GenerateKwargs]) -> List[str]:
+    async def aliststr(
+        self, requirement: str, k: NonNegativeInt = 0, **kwargs: Unpack[GenerateKwargs[List[str]]]
+    ) -> List[str]:
         """Asynchronously generates a list of strings based on a given requirement.
 
         Args:
@@ -253,7 +271,7 @@ class LLMUsage(ScopedConfig):
             **kwargs,
         )
 
-    async def apathstr(self, requirement: str, **kwargs: Unpack[ChooseKwargs]) -> List[str]:
+    async def apathstr(self, requirement: str, **kwargs: Unpack[ChooseKwargs[List[str]]]) -> List[str]:
         """Asynchronously generates a list of strings based on a given requirement.
 
         Args:
@@ -271,7 +289,7 @@ class LLMUsage(ScopedConfig):
             **kwargs,
         )
 
-    async def awhich_pathstr(self, requirement: str, **kwargs: Unpack[GenerateKwargs]) -> str:
+    async def awhich_pathstr(self, requirement: str, **kwargs: Unpack[GenerateKwargs[List[str]]]) -> str:
         """Asynchronously generates a single path string based on a given requirement.
 
         Args:
@@ -294,7 +312,7 @@ class LLMUsage(ScopedConfig):
         instruction: str,
         choices: List[T],
         k: NonNegativeInt = 0,
-        **kwargs: Unpack[GenerateKwargs],
+        **kwargs: Unpack[GenerateKwargs[List[T]]],
     ) -> List[T]:
         """Asynchronously executes a multi-choice decision-making process, generating a prompt based on the instruction and options, and validates the returned selection results.
 
@@ -345,7 +363,7 @@ class LLMUsage(ScopedConfig):
         self,
         instruction: str,
         choices: List[T],
-        **kwargs: Unpack[GenerateKwargs],
+        **kwargs: Unpack[GenerateKwargs[List[T]]],
     ) -> T:
         """Asynchronously picks a single choice from a list of options using AI validation.
 
@@ -374,7 +392,7 @@ class LLMUsage(ScopedConfig):
         prompt: str,
         affirm_case: str = "",
         deny_case: str = "",
-        **kwargs: Unpack[GenerateKwargs],
+        **kwargs: Unpack[GenerateKwargs[bool]],
     ) -> bool:
         """Asynchronously judges a prompt using AI validation.
 
@@ -489,17 +507,13 @@ class ToolBoxUsage(LLMUsage):
         self,
         task: Task,
         system_message: str = "",
-        k: NonNegativeInt = 0,
-        max_validations: PositiveInt = 2,
-        **kwargs: Unpack[LLMKwargs],
+        **kwargs: Unpack[ChooseKwargs[List[ToolBox]]],
     ) -> List[ToolBox]:
         """Asynchronously executes a multi-choice decision-making process to choose toolboxes.
 
         Args:
             task (Task): The task for which to choose toolboxes.
             system_message (str): Custom system-level prompt, defaults to an empty string.
-            k (NonNegativeInt): The number of toolboxes to select, 0 means infinite. Defaults to 0.
-            max_validations (PositiveInt): Maximum number of validation failures, default is 2.
             **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage.
 
         Returns:
@@ -511,8 +525,6 @@ class ToolBoxUsage(LLMUsage):
         return await self.achoose(
             instruction=task.briefing,
             choices=list(self.toolboxes),
-            k=k,
-            max_validations=max_validations,
             system_message=system_message,
             **kwargs,
         )
@@ -521,19 +533,13 @@ class ToolBoxUsage(LLMUsage):
         self,
         task: Task,
         toolbox: ToolBox,
-        system_message: str = "",
-        k: NonNegativeInt = 0,
-        max_validations: PositiveInt = 2,
-        **kwargs: Unpack[LLMKwargs],
+        **kwargs: Unpack[ChooseKwargs[List[Tool]]],
     ) -> List[Tool]:
         """Asynchronously executes a multi-choice decision-making process to choose tools.
 
         Args:
             task (Task): The task for which to choose tools.
             toolbox (ToolBox): The toolbox from which to choose tools.
-            system_message (str): Custom system-level prompt, defaults to an empty string.
-            k (NonNegativeInt): The number of tools to select, 0 means infinite. Defaults to 0.
-            max_validations (PositiveInt): Maximum number of validation failures, default is 2.
             **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage.
 
         Returns:
@@ -545,9 +551,6 @@ class ToolBoxUsage(LLMUsage):
         return await self.achoose(
             instruction=task.briefing,
             choices=toolbox.tools,
-            k=k,
-            max_validations=max_validations,
-            system_message=system_message,
             **kwargs,
         )
 

{fabricatio-0.2.5.dev2 → fabricatio-0.2.5.dev3}/python/fabricatio/toolboxes/fs.py

@@ -7,6 +7,7 @@ from fabricatio.fs import (
     delete_directory,
     delete_file,
     dump_text,
+    gather_files,
     move_file,
     safe_json_read,
     safe_text_read,
@@ -26,4 +27,5 @@ fs_toolbox = (
     .add_tool(absolute_path)
     .add_tool(safe_text_read)
     .add_tool(safe_json_read)
+    .add_tool(gather_files)
 )

{fabricatio-0.2.5.dev2 → fabricatio-0.2.5.dev3}/uv.lock

@@ -216,7 +216,7 @@ wheels = [
 
 [[package]]
 name = "fabricatio"
-version = "0.2.5.dev2"
+version = "0.2.5.dev3"
 source = { editable = "." }
 dependencies = [
     { name = "appdirs" },