fabricatio 0.2.5.dev1__tar.gz → 0.2.5.dev3__tar.gz

{fabricatio-0.2.5.dev1 → fabricatio-0.2.5.dev3}/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.dev3}/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.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.5.dev1
+Version: 0.2.5.dev3
 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.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.dev3/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.dev3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fabricatio"
-version = "0.2.5-dev1"
+version = "0.2.5-dev3"
 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.dev3/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.dev3}/python/fabricatio/_rust_instances.py

@@ -1,3 +1,5 @@
+"""Some necessary instances."""
+
 from fabricatio._rust import TemplateManager
 from fabricatio.config import configs
 

{fabricatio-0.2.5.dev1 → 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.dev1 → fabricatio-0.2.5.dev3}/python/fabricatio/capabilities/rating.py

@@ -2,9 +2,9 @@
 
 from asyncio import gather
 from itertools import permutations
+from random import sample
 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
@@ -17,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,
@@ -113,7 +117,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]:
@@ -189,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],
@@ -201,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.dev3/python/fabricatio/capabilities/review.py

@@ -0,0 +1,242 @@
+"""A module that provides functionality to rate tasks based on a rating manual and score range."""
+
+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 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
+from rich import print
+
+
+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):
+    """Represents the outcome of a review process with identified problems and solutions.
+
+    This class maintains a structured collection of problems found during a review,
+    their proposed solutions, and a reference to the original reviewed object.
+
+    Attributes:
+        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.
+    """
+
+    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."""
+
+    _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.
+
+        Args:
+            ref (K): The new reference object to be associated with this review.
+
+        Returns:
+            ReviewResult[K]: The current instance with updated reference type.
+        """
+        self._ref = ref
+        return self
+
+    def deref(self) -> T:
+        """Retrieve the referenced object that was reviewed.
+
+        Returns:
+            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.
+        """
+        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.(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:
+            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.(Default: retain all)\n\t`{to_exam.problem}`",
+                    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.
+
+    This class extends GiveRating and Propose capabilities to analyze content,
+    identify problems, and suggest solutions based on specified criteria.
+
+    The review process can be applied to Task objects or plain strings with
+    appropriate topic and criteria.
+    """
+
+    async def review_task[T](self, task: Task[T], **kwargs: Unpack[ReviewKwargs]) -> ReviewResult[Task[T]]:
+        """Review a task using specified review criteria.
+
+        This method analyzes a task object to identify problems and propose solutions
+        based on the criteria provided in kwargs.
+
+        Args:
+            task (Task[T]): The task object to be reviewed.
+            **kwargs (Unpack[ReviewKwargs]): Additional keyword arguments for the review process,
+                including topic and optional criteria.
+
+        Returns:
+            ReviewResult[Task[T]]: A review result containing identified problems and proposed solutions,
+                with a reference to the original task.
+        """
+        return await self.review_obj(task, **kwargs)
+
+    async def review_string(
+        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.
+
+        This method analyzes a text string to identify problems and propose solutions
+        based on the given topic and criteria.
+
+        Args:
+            text (str): The text content to be reviewed.
+            topic (str): The subject topic for the review criteria.
+            criteria (Optional[Set[str]], optional): A set of criteria for the review.
+                If not provided, criteria will be drafted automatically. Defaults to None.
+            **kwargs (Unpack[GenerateKwargs]): Additional keyword arguments for the LLM usage.
+
+        Returns:
+            ReviewResult[str]: A review result containing identified problems and proposed solutions,
+                with a reference to the original text.
+        """
+        criteria = criteria or (await self.draft_rating_criteria(topic))
+        manual = await self.draft_rating_manual(topic, criteria)
+        res: ReviewResult[str] = await self.propose(
+            ReviewResult,
+            template_manager.render_template(
+                configs.templates.review_string_template, {"text": text, "topic": topic, "criteria_manual": manual}
+            ),
+            **kwargs,
+        )
+        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.
+
+        This method extracts displayable text from the object and performs a review
+        based on the criteria provided in kwargs.
+
+        Args:
+            obj (M): The object to be reviewed, which must implement either Display or WithBriefing.
+            **kwargs (Unpack[ReviewKwargs]): Additional keyword arguments for the review process,
+                including topic and optional criteria.
+
+        Raises:
+            TypeError: If the object does not implement Display or WithBriefing.
+
+        Returns:
+            ReviewResult[M]: A review result containing identified problems and proposed solutions,
+                with a reference to the original object.
+        """
+        if isinstance(obj, Display):
+            text = obj.display()
+        elif isinstance(obj, WithBriefing):
+            text = obj.briefing
+        else:
+            raise TypeError(f"Unsupported type for review: {type(obj)}")
+
+        return (await self.review_string(text, **kwargs)).update_ref(obj)

{fabricatio-0.2.5.dev1 → fabricatio-0.2.5.dev3}/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.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.dev1 → 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.dev1 → 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.")