fabricatio 0.2.6.dev0__cp312-cp312-win_amd64.whl → 0.2.6.dev2__cp312-cp312-win_amd64.whl

fabricatio/models/task.py

@@ -6,7 +6,7 @@ It includes methods to manage the task's lifecycle, such as starting, finishing,
 from asyncio import Queue
 from typing import Any, List, Optional, Self
 
-from fabricatio._rust_instances import template_manager
+from fabricatio._rust_instances import TEMPLATE_MANAGER
 from fabricatio.config import configs
 from fabricatio.core import env
 from fabricatio.journal import logger
@@ -253,7 +253,7 @@ class Task[T](WithBriefing, ProposedAble, WithDependency):
         Returns:
             str: The briefing of the task.
         """
-        return template_manager.render_template(
+        return TEMPLATE_MANAGER.render_template(
             configs.templates.task_briefing_template,
             self.model_dump(),
         )

fabricatio/models/usages.py

@@ -5,7 +5,7 @@ from typing import Callable, Dict, Iterable, List, Optional, Self, Sequence, Set
 
 import asyncstdlib
 import litellm
-from fabricatio._rust_instances import template_manager
+from fabricatio._rust_instances import TEMPLATE_MANAGER
 from fabricatio.config import configs
 from fabricatio.journal import logger
 from fabricatio.models.generic import ScopedConfig, WithBriefing
@@ -13,7 +13,7 @@ from fabricatio.models.kwargs_types import ChooseKwargs, EmbeddingKwargs, Genera
 from fabricatio.models.task import Task
 from fabricatio.models.tool import Tool, ToolBox
 from fabricatio.models.utils import Messages
-from fabricatio.parser import JsonCapture
+from fabricatio.parser import GenericCapture, JsonCapture
 from litellm import Router, stream_chunk_builder
 from litellm.types.router import Deployment, LiteLLM_Params, ModelInfo
 from litellm.types.utils import (
@@ -30,6 +30,7 @@ from pydantic import Field, NonNegativeInt, PositiveInt
 if configs.cache.enabled and configs.cache.type:
     litellm.enable_cache(type=configs.cache.type, **configs.cache.params)
     logger.success(f"{configs.cache.type.name} Cache enabled")
+
 ROUTER = Router(
     routing_strategy="usage-based-routing-v2",
     allowed_fails=configs.routing.allowed_fails,
@@ -301,7 +302,7 @@ class LLMUsage(ScopedConfig):
             List[str]: The validated response as a list of strings.
         """
         return await self.aask_validate(
-            template_manager.render_template(
+            TEMPLATE_MANAGER.render_template(
                 configs.templates.liststr_template,
                 {"requirement": requirement, "k": k},
             ),
@@ -320,7 +321,7 @@ class LLMUsage(ScopedConfig):
             List[str]: The validated response as a list of strings.
         """
         return await self.aliststr(
-            template_manager.render_template(
+            TEMPLATE_MANAGER.render_template(
                 configs.templates.pathstr_template,
                 {"requirement": requirement},
             ),
@@ -345,6 +346,25 @@ class LLMUsage(ScopedConfig):
             )
         ).pop()
 
+    async def ageneric_string(self, requirement: str, **kwargs: Unpack[ValidateKwargs[str]]) -> str:
+        """Asynchronously generates a generic string based on a given requirement.
+
+        Args:
+            requirement (str): The requirement for the string.
+            **kwargs (Unpack[GenerateKwargs]): Additional keyword arguments for the LLM usage.
+
+        Returns:
+            str: The generated string.
+        """
+        return await self.aask_validate(
+            TEMPLATE_MANAGER.render_template(
+                configs.templates.generic_string_template,
+                {"requirement": requirement, "language": GenericCapture.capture_type},
+            ),
+            validator=lambda resp: GenericCapture.capture(resp),
+            **kwargs,
+        )
+
     async def achoose[T: WithBriefing](
         self,
         instruction: str,
@@ -371,7 +391,7 @@ class LLMUsage(ScopedConfig):
         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(
+        prompt = TEMPLATE_MANAGER.render_template(
             configs.templates.make_choice_template,
             {
                 "instruction": instruction,
@@ -444,7 +464,7 @@ class LLMUsage(ScopedConfig):
             bool: The judgment result (True or False) based on the AI's response.
         """
         return await self.aask_validate(
-            question=template_manager.render_template(
+            question=TEMPLATE_MANAGER.render_template(
                 configs.templates.make_judgment_template,
                 {"prompt": prompt, "affirm_case": affirm_case, "deny_case": deny_case},
             ),

fabricatio/models/utils.py

@@ -4,6 +4,7 @@ from enum import Enum
 from typing import Any, Dict, List, Literal, Optional, Self
 
 from pydantic import BaseModel, ConfigDict, Field
+from questionary import text
 
 
 class Message(BaseModel):
@@ -144,3 +145,23 @@ class TaskStatus(Enum):
     Finished = "finished"
     Failed = "failed"
     Cancelled = "cancelled"
+
+
+async def ask_edit(
+    text_seq: List[str],
+) -> List[str]:
+    """Asks the user to edit a list of texts.
+
+    Args:
+        text_seq (List[str]): A list of texts to be edited.
+
+    Returns:
+        List[str]: A list of edited texts.
+        If the user does not edit a text, it will not be included in the returned list.
+    """
+    res = []
+    for i, t in enumerate(text_seq):
+        edited = await text(f"[{i}] ", default=t).ask_async()
+        if edited:
+            res.append(edited)
+    return res

fabricatio/parser.py

@@ -35,7 +35,7 @@ class Capture(BaseModel):
         """Initialize the compiled pattern."""
         self._compiled = compile(self.pattern, self.flags)
 
-    def fix[T](self, text: str | Iterable[str]|T) -> str | List[str]|T:
+    def fix[T](self, text: str | Iterable[str] | T) -> str | List[str] | T:
         """Fix the text using the pattern.
 
         Args:
@@ -47,8 +47,8 @@ class Capture(BaseModel):
         match self.capture_type:
             case "json":
                 if isinstance(text, str):
-                    return repair_json(text,ensure_ascii=False)
-                return [repair_json(item) for item in text]
+                    return repair_json(text, ensure_ascii=False)
+                return [repair_json(item, ensure_ascii=False) for item in text]
             case _:
                 return text
 
@@ -134,8 +134,16 @@ class Capture(BaseModel):
         """
         return cls(pattern=f"```{language}\n(.*?)\n```", capture_type=language)
 
+    @classmethod
+    def capture_generic_block(cls, language: str) -> Self:
+        """Capture the first occurrence of a generic code block in the given text.
+
+        Returns:
+            Self: The instance of the class with the captured code block.
+        """
+        return cls(pattern=f"--- Start of {language} ---\n(.*?)\n--- end of {language} ---", capture_type=language)
+
 
 JsonCapture = Capture.capture_code_block("json")
 PythonCapture = Capture.capture_code_block("python")
-MarkdownCapture = Capture.capture_code_block("markdown")
-CodeBlockCapture = Capture(pattern="```.*?\n(.*?)\n```")
+GenericCapture = Capture.capture_generic_block("String")

fabricatio-0.2.6.dev2.dist-info/METADATA

@@ -0,0 +1,432 @@
+Metadata-Version: 2.4
+Name: fabricatio
+Version: 0.2.6.dev2
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Framework :: AsyncIO
+Classifier: Framework :: Pydantic :: 2
+Classifier: Typing :: Typed
+Requires-Dist: appdirs>=1.4.4
+Requires-Dist: asyncio>=3.4.3
+Requires-Dist: asyncstdlib>=3.13.0
+Requires-Dist: json-repair>=0.39.1
+Requires-Dist: litellm>=1.60.0
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: magika>=0.5.1
+Requires-Dist: more-itertools>=10.6.0
+Requires-Dist: orjson>=3.10.15
+Requires-Dist: pydantic>=2.10.6
+Requires-Dist: pydantic-settings>=2.7.1
+Requires-Dist: pymitter>=1.0.0
+Requires-Dist: questionary>=2.1.0
+Requires-Dist: regex>=2024.11.6
+Requires-Dist: rich>=13.9.4
+Requires-Dist: pymilvus>=2.5.4 ; extra == 'rag'
+Requires-Dist: fabricatio[rag] ; extra == 'full'
+Provides-Extra: rag
+Provides-Extra: full
+License-File: LICENSE
+Summary: A LLM multi-agent framework.
+Keywords: ai,agents,multi-agent,llm,pyo3
+Author-email: Whth <zettainspector@foxmail.com>
+Requires-Python: >=3.12, <3.13
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Homepage, https://github.com/Whth/fabricatio
+Project-URL: Repository, https://github.com/Whth/fabricatio
+Project-URL: Issues, https://github.com/Whth/fabricatio/issues
+
+# Fabricatio
+
+![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)
+![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)
+![Build Status](https://img.shields.io/badge/build-passing-brightgreen)
+
+## Overview
+
+Fabricatio is a Python library designed for building LLM (Large Language Model) applications using an event-based agent structure. It integrates Rust for performance-critical tasks, utilizes Handlebars for templating, and employs PyO3 for Python bindings.
+
+## Features
+
+- **Event-Based Architecture**: Utilizes an EventEmitter pattern for robust task management.
+- **LLM Integration**: Supports interactions with large language models for intelligent task processing.
+- **Templating Engine**: Uses Handlebars for dynamic content generation.
+- **Toolboxes**: Provides predefined toolboxes for common operations like file manipulation and arithmetic.
+- **Async Support**: Fully asynchronous for efficient execution.
+- **Extensible**: Easy to extend with custom actions, workflows, and tools.
+
+## Installation
+
+### Using UV (Recommended)
+
+To install Fabricatio using `uv` (a package manager for Python):
+
+```bash
+# Install uv if not already installed
+pip install uv
+
+# Clone the repository
+git clone https://github.com/Whth/fabricatio.git
+cd fabricatio
+
+# Install the package in development mode with uv
+uv --with-editable . maturin develop --uv -r
+```
+
+### Building Distribution
+
+For production builds:
+
+```bash
+# Build distribution packages
+make bdist
+```
+
+This will generate distribution files in the `dist` directory.
+
+## Usage
+
+### Basic Example
+
+#### Simple Hello World Program
+
+```python
+import asyncio
+from fabricatio import Action, Role, Task, logger, WorkFlow
+from typing import Any
+
+class Hello(Action):
+    name: str = "hello"
+    output_key: str = "task_output"
+
+    async def _execute(self, task_input: Task[str], **_) -> Any:
+        ret = "Hello fabricatio!"
+        logger.info("executing talk action")
+        return ret
+
+async def main() -> None:
+    role = Role(
+        name="talker",
+        description="talker role",
+        registry={Task.pending_label: WorkFlow(name="talk", steps=(Hello,))}
+    )
+
+    task = Task(name="say hello", goals="say hello", description="say hello to the world")
+    result = await task.delegate()
+    logger.success(f"Result: {result}")
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+### Advanced Examples
+
+#### Simple Chat
+
+Demonstrates a basic chat application.
+
+```python
+"""Simple chat example."""
+import asyncio
+from fabricatio import Action, Role, Task, WorkFlow, logger
+from fabricatio.models.events import Event
+from questionary import text
+
+class Talk(Action):
+    """Action that says hello to the world."""
+
+    output_key: str = "task_output"
+
+    async def _execute(self, task_input: Task[str], **_) -> int:
+        counter = 0
+        try:
+            while True:
+                user_say = await text("User: ").ask_async()
+                gpt_say = await self.aask(
+                    user_say,
+                    system_message=f"You have to answer to user obeying task assigned to you:\n{task_input.briefing}",
+                )
+                print(f"GPT: {gpt_say}")  # noqa: T201
+                counter += 1
+        except KeyboardInterrupt:
+            logger.info(f"executed talk action {counter} times")
+        return counter
+
+async def main() -> None:
+    """Main function."""
+    role = Role(
+        name="talker",
+        description="talker role",
+        registry={Event.instantiate_from("talk").push_wildcard().push("pending"): WorkFlow(name="talk", steps=(Talk,))},
+    )
+
+    task = await role.propose_task(
+        "you have to act as a helpful assistant, answer to all user questions properly and patiently"
+    )
+    _ = await task.delegate("talk")
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+#### Simple RAG
+
+Demonstrates Retrieval-Augmented Generation (RAG).
+
+```python
+"""Simple chat example."""
+import asyncio
+from fabricatio import RAG, Action, Role, Task, WorkFlow, logger
+from fabricatio.models.events import Event
+from questionary import text
+
+class Talk(Action, RAG):
+    """Action that says hello to the world."""
+
+    output_key: str = "task_output"
+
+    async def _execute(self, task_input: Task[str], **_) -> int:
+        counter = 0
+
+        self.init_client().view("test_collection", create=True)
+        await self.consume_string(
+            [
+                "Company policy clearly stipulates that all employees must arrive at the headquarters building located at 88 Jianguo Road, Chaoyang District, Beijing before 9 AM daily.",
+                "According to the latest revised health and safety guidelines, employees must wear company-provided athletic gear when using the company gym facilities.",
+                "Section 3.2.1 of the employee handbook states that pets are not allowed in the office area under any circumstances.",
+                "To promote work efficiency, the company has quiet workspaces at 100 Century Avenue, Pudong New District, Shanghai, for employees who need high concentration for their work.",
+                "According to the company's remote work policy, employees can apply for a maximum of 5 days of working from home per month, but must submit the application one week in advance.",
+                "The company has strict regulations on overtime. Unless approved by direct supervisors, no form of work is allowed after 9 PM.",
+                "Regarding the new regulations for business travel reimbursement, all traveling personnel must submit detailed expense reports within five working days after returning.",
+                "Company address: 123 East Sports Road, Tianhe District, Guangzhou, Postal Code: 510620.",
+                "Annual team building activities will be held in the second quarter of each year, usually at a resort within a two-hour drive from the Guangzhou headquarters.",
+                "Employees who are late more than three times will receive a formal warning, which may affect their year-end performance evaluation.",
+            ]
+        )
+        try:
+            while True:
+                user_say = await text("User: ").ask_async()
+                if user_say is None:
+                    break
+                gpt_say = await self.aask_retrieved(
+                    user_say,
+                    user_say,
+                    extra_system_message=f"You have to answer to user obeying task assigned to you:\n{task_input.briefing}",
+                )
+                print(f"GPT: {gpt_say}")  # noqa: T201
+                counter += 1
+        except KeyboardInterrupt:
+            logger.info(f"executed talk action {counter} times")
+        return counter
+
+async def main() -> None:
+    """Main function."""
+    role = Role(
+        name="talker",
+        description="talker role but with rag",
+        registry={Event.instantiate_from("talk").push_wildcard().push("pending"): WorkFlow(name="talk", steps=(Talk,))},
+    )
+
+    task = await role.propose_task(
+        "you have to act as a helpful assistant, answer to all user questions properly and patiently"
+    )
+    _ = await task.delegate("talk")
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+#### Extract Article
+
+Demonstrates extracting the essence of an article from a file.
+
+```python
+"""Example of proposing a task to a role."""
+import asyncio
+from typing import List
+
+from fabricatio import ArticleEssence, Event, ExtractArticleEssence, Role, Task, WorkFlow, logger
+
+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 file at './7.md'"
+    )
+    ess = (await task.delegate("article")).pop()
+    logger.success(f"Essence:\n{ess.display()}")
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+#### Propose Task
+
+Demonstrates proposing a task to a role.
+
+```python
+"""Example of proposing a task to a role."""
+import asyncio
+from typing import Any
+
+from fabricatio import Action, Event, Role, Task, WorkFlow, logger
+
+class Talk(Action):
+    """Action that says hello to the world."""
+
+    output_key: str = "task_output"
+
+    async def _execute(self, **_) -> Any:
+        ret = "Hello fabricatio!"
+        logger.info("executing talk action")
+        return ret
+
+async def main() -> None:
+    """Main function."""
+    role = Role(
+        name="talker",
+        description="talker role",
+        registry={Event.quick_instantiate("talk"): WorkFlow(name="talk", steps=(Talk,))},
+    )
+    logger.info(f"Task example:\n{Task.formated_json_schema()}")
+    logger.info(f"proposed task: {await role.propose_task('write a rust clap cli that can download a html page')}")
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+#### Review
+
+Demonstrates reviewing code.
+
+```python
+"""Example of review usage."""
+import asyncio
+
+from fabricatio import Role, logger
+
+async def main() -> None:
+    """Main function."""
+    role = Role(
+        name="Reviewer",
+        description="A role that reviews the code.",
+    )
+
+    code = await role.aask(
+        "write a cli app using rust with clap which can generate a basic manifest of a standard rust project, output code only,no extra explanation"
+    )
+
+    logger.success(f"Code: \n{code}")
+    res = await role.review_string(code, "If the cli app is of good design")
+    logger.success(f"Review: \n{res.display()}")
+    await res.supervisor_check()
+    logger.success(f"Review: \n{res.display()}")
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+#### Write Outline
+
+Demonstrates writing an outline for an article in Typst format.
+
+```python
+"""Example of using the library."""
+import asyncio
+
+from fabricatio import Event, Role, WriteOutlineWorkFlow, logger
+
+async def main() -> None:
+    """Main function."""
+    role = Role(
+        name="Undergraduate Researcher",
+        description="Write an outline for an article in typst format.",
+        registry={Event.quick_instantiate(ns := "article"): WriteOutlineWorkFlow},
+    )
+
+    proposed_task = await role.propose_task(
+        "You need to read the `./article_briefing.txt` file and write an outline for the article in typst format. The outline should be saved in the `./out.typ` file.",
+    )
+    path = await proposed_task.delegate(ns)
+    logger.success(f"The outline is saved in:\n{path}")
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## Configuration
+
+The configuration for Fabricatio is managed via environment variables or TOML files. The default configuration file (`config.toml`) can be overridden by specifying a custom path.
+
+Example `config.toml`:
+
+```toml
+[llm]
+api_endpoint = "https://api.openai.com"
+api_key = "your_openai_api_key"
+timeout = 300
+max_retries = 3
+model = "gpt-3.5-turbo"
+temperature = 1.0
+stop_sign = ["\n\n\n", "User:"]
+top_p = 0.35
+generation_count = 1
+stream = false
+max_tokens = 8192
+```
+
+## Development Setup
+
+To set up a development environment for Fabricatio:
+
+1. **Clone the Repository**:
+    ```bash
+    git clone https://github.com/Whth/fabricatio.git
+    cd fabricatio
+    ```
+
+2. **Install Dependencies**:
+    ```bash
+    uv --with-editable . maturin develop --uv -r
+    ```
+
+3. **Run Tests**:
+    ```bash
+    make test
+    ```
+
+4. **Build Documentation**:
+    ```bash
+    make docs
+    ```
+
+## Contributing
+
+Contributions are welcome! Please follow these guidelines when contributing:
+
+1. Fork the repository.
+2. Create your feature branch (`git checkout -b feature/new-feature`).
+3. Commit your changes (`git commit -am 'Add new feature'`).
+4. Push to the branch (`git push origin feature/new-feature`).
+5. Create a new Pull Request.
+
+## License
+
+Fabricatio is licensed under the MIT License. See [LICENSE](LICENSE) for more details.
+
+## Acknowledgments
+
+Special thanks to the contributors and maintainers of:
+- [PyO3](https://github.com/PyO3/pyo3)
+- [Maturin](https://github.com/PyO3/maturin)
+- [Handlebars.rs](https://github.com/sunng87/handlebars-rust)

fabricatio-0.2.6.dev2.dist-info/RECORD

@@ -0,0 +1,42 @@
+fabricatio-0.2.6.dev2.dist-info/METADATA,sha256=bzt1bm_oxz4nv8eH7gaT5B6sEYsDx1bZ76p5RXdiO-8,14085
+fabricatio-0.2.6.dev2.dist-info/WHEEL,sha256=tpW5AN9B-9qsM9WW2FXG2r193YXiqexDadpKp0A2daI,96
+fabricatio-0.2.6.dev2.dist-info/licenses/LICENSE,sha256=do7J7EiCGbq0QPbMAL_FqLYufXpHnCnXBOuqVPwSV8Y,1088
+fabricatio/actions/article.py,sha256=yzRwgc203vI3MW_oWyFybDxTz6kaBBvUgN2zOJJ9Amc,2825
+fabricatio/actions/output.py,sha256=KSSLvEvXsA10ACN2mbqGo98QwKLVUAoMUJNKYk6HhGc,645
+fabricatio/actions/rag.py,sha256=GpT7YlqOYznZyaT-6Y84_33HtZGT-5s71ZK8iroQA9g,813
+fabricatio/capabilities/correct.py,sha256=0BYhjo9WrLwKsXQR8bTPvdQITbrMs7RX1xpzhuQt_yY,5222
+fabricatio/capabilities/propose.py,sha256=y3kge5g6bb8HYuV8e9h4MdqOMTlsfAIZpqE_cagWPTY,1593
+fabricatio/capabilities/rag.py,sha256=OebdGps8LGniN_HkRAOuwZd1ZQsyQe3WrduNAmBSxLM,15773
+fabricatio/capabilities/rating.py,sha256=R9otyZVE2E3kKxrOCTZMeesBCPbC-fSb7bXgZPMQzfU,14406
+fabricatio/capabilities/review.py,sha256=XYzpSnFCT9HS2XytQT8HDgV4SjXehexoJgucZFMx6P8,11102
+fabricatio/capabilities/task.py,sha256=nVsC8smZRM5kGnIDiQtgP9kiGkz5KB1S9NXhMvwY2CQ,4607
+fabricatio/config.py,sha256=bpj8i0KT8HQ9ka2kX3lcILBWh4S5_PenCas9wu_Ueg0,16302
+fabricatio/core.py,sha256=VQ_JKgUGIy2gZ8xsTBZCdr_IP7wC5aPg0_bsOmjQ588,6458
+fabricatio/decorators.py,sha256=uzsP4tFKQNjDHBkofsjjoJA0IUAaYOtt6YVedoyOqlo,6551
+fabricatio/fs/curd.py,sha256=N6l2MncjrFfnXBRtteRouXp5Rjy8EAKC_i29_G-zz98,4618
+fabricatio/fs/readers.py,sha256=EZKN_AZdrp8DggJECP53QHw3uHeSDf-AwCAA_V7fNKU,1202
+fabricatio/fs/__init__.py,sha256=PCf0s_9KDjVfNw7AfPoJzGt3jMq4gJOfbcT4pb0D0ZY,588
+fabricatio/journal.py,sha256=stnEP88aUBA_GmU9gfTF2EZI8FS2OyMLGaMSTgK4QgA,476
+fabricatio/models/action.py,sha256=25kaph3csV0VQtxVPQCyRAusgwp6E1R1g4KBs7H9T2c,6448
+fabricatio/models/events.py,sha256=QvlnS8FEELg6KNabcJMeh2GV_y0ZBzKOPphcteKYWYU,4183
+fabricatio/models/extra.py,sha256=O8ncZVsaNmlR5f8c_b2HJc-yVZQ2YhB6ddDbfT0Ysh4,7412
+fabricatio/models/generic.py,sha256=IdPJMf3qxZFq8yqd6OuAYKfCM0wBlJkozgxvxQZVEEc,14025
+fabricatio/models/kwargs_types.py,sha256=Q-dTKfh-_FddyVCI13FzLBlgVjYrRtzXpZoQdy-G9I4,4573
+fabricatio/models/role.py,sha256=7S3HSjFLaSTZ5bzgTJLeZ3PpAQDEGBxPhou5Mp8ONpQ,1842
+fabricatio/models/task.py,sha256=8NaR7ojQWyM740EDTqt9stwHKdrD6axCRpLKo0QzS-I,10492
+fabricatio/models/tool.py,sha256=4b-v4WIC_LuLOKzzXL9bvKXr8vmGZ8O2uAFv5-1KRA0,7052
+fabricatio/models/usages.py,sha256=hR4OU4sjQ2jKaH5_kkN83vG58n3kcKnt9osND0BYi0Q,28634
+fabricatio/models/utils.py,sha256=1bCqeB6za7ecCAM3cU1raNWuN56732m45rXtlIlc3I4,5017
+fabricatio/parser.py,sha256=SzyVzbKj5L_0IcI5Z5ILpopJxE-1hGhmomskTWdcc68,6194
+fabricatio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fabricatio/toolboxes/arithmetic.py,sha256=WLqhY-Pikv11Y_0SGajwZx3WhsLNpHKf9drzAqOf_nY,1369
+fabricatio/toolboxes/fs.py,sha256=l4L1CVxJmjw9Ld2XUpIlWfV0_Fu_2Og6d3E13I-S4aE,736
+fabricatio/toolboxes/__init__.py,sha256=KBJi5OG_pExscdlM7Bnt_UF43j4I3Lv6G71kPVu4KQU,395
+fabricatio/workflows/articles.py,sha256=RebdC_BzSXC-xsck5I9ccC_XIgfhtoeM8FZuhtVDn3U,580
+fabricatio/workflows/rag.py,sha256=-YYp2tlE9Vtfgpg6ROpu6QVO8j8yVSPa6yDzlN3qVxs,520
+fabricatio/_rust.pyi,sha256=pI747rOciunGuQZDvfC3O0A6pLyOiaHSa3A5kHuQO0E,3169
+fabricatio/_rust_instances.py,sha256=2GwF8aVfYNemRI2feBzH1CZfBGno-XJJE5imJokGEYw,314
+fabricatio/__init__.py,sha256=wTPzKLGztMr7orV-KizHRXJFhPGncvAHE7BPeSmBVDU,1926
+fabricatio/_rust.cp312-win_amd64.pyd,sha256=cAUlGwAeoyfEkzITxfCVr8ngDBeEcEdpVS8iTOP82kk,1815552
+fabricatio-0.2.6.dev2.data/scripts/tdown.exe,sha256=panGfEi6b9ALQ9_0Be3Px-jxGpvmvKeet9UXBF6f9zU,3395072
+fabricatio-0.2.6.dev2.dist-info/RECORD,,