fabricatio 0.2.7.dev3__tar.gz → 0.2.7.dev4__tar.gz

fabricatio-0.2.7.dev4/PKG-INFO

@@ -0,0 +1,181 @@
+Metadata-Version: 2.4
+Name: fabricatio
+Version: 0.2.7.dev4
+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[calc,plot,rag] ; extra == 'full'
+Requires-Dist: sympy>=1.13.3 ; extra == 'calc'
+Requires-Dist: matplotlib>=3.10.1 ; extra == 'plot'
+Provides-Extra: rag
+Provides-Extra: full
+Provides-Extra: calc
+Provides-Extra: plot
+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 streamlined Python library for building LLM applications using an event-based agent structure. It leverages Rust for performance-critical tasks, Handlebars for templating, and PyO3 for Python bindings.
+
+## Features
+
+- **Event-Driven Architecture**: Robust task management through an EventEmitter pattern.
+- **LLM Integration & Templating**: Seamlessly interact with large language models and dynamic content generation.
+- **Async & Extensible**: Fully asynchronous execution with easy extension via custom actions and workflows.
+
+## Installation
+
+### Using UV (Recommended)
+
+```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
+
+```bash
+# Build distribution packages
+make bdist
+```
+
+## Usage
+
+### Basic Example
+
+```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())
+```
+
+### Examples
+
+For various usage scenarios, refer to the following examples:
+- Simple Chat
+- Retrieval-Augmented Generation (RAG)
+- Article Extraction
+- Propose Task
+- Code Review
+- Write Outline
+
+_(For full example details, please check our detailed documentation, see [Examples](./examples))_
+
+## Configuration
+
+The configuration for Fabricatio is managed via environment variables or TOML files. For example:
+
+```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
+
+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
+    ```
+
+## Contributing
+
+Contributions are welcome! Follow these steps:
+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 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.7.dev4/README.md

@@ -0,0 +1,138 @@
+# 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 streamlined Python library for building LLM applications using an event-based agent structure. It leverages Rust for performance-critical tasks, Handlebars for templating, and PyO3 for Python bindings.
+
+## Features
+
+- **Event-Driven Architecture**: Robust task management through an EventEmitter pattern.
+- **LLM Integration & Templating**: Seamlessly interact with large language models and dynamic content generation.
+- **Async & Extensible**: Fully asynchronous execution with easy extension via custom actions and workflows.
+
+## Installation
+
+### Using UV (Recommended)
+
+```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
+
+```bash
+# Build distribution packages
+make bdist
+```
+
+## Usage
+
+### Basic Example
+
+```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())
+```
+
+### Examples
+
+For various usage scenarios, refer to the following examples:
+- Simple Chat
+- Retrieval-Augmented Generation (RAG)
+- Article Extraction
+- Propose Task
+- Code Review
+- Write Outline
+
+_(For full example details, please check our detailed documentation, see [Examples](./examples))_
+
+## Configuration
+
+The configuration for Fabricatio is managed via environment variables or TOML files. For example:
+
+```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
+
+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
+    ```
+
+## Contributing
+
+Contributions are welcome! Follow these steps:
+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 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.7.dev3 → fabricatio-0.2.7.dev4}/pyproject.toml

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

fabricatio-0.2.7.dev4/python/fabricatio/models/extra/article_base.py

