fabricatio 0.2.5.dev1__tar.gz → 0.2.5.dev2__tar.gz

{fabricatio-0.2.5.dev1 → fabricatio-0.2.5.dev2}/Cargo.lock

@@ -448,6 +448,7 @@ dependencies = [
  "biblatex",
  "blake3",
  "handlebars",
+ "nucleo-matcher",
  "pyo3",
  "pythonize",
  "rayon",
@@ -1052,6 +1053,16 @@ dependencies = [
  "tempfile",
 ]
 
+[[package]]
+name = "nucleo-matcher"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf33f538733d1a5a3494b836ba913207f14d9d4a1d3cd67030c5061bdd2cac85"
+dependencies = [
+ "memchr",
+ "unicode-segmentation",
+]
+
 [[package]]
 name = "num-modular"
 version = "0.6.1"
@@ -1913,6 +1924,12 @@ dependencies = [
  "tinyvec",
 ]
 
+[[package]]
+name = "unicode-segmentation"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493"
+
 [[package]]
 name = "unindent"
 version = "0.2.3"

{fabricatio-0.2.5.dev1 → fabricatio-0.2.5.dev2}/Cargo.toml

@@ -9,6 +9,7 @@ crate-type = ["cdylib"]
 biblatex = "0.10.0"
 blake3 = "1.6.0"
 handlebars = "6.3.1"
+nucleo-matcher = "0.3.1"
 pyo3 = { version = "0.23.4", features = ["extension-module"] }
 pythonize = "0.23.0"
 rayon = "1.10.0"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.5.dev1
+Version: 0.2.5.dev2
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12
@@ -9,7 +9,6 @@ Classifier: Framework :: AsyncIO
 Classifier: Framework :: Pydantic :: 2
 Classifier: Typing :: Typed
 Requires-Dist: appdirs>=1.4.4
-Requires-Dist: async-cache>=1.1.1
 Requires-Dist: asyncio>=3.4.3
 Requires-Dist: asyncstdlib>=3.13.0
 Requires-Dist: litellm>=1.60.0

fabricatio-0.2.5.dev2/examples/reviewer/review.py

@@ -0,0 +1,27 @@
+"""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(True)
+    logger.success(f"Review: \n{res.display()}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

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

@@ -1,6 +1,6 @@
 [project]
 name = "fabricatio"
-version = "0.2.5-dev1"
+version = "0.2.5-dev2"
 description = "A LLM multi-agent framework."
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -28,7 +28,6 @@ keywords = [
 requires-python = ">=3.12,<3.13"
 dependencies = [
     "appdirs>=1.4.4",
-    "async-cache>=1.1.1",
     "asyncio>=3.4.3",
     "asyncstdlib>=3.13.0",
     "litellm>=1.60.0",

fabricatio-0.2.5.dev2/python/fabricatio/_rust.pyi

@@ -0,0 +1,102 @@
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+class TemplateManager:
+    """Template rendering engine using Handlebars templates.
+
+    This manager handles template discovery, loading, and rendering
+    through a wrapper around the handlebars-rust engine.
+
+    See: https://crates.io/crates/handlebars
+    """
+    def __init__(
+        self, template_dirs: List[Path], suffix: Optional[str] = None, active_loading: Optional[bool] = None
+    ) -> None:
+        """Initialize the template manager.
+
+        Args:
+            template_dirs: List of directories containing template files
+            suffix: File extension for templates (defaults to 'hbs')
+            active_loading: Whether to enable dev mode for reloading templates on change
+        """
+
+    @property
+    def template_count(self) -> int:
+        """Returns the number of currently loaded templates."""
+
+    def get_template_source(self, name: str) -> Optional[str]:
+        """Get the filesystem path for a template.
+
+        Args:
+            name: Template name (without extension)
+
+        Returns:
+            Path to the template file if found, None otherwise
+        """
+
+    def discover_templates(self) -> None:
+        """Scan template directories and load available templates.
+
+        This refreshes the template cache, finding any new or modified templates.
+        """
+
+    def render_template(self, name: str, data: Dict[str, Any]) -> str:
+        """Render a template with context data.
+
+        Args:
+            name: Template name (without extension)
+            data: Context dictionary to provide variables to the template
+
+        Returns:
+            Rendered template content as string
+
+        Raises:
+            RuntimeError: If template rendering fails
+        """
+
+def blake3_hash(content: bytes) -> str:
+    """Calculate the BLAKE3 cryptographic hash of data.
+
+    Args:
+        content: Bytes to be hashed
+
+    Returns:
+        Hex-encoded BLAKE3 hash string
+    """
+
+class BibManager:
+    """BibTeX bibliography manager for parsing and querying citation data."""
+
+    def __init__(self, path: str) -> None:
+        """Initialize the bibliography manager.
+
+        Args:
+            path: Path to BibTeX (.bib) file to load
+
+        Raises:
+            RuntimeError: If file cannot be read or parsed
+        """
+
+    def get_cite_key(self, title: str) -> Optional[str]:
+        """Find citation key by exact title match.
+
+        Args:
+            title: Full title to search for (case-insensitive)
+
+        Returns:
+            Citation key if exact match found, None otherwise
+        """
+
+    def get_cite_key_fuzzy(self, query: str) -> Optional[str]:
+        """Find best matching citation using fuzzy text search.
+
+        Args:
+            query: Search term to find in bibliography entries
+
+        Returns:
+            Citation key of best matching entry, or None if no good match
+
+        Notes:
+            Uses nucleo_matcher for high-quality fuzzy text searching
+            See: https://crates.io/crates/nucleo-matcher
+        """

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

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

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

@@ -4,7 +4,6 @@ from asyncio import gather
 from itertools import permutations
 from typing import Dict, List, Set, Tuple, Union, Unpack, overload
 
-from cache import AsyncLRU
 from fabricatio._rust_instances import template_manager
 from fabricatio.config import configs
 from fabricatio.journal import logger
@@ -113,7 +112,6 @@ class GiveRating(WithBriefing, LLMUsage):
             return await gather(*[self.rate_fine_grind(item, manual, score_range, **kwargs) for item in to_rate])
         raise ValueError("to_rate must be a string or a list of strings")
 
-    @AsyncLRU(maxsize=32)
     async def draft_rating_manual(
         self, topic: str, criteria: Set[str], **kwargs: Unpack[ValidateKwargs]
     ) -> Dict[str, str]:

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

@@ -1,60 +1,135 @@
 """A module that provides functionality to rate tasks based on a rating manual and score range."""
 
-from typing import List, Optional, Set, Unpack
+from typing import List, Optional, Self, Set, Unpack
 
 from fabricatio import template_manager
 from fabricatio.capabilities.propose import Propose
 from fabricatio.capabilities.rating import GiveRating
 from fabricatio.config import configs
-from fabricatio.models.generic import Display, ProposedAble, WithBriefing
+from fabricatio.models.generic import Base, Display, ProposedAble, WithBriefing
 from fabricatio.models.kwargs_types import GenerateKwargs, ReviewKwargs
 from fabricatio.models.task import Task
 from pydantic import PrivateAttr
+from questionary import Choice, checkbox
+
+
+class ProblemSolutions(Base):
+    """Represents a problem-solution pair identified during a review process.
+
+    This class encapsulates a single problem with its corresponding potential solutions,
+    providing a structured way to manage review findings.
+
+    Attributes:
+        problem (str): The problem statement identified during review.
+        solutions (List[str]): A collection of potential solutions to address the problem.
+    """
+
+    problem: str
+    """The problem identified in the review."""
+    solutions: List[str]
+    """A collection of potential solutions to address the problem."""
+
+    def update_problem(self, problem: str) -> Self:
+        """Update the problem description.
+
+        Args:
+            problem (str): The new problem description to replace the current one.
+
+        Returns:
+            Self: The current instance with updated problem description.
+        """
+        self.problem = problem
+        return self
+
+    def update_solutions(self, solutions: List[str]) -> Self:
+        """Update the list of potential solutions.
+
+        Args:
+            solutions (List[str]): The new collection of solutions to replace the current ones.
+
+        Returns:
+            Self: The current instance with updated solutions.
+        """
+        self.solutions = solutions
+        return self
 
 
 class ReviewResult[T](ProposedAble, Display):
-    """Class that represents the result of a review.
+    """Represents the outcome of a review process with identified problems and solutions.
 
-    This class holds the problems identified in a review and their proposed solutions,
-    along with a reference to the reviewed object.
+    This class maintains a structured collection of problems found during a review,
+    their proposed solutions, and a reference to the original reviewed object.
 
     Attributes:
-        existing_problems (List[str]): List of problems identified in the review.
-        proposed_solutions (List[str]): List of proposed solutions to the problems identified in the review.
+        review_topic (str): The subject or focus area of the review.
+        problem_solutions (List[ProblemSolutions]): Collection of problems identified
+            during review along with their potential solutions.
 
     Type Parameters:
         T: The type of the object being reviewed.
     """
 
-    existing_problems: List[str]
-    """List of problems identified in the review."""
+    review_topic: str
+    """The subject or focus area of the review."""
 
-    proposed_solutions: List[str]
-    """List of proposed solutions to the problems identified in the review."""
+    problem_solutions: List[ProblemSolutions]
+    """Collection of problems identified during review along with their potential solutions."""
 
     _ref: T = PrivateAttr(None)
-    """Reference to the object being reviewed."""
+    """Reference to the original object that was reviewed."""
 
     def update_ref[K](self, ref: K) -> "ReviewResult[K]":
-        """Update the reference to the object being reviewed.
+        """Update the reference to the reviewed object.
 
         Args:
-            ref (K): The new reference to the object being reviewed.
+            ref (K): The new reference object to be associated with this review.
 
         Returns:
-            ReviewResult[K]: The updated instance of the ReviewResult class with the new reference type.
+            ReviewResult[K]: The current instance with updated reference type.
         """
         self._ref = ref
         return self
 
     def deref(self) -> T:
-        """Dereference the object being reviewed.
+        """Retrieve the referenced object that was reviewed.
 
         Returns:
-            T: The object being reviewed.
+            T: The original object that was reviewed.
         """
         return self._ref
 
+    async def supervisor_check(self, check_solutions: bool = False) -> Self:
+        """Perform an interactive review session to filter problems and solutions.
+
+        Presents an interactive prompt allowing a supervisor to select which
+        problems (and optionally solutions) should be retained in the final review.
+
+        Args:
+            check_solutions (bool, optional): When True, also prompts for filtering
+                individual solutions for each retained problem. Defaults to False.
+
+        Returns:
+            Self: The current instance with filtered problems and solutions.
+        """
+        # Choose the problems to retain
+        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)",
+            choices=[Choice(p.problem, p, checked=True) for p in self.problem_solutions],
+        ).ask_async()
+        if not check_solutions:
+            self.problem_solutions = chosen_ones
+            return self
+
+        # Choose the solutions to retain
+        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)",
+                    choices=[Choice(s, s, checked=True) for s in to_exam.solutions],
+                ).ask_async()
+            )
+        return self
+
 
 class Review(GiveRating, Propose):
     """Class that provides functionality to review tasks and strings using a language model.

{fabricatio-0.2.5.dev1 → fabricatio-0.2.5.dev2}/python/fabricatio/config.py

@@ -3,6 +3,7 @@
 from typing import List, Literal, Optional
 
 from appdirs import user_config_dir
+from litellm.types.caching import LiteLLMCacheType
 from pydantic import (
     BaseModel,
     ConfigDict,
@@ -25,6 +26,8 @@ from pydantic_settings import (
     TomlConfigSettingsSource,
 )
 
+from fabricatio.models.kwargs_types import CacheKwargs
+
 ROAMING_DIR = user_config_dir("fabricatio", "", roaming=True)
 
 
@@ -265,6 +268,19 @@ class RagConfig(BaseModel):
     """The dimensions of the Milvus server."""
 
 
+class CacheConfig(BaseModel):
+    """cache configuration class, uses litellm as cache backend. more info see https://docs.litellm.ai/docs/caching/all_caches."""
+
+    model_config = ConfigDict(use_attribute_docstrings=True)
+
+    type: Optional[LiteLLMCacheType] = None
+    """The type of cache to use. If None, the default cache type will be used."""
+    params: CacheKwargs = Field(default_factory=CacheKwargs)
+    """The parameters for the cache. If type is None, the default parameters will be used."""
+    enabled: bool = Field(default=False)
+    """Whether to enable cache."""
+
+
 class Settings(BaseSettings):
     """Application settings class.
 
@@ -314,6 +330,9 @@ class Settings(BaseSettings):
     rag: RagConfig = Field(default_factory=RagConfig)
     """RAG Configuration"""
 
+    cache: CacheConfig = Field(default_factory=CacheConfig)
+    """Cache Configuration"""
+
     @classmethod
     def settings_customise_sources(
         cls,

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

@@ -1,7 +1,9 @@
 """This module contains the types for the keyword arguments of the methods in the models module."""
 
-from typing import List, NotRequired, Set, TypedDict
+from typing import Any, List, NotRequired, Set, TypedDict
 
+from litellm.caching.caching import CacheMode
+from litellm.types.caching import CachingSupportedCallTypes
 from pydantic import NonNegativeFloat, NonNegativeInt, PositiveInt
 
 
@@ -65,3 +67,40 @@ class ChooseKwargs(GenerateKwargs):
     """A type representing the keyword arguments for the choose method."""
 
     k: NotRequired[NonNegativeInt]
+
+
+class CacheKwargs(TypedDict, total=False):
+    """A type representing the keyword arguments for the cache method."""
+
+    mode: NotRequired[CacheMode]  # when default_on cache is always on, when default_off cache is opt in
+    host: NotRequired[str]
+    port: NotRequired[str]
+    password: NotRequired[str]
+    namespace: NotRequired[str]
+    ttl: NotRequired[float]
+    default_in_memory_ttl: NotRequired[float]
+    default_in_redis_ttl: NotRequired[float]
+    similarity_threshold: NotRequired[float]
+    supported_call_types: NotRequired[List[CachingSupportedCallTypes]]
+    # s3 Bucket, boto3 configuration
+    s3_bucket_name: NotRequired[str]
+    s3_region_name: NotRequired[str]
+    s3_api_version: NotRequired[str]
+    s3_use_ssl: NotRequired[bool]
+    s3_verify: NotRequired[bool | str]
+    s3_endpoint_url: NotRequired[str]
+    s3_aws_access_key_id: NotRequired[str]
+    s3_aws_secret_access_key: NotRequired[str]
+    s3_aws_session_token: NotRequired[str]
+    s3_config: NotRequired[Any]
+    s3_path: NotRequired[str]
+    redis_semantic_cache_use_async: bool
+    redis_semantic_cache_embedding_model: str
+    redis_flush_size: NotRequired[int]
+    redis_startup_nodes: NotRequired[List]
+    disk_cache_dir: Any
+    qdrant_api_base: NotRequired[str]
+    qdrant_api_key: NotRequired[str]
+    qdrant_collection_name: NotRequired[str]
+    qdrant_quantization_config: NotRequired[str]
+    qdrant_semantic_cache_embedding_model: str

{fabricatio-0.2.5.dev1 → fabricatio-0.2.5.dev2}/python/fabricatio/models/role.py

@@ -15,7 +15,7 @@ from pydantic import Field
 class Role(ProposeTask, HandleTask, Review):
     """Class that represents a role with a registry of events and workflows."""
 
-    registry: dict[Event | str, WorkFlow] = Field(...)
+    registry: dict[Event | str, WorkFlow] = Field(default_factory=dict)
     """ The registry of events and workflows."""
 
     toolboxes: Set[ToolBox] = Field(default_factory=set)

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

@@ -25,6 +25,14 @@ from litellm.utils import CustomStreamWrapper
 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)
+
 
 class LLMUsage(ScopedConfig):
     """Class that manages LLM (Large Language Model) usage parameters and methods."""
@@ -105,14 +113,14 @@ class LLMUsage(ScopedConfig):
     async def aask(
         self,
         question: List[str],
-        system_message: Optional[List[str]] = None,
+        system_message: List[str],
         **kwargs: Unpack[LLMKwargs],
     ) -> List[str]: ...
     @overload
     async def aask(
         self,
         question: str,
-        system_message: Optional[List[str]] = None,
+        system_message: List[str],
         **kwargs: Unpack[LLMKwargs],
     ) -> List[str]: ...
     @overload
@@ -148,36 +156,23 @@ class LLMUsage(ScopedConfig):
             str | List[str]: The content of the model's response message.
         """
         system_message = system_message or ""
