fabricatio 0.2.6.dev2__tar.gz → 0.2.6.dev4__tar.gz

{fabricatio-0.2.6.dev2 → fabricatio-0.2.6.dev4}/Makefile

@@ -12,16 +12,16 @@ tools:
 	rm $(DATA)/scripts/*.dwarf || true
 
 dev: tools
-	uvx  --with-editable . maturin develop --uv -r
+	uvx --project . maturin develop --uv -r
 
 bdist:clean tools
-	uvx  --with-editable . maturin sdist -o $(DIST)
-	uvx  --with-editable . maturin build  -r -o $(DIST)
+	uvx --project . maturin sdist -o $(DIST)
+	uvx --project . maturin build  -r -o $(DIST)
 
 clean:
 	rm -rf $(DIST) $(DATA)
 
 publish:tools
-	uvx  --with-editable . maturin publish --skip-existing
-	uvx  --with-editable . maturin upload --skip-existing $(DIST)/*
+	uvx --project . maturin publish --skip-existing
+	uvx --project . maturin upload --skip-existing $(DIST)/*
 .PHONY: tools

{fabricatio-0.2.6.dev2 → fabricatio-0.2.6.dev4}/PKG-INFO

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

fabricatio-0.2.6.dev4/examples/correct/correct_loop.py

@@ -0,0 +1,30 @@
+"""Example of review usage."""
+
+import asyncio
+
+from fabricatio import Role, logger
+from questionary import confirm
+from rich import print as r_print
+
+
+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, you should using derive mode of clap."
+    )
+
+    logger.success(f"Code: \n{code}")
+
+    while await confirm("Do you want to review the code?").ask_async():
+        code = await role.correct_string(code, topic="If the cli app is of good design", supervisor_check=False)
+        r_print(code)
+    logger.success(f"Corrected: \n{code}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

{fabricatio-0.2.6.dev2 → fabricatio-0.2.6.dev4}/examples/extract_and_review/extract_and_review.py

@@ -4,7 +4,8 @@ import asyncio
 from pathlib import Path
 from typing import List
 
-from fabricatio import ArticleEssence, Event, ExtractArticleEssence, Role, Task, WorkFlow, logger
+from fabricatio import ArticleEssence, Event, Role, Task, WorkFlow, logger
+from fabricatio.actions.article import ExtractArticleEssence
 from fabricatio.fs.curd import dump_text, gather_files
 
 

{fabricatio-0.2.6.dev2 → fabricatio-0.2.6.dev4}/examples/extract_article/extract.py

@@ -3,7 +3,8 @@
 import asyncio
 from typing import List
 
-from fabricatio import ArticleEssence, Event, ExtractArticleEssence, Role, Task, WorkFlow, logger
+from fabricatio import ArticleEssence, Event, Role, Task, WorkFlow, logger
+from fabricatio.actions.article import ExtractArticleEssence
 
 
 async def main() -> None:

fabricatio-0.2.6.dev4/examples/search_bibtex/.gitignore

@@ -0,0 +1 @@
+*.bib

fabricatio-0.2.6.dev4/examples/search_bibtex/search.py

@@ -0,0 +1,11 @@
+"""Example of using BibManager."""
+from fabricatio import BibManager, logger
+
+b = BibManager("Exported Items.bib")
+logger.success(
+    b.get_cite_key("A Negative Selection Immune System Inspired Methodology for Fault Diagnosis of Wind Turbines"))
+logger.success(
+    b.get_cite_key_fuzzy(
+        "System Inspired Methodology for Fault"
+    )
+)

fabricatio-0.2.6.dev4/examples/write_outline/write_outline_corrected.py

@@ -0,0 +1,44 @@
+"""Example of using the library."""
+
+import asyncio
+
+from fabricatio import Event, Role, WorkFlow, logger
+from fabricatio.actions.article import CorrectOutline, CorrectProposal, GenerateArticleProposal, GenerateOutline
+from fabricatio.actions.output import DumpFinalizedOutput
+
+
+async def main() -> None:
+    """Main function."""
+    role = Role(
+        name="Undergraduate Researcher",
+        description="Write an outline for an article in typst format.",
+        llm_top_p=0.8,
+        llm_temperature=1.15,
+        registry={
+            Event.quick_instantiate(ns := "article"): WorkFlow(
+                name="Generate Article Outline",
+                description="Generate an outline for an article. dump the outline to the given path. in typst format.",
+                steps=(
+                    GenerateArticleProposal(llm_model="deepseek/deepseek-reasoner", llm_temperature=1.3),
+                    CorrectProposal(
+                        output_key="article_proposal",
+                        llm_model="deepseek/deepseek-reasoner",
+                        llm_temperature=1.3,
+                    ),
+                    GenerateOutline(llm_model="deepseek/deepseek-chat", llm_temperature=1.4, llm_top_p=0.5),
+                    CorrectOutline(output_key="to_dump", llm_temperature=1.4, llm_top_p=0.45),
+                    DumpFinalizedOutput(output_key="task_output"),
+                ),
+            )
+        },
+    )
+
+    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())

{fabricatio-0.2.6.dev2 → fabricatio-0.2.6.dev4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fabricatio"
-version = "0.2.6-dev2"
+version = "0.2.6-dev4"
 description = "A LLM multi-agent framework."
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -85,7 +85,7 @@ full = [
 ]
 
 [tool.ruff]
-include = ["pyproject.toml", "python/fabricatio/*.py","python/fabricatio/*.pyi", "examples/*.py"]
+include = ["pyproject.toml", "python/fabricatio/*.py", "python/fabricatio/*.pyi", "examples/*.py"]
 line-length = 120
 target-version = "py312"
 [tool.ruff.format]

fabricatio-0.2.6.dev4/python/fabricatio/__init__.py

@@ -0,0 +1,43 @@
+"""Fabricatio is a Python library for building llm app using event-based agent structure."""
+
+from importlib.util import find_spec
+
+from fabricatio import actions, toolboxes, workflows
+from fabricatio._rust import BibManager
+from fabricatio._rust_instances import TEMPLATE_MANAGER
+from fabricatio.core import env
+from fabricatio.journal import logger
+from fabricatio.models import extra
+from fabricatio.models.action import Action, WorkFlow
+from fabricatio.models.events import Event
+from fabricatio.models.role import Role
+from fabricatio.models.task import Task
+from fabricatio.models.tool import ToolBox
+from fabricatio.parser import Capture, GenericCapture, JsonCapture, PythonCapture
+
+__all__ = [
+    "TEMPLATE_MANAGER",
+    "Action",
+    "BibManager",
+    "Capture",
+    "Event",
+    "GenericCapture",
+    "JsonCapture",
+    "PythonCapture",
+    "Role",
+    "Task",
+    "ToolBox",
+    "WorkFlow",
+    "actions",
+    "env",
+    "extra",
+    "logger",
+    "toolboxes",
+    "workflows",
+]
+
+
+if find_spec("pymilvus"):
+    from fabricatio.capabilities.rag import RAG
+
+    __all__ += ["RAG"]

{fabricatio-0.2.6.dev2 → fabricatio-0.2.6.dev4}/python/fabricatio/_rust.pyi

@@ -9,8 +9,9 @@ class TemplateManager:
 
     See: https://crates.io/crates/handlebars
     """
+
     def __init__(
-        self, template_dirs: List[Path], suffix: Optional[str] = None, active_loading: Optional[bool] = None
+            self, template_dirs: List[Path], suffix: Optional[str] = None, active_loading: Optional[bool] = None
     ) -> None:
         """Initialize the template manager.
 
@@ -54,6 +55,7 @@ class TemplateManager:
             RuntimeError: If template rendering fails
         """
 
+
 def blake3_hash(content: bytes) -> str:
     """Calculate the BLAKE3 cryptographic hash of data.
 
@@ -64,6 +66,7 @@ def blake3_hash(content: bytes) -> str:
         Hex-encoded BLAKE3 hash string
     """
 
+
 class BibManager:
     """BibTeX bibliography manager for parsing and querying citation data."""
 
@@ -100,3 +103,13 @@ class BibManager:
             Uses nucleo_matcher for high-quality fuzzy text searching
             See: https://crates.io/crates/nucleo-matcher
         """
+
+    def list_titles(self, is_verbatim: Optional[bool] = False) -> List[str]:
+        """List all titles in the bibliography.
+
+        Args:
+            is_verbatim: Whether to return verbatim titles (without formatting)
+
+        Returns:
+            List of all titles in the bibliography
+        """

{fabricatio-0.2.6.dev2 → fabricatio-0.2.6.dev4}/python/fabricatio/actions/article.py

@@ -2,13 +2,15 @@
 
 from os import PathLike
 from pathlib import Path
-from typing import Callable, List, Optional
+from typing import Any, Callable, List, Optional
 
 from fabricatio.fs import safe_text_read
 from fabricatio.journal import logger
 from fabricatio.models.action import Action
 from fabricatio.models.extra import ArticleEssence, ArticleOutline, ArticleProposal
 from fabricatio.models.task import Task
+from questionary import confirm, text
+from rich import print as rprint
 
 
 class ExtractArticleEssence(Action):
@@ -66,7 +68,7 @@ class GenerateArticleProposal(Action):
 class GenerateOutline(Action):
     """Generate the article based on the outline."""
 
-    output_key: str = "article"
+    output_key: str = "article_outline"
     """The key of the output data."""
 
     async def _execute(
@@ -79,3 +81,45 @@ class GenerateOutline(Action):
             article_proposal.display(),
             system_message=f"# your personal briefing: \n{self.briefing}",
         )
+
+
+class CorrectProposal(Action):
+    """Correct the proposal of the article."""
+
+    output_key: str = "corrected_proposal"
+
+    async def _execute(self, task_input: Task, article_proposal: ArticleProposal, **_) -> Any:
+        input_path = await self.awhich_pathstr(
+            f"{task_input.briefing}\nExtract the path of file, which contains the article briefing that I need to read."
+        )
+
+        rprint(article_proposal.display())
+        ret = None
+        while await confirm("Do you want to correct the Proposal?").ask_async():
+            topic = await text("What is the topic of the proposal?").ask_async()
+            ret = await self.correct_obj(
+                article_proposal,
+                safe_text_read(input_path),
+                topic=topic,
+            )
+        return ret or article_proposal
+
+
+class CorrectOutline(Action):
+    """Correct the outline of the article."""
+
+    output_key: str = "corrected_outline"
+    """The key of the output data."""
+
+    async def _execute(
+        self,
+        article_outline: ArticleOutline,
+        article_proposal: ArticleProposal,
+        **_,
+    ) -> Optional[str]:
+        rprint(article_outline.finalized_dump())
+        ret = None
+        while await confirm("Do you want to correct the outline?").ask_async():
+            topic = await text("What is the topic of the outline?").ask_async()
+            ret = await self.correct_obj(article_outline, article_proposal.display(), topic=topic)
+        return ret or article_outline

{fabricatio-0.2.6.dev2 → fabricatio-0.2.6.dev4}/python/fabricatio/models/extra.py

@@ -126,7 +126,7 @@ class ArticleSectionOutline(Base):
     """The title of the section."""
     description: str = Field(...)
     """A brief description of the section's content should be, how it fits into the overall structure of the paper, and its significance in the context of the research."""
-    subsections: List[ArticleSubsectionOutline] = Field(default_factory=list)
+    subsections: List[ArticleSubsectionOutline]
     """The subsections of the section, outlining their content and significance."""
 
 
@@ -137,7 +137,7 @@ class ArticleChapterOutline(Base):
     """The title of the chapter."""
     description: str = Field(...)
     """A brief description of the chapter's content should be, how it fits into the overall structure of the paper, and its significance in the context of the research."""
-    sections: List[ArticleSectionOutline] = Field(default_factory=list)
+    sections: List[ArticleSectionOutline]
     """The sections of the chapter, outlining their content and significance."""
 
 
@@ -150,7 +150,7 @@ class ArticleOutline(ProposedAble, Display, FinalizedDumpAble):
     prospect: str = Field(...)
     """A brief description of the research problem or question that the paper aims to address manipulating methods or techniques"""
 
-    chapters: List[ArticleChapterOutline] = Field(default_factory=list)
+    chapters: List[ArticleChapterOutline]
     """The chapters of the paper, outlining their content and significance."""
 
     def finalized_dump(self) -> str:

{fabricatio-0.2.6.dev2 → fabricatio-0.2.6.dev4}/python/fabricatio/models/kwargs_types.py

@@ -1,6 +1,6 @@
 """This module contains the types for the keyword arguments of the methods in the models module."""
 
-from typing import Any, TypedDict
+from typing import Any, Required, TypedDict
 
 from litellm.caching.caching import CacheMode
 from litellm.types.caching import CachingSupportedCallTypes
@@ -91,7 +91,7 @@ class ReviewKwargs[T](ValidateKwargs[T], total=False):
     specific topics and review criteria.
     """
 
-    topic: str
+    topic: Required[str]
     criteria: set[str]
 
 

{fabricatio-0.2.6.dev2 → fabricatio-0.2.6.dev4}/python/fabricatio/parser.py

@@ -64,6 +64,7 @@ class Capture(BaseModel):
         """
         match = self._compiled.search(text)
         if match is None:
+            logger.debug(f"Capture Failed: \n{text}")
             return None
         groups = self.fix(match.groups()) if configs.general.use_json_repair else match.groups()
         if self.target_groups:

fabricatio-0.2.6.dev4/python/fabricatio/workflows/articles.py

@@ -0,0 +1,26 @@
+"""Store article essence in the database."""
+
+from fabricatio.actions.article import CorrectOutline, CorrectProposal, GenerateArticleProposal, GenerateOutline
+from fabricatio.actions.output import DumpFinalizedOutput
+from fabricatio.models.action import WorkFlow
+
+WriteOutlineWorkFlow = WorkFlow(
+    name="Generate Article Outline",
+    description="Generate an outline for an article. dump the outline to the given path. in typst format.",
+    steps=(
+        GenerateArticleProposal,
+        GenerateOutline(output_key="to_dump"),
+        DumpFinalizedOutput(output_key="task_output"),
+    ),
+)
+WriteOutlineCorrectedWorkFlow = WorkFlow(
+    name="Generate Article Outline",
+    description="Generate an outline for an article. dump the outline to the given path. in typst format.",
+    steps=(
+        GenerateArticleProposal,
+        CorrectProposal(output_key="article_proposal"),
+        GenerateOutline,
+        CorrectOutline(output_key="to_dump"),
+        DumpFinalizedOutput(output_key="task_output"),
+    ),
+)

fabricatio-0.2.6.dev4/src/bib_tools.rs

@@ -0,0 +1,88 @@
+use biblatex::{Bibliography, ChunksExt};
+use nucleo_matcher::pattern::{AtomKind, CaseMatching, Normalization, Pattern};
+use nucleo_matcher::{Config, Matcher, Utf32Str};
+use pyo3::exceptions::PyRuntimeError;
+use pyo3::prelude::*;
+use rayon::prelude::*;
+
+#[pyclass]
+pub struct BibManager {
+    source: Bibliography,
+}
+
+
+#[pymethods]
+impl BibManager {
+    /// Create a new BibManager instance.
+    #[new]
+    fn new(path: String) -> PyResult<Self> {
+        let bib = std::fs::read_to_string(path)
+            .map_err(|e| PyErr::new::<PyRuntimeError, _>(e.to_string()))?;
+
+        let source = Bibliography::parse(&bib)
+            .map_err(|e| PyErr::new::<PyRuntimeError, _>(e.to_string()))?;
+
+        Ok(BibManager { source })
+    }
+
+    /// find the cite key of an article with given title
+    fn get_cite_key(&self, title: String) -> Option<String> {
+        let title_lower = title.to_lowercase();
+
+        self.source.iter().par_bridge()
+            .find_map_any(|entry| {
+                let entry_title = entry.title()
+                    .map_err(|e| PyErr::new::<PyRuntimeError, _>(format!("{}", e)))
+                    .ok()?
+                    .to_biblatex_string(false)
+                    .replace("{", "")
+                    .replace("}", "")
+                    .to_lowercase();
+
+                (entry_title == title_lower).then(|| entry.key.clone())
+            })
+    }
+
+    /// Find the corresponding cite key of an article with given query string using fuzzy matcher
+    fn get_cite_key_fuzzy(&self, query: String) -> Option<String> {
+        let mut matcher = Matcher::new(Config::DEFAULT);
+        let pattern = Pattern::new(
+            query.as_str(),
+            CaseMatching::Ignore,
+            Normalization::Smart,
+            AtomKind::Substring,
+        );
+
+
+        self.source.iter()
+            .map(|entry| {
+                let mut buf = vec![];
+                let text = entry.to_biblatex_string().replace("{", "")
+                    .replace("}", "");
+                (pattern.score(Utf32Str::new(text.as_str(), &mut buf), &mut matcher), entry)
+            })
+            .par_bridge()
+            // Use filter_map's more concise form with pattern matching
+            .filter_map(|(maybe_score, entry)| maybe_score.map(|score| (score, entry)))
+            .max_by_key(|(score, _)| *score)
+            .map(|(_, entry)| entry.key.clone())
+    }
+    #[pyo3(signature = (is_verbatim=false))]
+    fn list_titles(&self, is_verbatim: bool) -> Vec<String> {
+        self.source.iter().map(|entry| {
+            entry.title()
+                .map_err(|e| PyErr::new::<PyRuntimeError, _>(format!("{}", e)))
+                .ok()
+                .unwrap()
+                .to_biblatex_string(is_verbatim)
+                .replace("{", "")
+                .replace("}", "")
+        }).collect::<Vec<_>>()
+    }
+}
+
+
+pub(crate) fn register(_: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_class::<BibManager>()?;
+    Ok(())
+}

{fabricatio-0.2.6.dev2 → fabricatio-0.2.6.dev4}/uv.lock

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

fabricatio-0.2.6.dev2/python/fabricatio/__init__.py

@@ -1,60 +0,0 @@
-"""Fabricatio is a Python library for building llm app using event-based agent structure."""
-
-from importlib.util import find_spec
-
-from fabricatio._rust import BibManager
-from fabricatio._rust_instances import TEMPLATE_MANAGER
-from fabricatio.actions.article import ExtractArticleEssence, GenerateArticleProposal, GenerateOutline
-from fabricatio.actions.output import DumpFinalizedOutput
-from fabricatio.core import env
-from fabricatio.fs import MAGIKA, safe_json_read, safe_text_read
-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
-from fabricatio.models.utils import Message, Messages
-from fabricatio.parser import Capture, GenericCapture, JsonCapture, PythonCapture
-from fabricatio.toolboxes import arithmetic_toolbox, basic_toolboxes, fs_toolbox
-from fabricatio.workflows.articles import WriteOutlineWorkFlow
-
-__all__ = [
-    "MAGIKA",
-    "TEMPLATE_MANAGER",
-    "Action",
-    "ArticleEssence",
-    "BibManager",
-    "Capture",
-    "DumpFinalizedOutput",
-    "Event",
-    "ExtractArticleEssence",
-    "GenerateArticleProposal",
-    "GenerateOutline",
-    "GenericCapture",
-    "JsonCapture",
-    "Message",
-    "Messages",
-    "PythonCapture",
-    "Role",
-    "Task",
-    "ToolBox",
-    "WorkFlow",
-    "WriteOutlineWorkFlow",
-    "arithmetic_toolbox",
-    "basic_toolboxes",
-    "env",
-    "fs_toolbox",
-    "logger",
-    "safe_json_read",
-    "safe_text_read",
-]
-
-
-if find_spec("pymilvus"):
-    from fabricatio.actions.rag import InjectToDB
-    from fabricatio.capabilities.rag import RAG
-    from fabricatio.workflows.rag import StoreArticle
-
-    __all__ += ["RAG", "InjectToDB", "StoreArticle"]

fabricatio-0.2.6.dev2/python/fabricatio/workflows/articles.py

@@ -1,15 +0,0 @@
-"""Store article essence in the database."""
-
-from fabricatio.actions.article import GenerateArticleProposal, GenerateOutline
-from fabricatio.actions.output import DumpFinalizedOutput
-from fabricatio.models.action import WorkFlow
-
-WriteOutlineWorkFlow = WorkFlow(
-    name="Generate Article Outline",
-    description="Generate an outline for an article. dump the outline to the given path. in typst format.",
-    steps=(
-        GenerateArticleProposal,
-        GenerateOutline(output_key="to_dump"),
-        DumpFinalizedOutput(output_key="task_output"),
-    ),
-)

fabricatio-0.2.6.dev2/src/bib_tools.rs

@@ -1,73 +0,0 @@
-use biblatex::{Bibliography, ChunksExt};
-use nucleo_matcher::pattern::{AtomKind, CaseMatching, Normalization, Pattern};
-use nucleo_matcher::{Config, Matcher, Utf32Str};
-use pyo3::exceptions::PyRuntimeError;
-use pyo3::prelude::*;
-use rayon::prelude::*;
-
-#[pyclass]
-pub struct BibManager {
-    source:Bibliography,
-}
-
-
-#[pymethods]
-impl BibManager {
-    /// Create a new BibManager instance.
-    #[new]
-    fn new(path: String) -> PyResult<Self> {
-        let bib = std::fs::read_to_string(path)
-            .map_err(|e| PyErr::new::<PyRuntimeError, _>(e.to_string()))?;
-
-        let source = Bibliography::parse(&bib)
-            .map_err(|e| PyErr::new::<PyRuntimeError, _>(e.to_string()))?;
-
-        Ok(BibManager { source })
-    }
-
-    /// find the cite key of an article with given title
-fn get_cite_key(&self, title: String) -> Option<String> {
-    let title_lower = title.to_lowercase();
-
-    self.source.iter().par_bridge()
-        .find_map_any(|entry| {
-            let entry_title = entry.title()
-                .map_err(|e| PyErr::new::<PyRuntimeError, _>(format!("{}", e)))
-                .ok()?
-                .to_biblatex_string(false)
-                .to_lowercase();
-
-            (entry_title == title_lower).then(|| entry.key.clone())
-        })
-}
-
-    /// Find the corresponding cite key of an article with given query string using fuzzy matcher
-fn get_cite_key_fuzzy(&self, query: String) -> Option<String> {
-    let mut matcher = Matcher::new(Config::DEFAULT);
-    let pattern = Pattern::new(
-        query.as_str(),
-        CaseMatching::Ignore,
-        Normalization::Smart,
-        AtomKind::Substring,
-    );
-
-    self.source.iter()
-        .map(|entry| {
-            let mut buf = vec![];
-            let text = entry.to_biblatex_string();
-            (pattern.score(Utf32Str::new(text.as_str(), &mut buf), &mut matcher), entry)
-        })
-        .par_bridge()
-        // Use filter_map's more concise form with pattern matching
-        .filter_map(|(maybe_score, entry)| maybe_score.map(|score| (score, entry)))
-        .max_by_key(|(score, _)| *score)
-        .map(|(_, entry)| entry.key.clone())
-}
-
-}
-
-
-pub(crate) fn register(_: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
-    m.add_class::<BibManager>()?;
-    Ok(())
-}