@@ -0,0 +1,192 @@
+"""A foundation for hierarchical document components with dependency tracking."""
+
+from abc import abstractmethod
+from enum import StrEnum
+from typing import TYPE_CHECKING, List, Optional, Self, Union, final, overload
+
+from fabricatio.models.generic import Base, CensoredAble, Display, PersistentAble
+from pydantic import Field
+
+if TYPE_CHECKING:
+    from fabricatio.models.extra.article_main import Article
+    from fabricatio.models.extra.article_outline import ArticleOutline
+
+
+class ReferringType(StrEnum):
+    """Enumeration of different types of references that can be made in an article."""
+
+    CHAPTER: str = "chapter"
+    SECTION: str = "section"
+    SUBSECTION: str = "subsection"
+
+
+class ArticleRef(CensoredAble):
+    """Reference to a specific chapter, section or subsection within the article. You SHALL not refer to an article component that is external and not present within our own article.
+
+    Examples:
+        - Referring to a chapter titled `Introduction`:
+            Using Python
+            ```python
+            ArticleRef(referred_chapter_title="Introduction")
+            ```
+            Using JSON
+            ```json
+            {referred_chapter_title="Introduction"}
+            ```
+        - Referring to a section titled `Background` under the `Introduction` chapter:
+            Using Python
+            ```python
+            ArticleRef(referred_chapter_title="Introduction", referred_section_title="Background")
+            ```
+            Using JSON
+            ```json
+            {referred_chapter_title="Introduction", referred_section_title="Background"}
+            ```
+        - Referring to a subsection titled `Related Work` under the `Background` section of the `Introduction` chapter:
+            Using Python
+            ```python
+            ArticleRef(referred_chapter_title="Introduction", referred_section_title="Background", referred_subsection_title="Related Work")
+            ```
+            Using JSON
+            ```json
+            {referred_chapter_title="Introduction", referred_section_title="Background", referred_subsection_title="Related Work"}
+            ```
+    """
+
+    referred_subsection_title: Optional[str] = None
+    """`title` Field of the referenced subsection."""
+
+    referred_section_title: Optional[str] = None
+    """`title` Field of the referenced section."""
+
+    referred_chapter_title: str
+    """`title` Field of the referenced chapter"""
+
+    def __hash__(self) -> int:
+        """Overrides the default hash function to ensure consistent hashing across instances."""
+        return hash((self.referred_chapter_title, self.referred_section_title, self.referred_subsection_title))
+
+    @overload
+    def deref(self, article: "Article") -> Optional["ArticleMainBase"]:
+        """Dereference the reference to the actual section or subsection within the provided article."""
+
+    @overload
+    def deref(self, article: "ArticleOutline") -> Optional["ArticleOutlineBase"]:
+        """Dereference the reference to the actual section or subsection within the provided article."""
+
+    def deref(
+        self, article: Union["ArticleOutline", "Article"]
+    ) -> Union["ArticleOutlineBase", "ArticleMainBase", None]:
+        """Dereference the reference to the actual section or subsection within the provided article.
+
+        Args:
+            article (ArticleOutline | Article): The article to dereference the reference from.
+
+        Returns:
+            ArticleMainBase | ArticleOutline | None: The dereferenced section or subsection, or None if not found.
+        """
+        chap = next((chap for chap in article.chapters if chap.title == self.referred_chapter_title), None)
+        if self.referred_section_title is None or chap is None:
+            return chap
+        sec = next((sec for sec in chap.sections if sec.title == self.referred_section_title), None)
+        if self.referred_subsection_title is None or sec is None:
+            return sec
+        return next((subsec for subsec in sec.subsections if subsec.title == self.referred_subsection_title), None)
+
+    @property
+    def referring_type(self) -> ReferringType:
+        """Determine the type of reference based on the presence of specific attributes."""
+        if self.referred_subsection_title is not None:
+            return ReferringType.SUBSECTION
+        if self.referred_section_title is not None:
+            return ReferringType.SECTION
+        return ReferringType.CHAPTER
+
+
+class SubSectionBase(Base):
+    """Base class for article sections and subsections."""
+
+
+class SectionBase[T: SubSectionBase](Base):
+    """Base class for article sections and subsections."""
+
+    subsections: List[T] = Field(min_length=1)
+    """List of subsections, each containing a specific research component. Must contains at least 1 subsection, But do remember you should always add more subsection as required."""
+
+
+class ChapterBase[T: SectionBase](Base):
+    """Base class for article chapters."""
+
+    sections: List[T] = Field(min_length=1)
+    """List of sections, each containing a specific research component. Must contains at least 1 section, But do remember you should always add more section as required."""
+
+
+class ArticleBase[T: ChapterBase](Base):
+    """Base class for article outlines."""
+
+    chapters: List[T] = Field(min_length=5)
+    """List of chapters, each containing a specific research component. Must contains at least 5 chapters, But do remember you should always add more chapter as required."""
+
+
+class ArticleOutlineBase(Base):
+    """Base class for article outlines."""
+
+    title: str
+    """Title of the research component in academic style."""
+    description: str
+    """Description of the research component in academic style."""
+
+    support_to: List[ArticleRef]
+    """Required: List of all essential ArticleRef objects identifying components this section provides evidence for.
+    Format: Each reference must point to a specific chapter, section, or subsection.
+    Note: References form a directed acyclic graph in the document structure."""
+    depend_on: List[ArticleRef]
+    """Required: List of all essential ArticleRef objects identifying components this section builds upon.
+    Format: Each reference must point to a previously defined chapter, section, or subsection.
+    Note: Circular dependencies are not permitted."""
+
+    writing_aim: List[str]
+    """Required: List of specific rhetorical objectives (3-5 items).
+    Format: Each item must be an actionable phrase starting with a verb.
+    Example: ['Establish metric validity', 'Compare with baseline approaches',
+             'Justify threshold selection']"""
+
+
+class ArticleMainBase(CensoredAble, Display, ArticleOutlineBase, PersistentAble):
+    """Foundation for hierarchical document components with dependency tracking."""
+
+    @abstractmethod
+    def to_typst_code(self) -> str:
+        """Converts the component into a Typst code snippet for rendering."""
+
+    def _update_pre_check(self, other: Self) -> Self:
+        if not isinstance(other, self.__class__):
+            raise TypeError(f"Cannot update from a non-{self.__class__} instance.")
+        if self.title != other.title:
+            raise ValueError("Cannot update from a different title.")
+        return self
+
+    @abstractmethod
+    def resolve_update_error(self, other: Self) -> str:
+        """Resolve update errors in the article outline.
+
+        Returns:
+            str: Error message indicating update errors in the article outline.
+        """
+
+    @abstractmethod
+    def _update_from_inner(self, other: Self) -> Self:
+        """Updates the current instance with the attributes of another instance."""
+
+    @final
+    def update_from(self, other: Self) -> Self:
+        """Updates the current instance with the attributes of another instance."""
+        return self._update_pre_check(other)._update_from_inner(other)
+
+    def __eq__(self, other: "ArticleMainBase") -> bool:
+        """Compares two ArticleBase objects based on their model_dump_json representation."""
+        return self.model_dump_json() == other.model_dump_json()
+
+    def __hash__(self) -> int:
+        """Calculates a hash value for the ArticleBase object based on its model_dump_json representation."""
+        return hash(self.model_dump_json())