-        match (isinstance(question, list), isinstance(system_message, list)):
-            case (True, True):
+        match (question, system_message):
+            case (list(q_seq), list(sm_seq)):
                 res = await gather(
                     *[
                         self.ainvoke(n=1, question=q, system_message=sm, **kwargs)
-                        for q, sm in zip(question, system_message, strict=True)
+                        for q, sm in zip(q_seq, sm_seq, strict=True)
                     ]
                 )
                 return [r.pop().message.content for r in res]
-            case (True, False):
-                res = await gather(
-                    *[self.ainvoke(n=1, question=q, system_message=system_message, **kwargs) for q in question]
-                )
+            case (list(q_seq), str(sm)):
+                res = await gather(*[self.ainvoke(n=1, question=q, system_message=sm, **kwargs) for q in q_seq])
                 return [r.pop().message.content for r in res]
-            case (False, True):
-                res = await gather(
-                    *[self.ainvoke(n=1, question=question, system_message=sm, **kwargs) for sm in system_message]
-                )
+            case (str(q), list(sm_seq)):
+                res = await gather(*[self.ainvoke(n=1, question=q, system_message=sm, **kwargs) for sm in sm_seq])
                 return [r.pop().message.content for r in res]
-            case (False, False):
-                return (
-                    (
-                        await self.ainvoke(
-                            n=1,
-                            question=question,
-                            system_message=system_message,
-                            **kwargs,
-                        )
-                    ).pop()
-                ).message.content
+            case (str(q), str(sm)):
+                return ((await self.ainvoke(n=1, question=q, system_message=sm, **kwargs)).pop()).message.content
             case _:
                 raise RuntimeError("Should not reach here.")
 
@@ -514,7 +509,7 @@ class ToolBoxUsage(LLMUsage):
             logger.warning("No toolboxes available.")
             return []
         return await self.achoose(
-            instruction=task.briefing,  # TODO write a template to build a more robust instruction
+            instruction=task.briefing,
             choices=list(self.toolboxes),
             k=k,
             max_validations=max_validations,
@@ -548,7 +543,7 @@ class ToolBoxUsage(LLMUsage):
             logger.warning(f"No tools available in toolbox {toolbox.name}.")
             return []
         return await self.achoose(
-            instruction=task.briefing,  # TODO write a template to build a more robust instruction
+            instruction=task.briefing,
             choices=toolbox.tools,
             k=k,
             max_validations=max_validations,

fabricatio-0.2.5.dev2/src/bib_tools.rs

@@ -0,0 +1,73 @@
+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(())
+}

fabricatio-0.2.5.dev2/src/hbs_helpers.rs

@@ -0,0 +1,9 @@
+use handlebars::handlebars_helper;
+use serde_json::Value;
+
+handlebars_helper!(len: |v: Value| match v {
+    Value::Array(arr) => arr.len(),
+    Value::Object(obj) => obj.len(),
+    Value::String(s) => s.len(),
+    _ => 0
+});