fabricatio 0.2.4.dev0__tar.gz → 0.2.4.dev1__tar.gz

{fabricatio-0.2.4.dev0 → fabricatio-0.2.4.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.4.dev0
+Version: 0.2.4.dev1
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12

{fabricatio-0.2.4.dev0 → fabricatio-0.2.4.dev1}/examples/extract_article/extract.py

@@ -1,8 +1,9 @@
 """Example of proposing a task to a role."""
 
 import asyncio
+from typing import List
 
-from fabricatio import Event, ExtractArticleEssence, Role, WorkFlow, logger
+from fabricatio import ArticleEssence, Event, ExtractArticleEssence, Role, Task, WorkFlow, logger
 
 
 async def main() -> None:
@@ -17,9 +18,11 @@ async def main() -> None:
             )
         },
     )
-    task = await role.propose_task("Extract the essence of the article from the file at './7.md'")
-    ess = await task.delegate("article")
-    logger.success(f"Essence:\n{ess}")
+    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__":

{fabricatio-0.2.4.dev0 → fabricatio-0.2.4.dev1}/pyproject.toml

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

{fabricatio-0.2.4.dev0 → fabricatio-0.2.4.dev1}/python/fabricatio/__init__.py

@@ -9,6 +9,7 @@ from fabricatio.fs import magika
 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
@@ -18,6 +19,7 @@ from fabricatio.toolboxes import arithmetic_toolbox, basic_toolboxes, fs_toolbox
 
 __all__ = [
     "Action",
+    "ArticleEssence",
     "Capture",
     "CodeBlockCapture",
     "Event",

fabricatio-0.2.4.dev1/python/fabricatio/actions/article.py

@@ -0,0 +1,44 @@
+"""Actions for transmitting tasks to targets."""
+
+from os import PathLike
+from pathlib import Path
+from typing import Callable, List
+
+from fabricatio.journal import logger
+from fabricatio.models.action import Action
+from fabricatio.models.extra import ArticleEssence
+from fabricatio.models.task import Task
+
+
+class ExtractArticleEssence(Action):
+    """Extract the essence of article(s)."""
+
+    name: str = "extract article essence"
+    """The name of the action."""
+    description: str = "Extract the essence of an article. output as json"
+    """The description of the action."""
+
+    output_key: str = "article_essence"
+    """The key of the output data."""
+
+    async def _execute[P: PathLike | str](
+        self,
+        task_input: Task,
+        reader: Callable[[P], str] = lambda p: Path(p).read_text(encoding="utf-8"),
+        **_,
+    ) -> List[ArticleEssence]:
+        if not await self.ajudge(
+            f"= Task\n{task_input.briefing}\n\n\n= Role\n{self.briefing}",
+            affirm_case="The task does not violate the role, and could be approved since the file dependencies are specified.",
+            deny_case="The task does violate the role, and could not be approved.",
+        ):
+            logger.info(err := "Task not approved.")
+            raise RuntimeError(err)
+
+        # trim the references
+        contents = ["References".join(c.split("References")[:-1]) for c in map(reader, task_input.dependencies)]
+        return await self.propose(
+            ArticleEssence,
+            contents,
+            system_message=f"# your personal briefing: \n{self.briefing}",
+        )

{fabricatio-0.2.4.dev0 → fabricatio-0.2.4.dev1}/python/fabricatio/capabilities/rating.py

@@ -131,8 +131,7 @@ class GiveRating(WithBriefing, LLMUsage):
 
         def _validator(response: str) -> Dict[str, str] | None:
             if (
-                (json_data := JsonCapture.convert_with(response, orjson.loads)) is not None
-                and isinstance(json_data, dict)
+                (json_data := JsonCapture.validate_with(response, target_type=dict, elements_type=str)) is not None
                 and json_data.keys() == criteria
                 and all(isinstance(v, str) for v in json_data.values())
             ):
@@ -173,11 +172,10 @@ class GiveRating(WithBriefing, LLMUsage):
 
         def _validator(response: str) -> Set[str] | None:
             if (
-                (json_data := JsonCapture.convert_with(response, orjson.loads)) is not None
-                and isinstance(json_data, list)
-                and all(isinstance(v, str) for v in json_data)
-                and (criteria_count == 0 or len(json_data) == criteria_count)
-            ):
+                json_data := JsonCapture.validate_with(
+                    response, target_type=list, elements_type=str, length=criteria_count
+                )
+            ) is not None:
                 return set(json_data)
             return None
 
@@ -219,27 +217,6 @@ class GiveRating(WithBriefing, LLMUsage):
         Returns:
             Set[str]: A set of drafted rating criteria.
         """
-
-        def _reasons_validator(response: str) -> List[str] | None:
-            if (
-                (json_data := JsonCapture.convert_with(response, orjson.loads)) is not None
-                and isinstance(json_data, list)
-                and all(isinstance(v, str) for v in json_data)
-                and len(json_data) == reasons_count
-            ):
-                return json_data
-            return None
-
-        def _criteria_validator(response: str) -> Set[str] | None:
-            if (
-                (json_data := JsonCapture.convert_with(response, orjson.loads)) is not None
-                and isinstance(json_data, list)
-                and all(isinstance(v, str) for v in json_data)
-                and len(json_data) == criteria_count
-            ):
-                return set(json_data)
-            return None
-
         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(
@@ -256,7 +233,9 @@ class GiveRating(WithBriefing, LLMUsage):
                     )
                     for pair in (permutations(examples, 2))
                 ],
-                validator=_reasons_validator,
+                validator=lambda resp: JsonCapture.validate_with(
+                    resp, target_type=list, elements_type=str, length=reasons_count
+                ),
                 **kwargs,
             )
         )
@@ -272,7 +251,9 @@ class GiveRating(WithBriefing, LLMUsage):
                     },
                 )
             ),
-            validator=_criteria_validator,
+            validator=lambda resp: set(out)
+            if (out := JsonCapture.validate_with(resp, target_type=list, elements_type=str, length=criteria_count))
+            else None,
             **kwargs,
         )
 
@@ -295,11 +276,6 @@ class GiveRating(WithBriefing, LLMUsage):
         if len(criteria) < 2:  # noqa: PLR2004
             raise ValueError("At least two criteria are required to draft rating weights")
 
-        def _validator(resp: str) -> float | None:
-            if (cap := JsonCapture.convert_with(resp, orjson.loads)) is not None and isinstance(cap, float):
-                return cap
-            return None
-
         criteria = list(criteria)  # freeze the order
         windows = windowed(criteria, 2)
 
@@ -316,7 +292,7 @@ class GiveRating(WithBriefing, LLMUsage):
                 )
                 for pair in windows
             ],
-            validator=_validator,
+            validator=lambda resp: JsonCapture.validate_with(resp, target_type=float),
             **GenerateKwargs(system_message=f"# your personal briefing: \n{self.briefing}", **kwargs),
         )
         weights = [1]

{fabricatio-0.2.4.dev0 → fabricatio-0.2.4.dev1}/python/fabricatio/models/action.py

@@ -92,9 +92,8 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
         Returns:
             Self: The instance of the workflow with the injected personality.
         """
-        for a in self._instances:
-            if not a.personality:
-                a.personality = personality
+        for a in filter(lambda action: not action.personality, self._instances):
+            a.personality = personality
         return self
 
     async def serve(self, task: Task) -> None:

fabricatio-0.2.4.dev0/python/fabricatio/actions/article.py → fabricatio-0.2.4.dev1/python/fabricatio/models/extra.py

@@ -1,16 +1,9 @@
-"""Actions for transmitting tasks to targets."""
+"""Extra models for built-in actions."""
 
-from os import PathLike
-from pathlib import Path
-from typing import Callable, List
+from typing import List
 
-from pydantic import BaseModel, Field
-from pydantic.config import ConfigDict
-
-from fabricatio.journal import logger
-from fabricatio.models.action import Action
-from fabricatio.models.generic import ProposedAble
-from fabricatio.models.task import Task
+from fabricatio.models.generic import Display, PrepareVectorization, ProposedAble
+from pydantic import BaseModel, ConfigDict, Field
 
 
 class Equation(BaseModel):
@@ -36,8 +29,28 @@ class Figure(BaseModel):
     figure_caption: str = Field(...)
     """The caption accompanying the figure, summarizing its main points and academic value."""
 
+    figure_path: str = Field(...)
+    """The file path to the figure"""
+
+
+class Highlightings(BaseModel):
+    """Structured representation of highlighted elements in an academic paper (including equations, algorithms, figures, and tables)."""
+
+    # Academic Achievements Showcase
+    highlighted_equations: List[Equation] = Field(default_factory=list)
+    """Core mathematical equations that represent breakthroughs in the field, accompanied by explanations of their physical or conceptual significance."""
+
+    highlighted_algorithms: List[str] = Field(default_factory=list)
+    """Pseudocode for key algorithms, annotated to highlight innovative components."""
+
+    highlighted_figures: List[Figure] = Field(default_factory=list)
+    """Critical diagrams or illustrations, each accompanied by a caption explaining their academic importance."""
+
+    highlighted_tables: List[str] = Field(default_factory=list)
+    """Important data tables, annotated to indicate statistical significance or other notable findings."""
 
-class ArticleEssence(ProposedAble):
+
+class ArticleEssence(ProposedAble, Display, PrepareVectorization):
     """Structured representation of the core elements of an academic paper(providing a comprehensive digital profile of the paper's essential information)."""
 
     # Basic Metadata
@@ -66,19 +79,6 @@ class ArticleEssence(ProposedAble):
     technical_novelty: List[str] = Field(default_factory=list)
     """Specific technical innovations introduced by the research, listed as individual points."""
 
-    # Academic Achievements Showcase
-    highlighted_equations: List[Equation] = Field(default_factory=list)
-    """Core mathematical equations that represent breakthroughs in the field, accompanied by explanations of their physical or conceptual significance."""
-
-    highlighted_algorithms: List[str] = Field(default_factory=list)
-    """Pseudocode for key algorithms, annotated to highlight innovative components."""
-
-    highlighted_figures: List[Figure] = Field(default_factory=list)
-    """Critical diagrams or illustrations, each accompanied by a caption explaining their academic importance."""
-
-    highlighted_tables: List[str] = Field(default_factory=list)
-    """Important data tables, annotated to indicate statistical significance or other notable findings."""
-
     # Academic Discussion Dimensions
     research_problem: str = Field("")
     """A clearly defined research question or problem addressed by the study."""
@@ -92,36 +92,5 @@ class ArticleEssence(ProposedAble):
     impact_analysis: str = Field("")
     """An assessment of the paper's potential influence on the development of the field."""
 
-
-class ExtractArticleEssence(Action):
-    """Extract the essence of article(s)."""
-
-    name: str = "extract article essence"
-    """The name of the action."""
-    description: str = "Extract the essence of an article. output as json"
-    """The description of the action."""
-
-    output_key: str = "article_essence"
-    """The key of the output data."""
-
-    async def _execute[P: PathLike | str](
-        self,
-        task_input: Task,
-        reader: Callable[[P], str] = lambda p: Path(p).read_text(encoding="utf-8"),
-        **_,
-    ) -> List[ArticleEssence]:
-        if not await self.ajudge(
-            f"= Task\n{task_input.briefing}\n\n\n= Role\n{self.briefing}",
-            affirm_case="The task does not violate the role, and could be approved since the file dependencies are specified.",
-            deny_case="The task does violate the role, and could not be approved.",
-        ):
-            logger.info(err := "Task not approved.")
-            raise RuntimeError(err)
-
-        # trim the references
-        contents = ["References".join(c.split("References")[:-1]) for c in map(reader, task_input.dependencies)]
-        return await self.propose(
-            ArticleEssence,
-            contents,
-            system_message=f"# your personal briefing: \n{self.briefing}",
-        )
+    def _prepare_vectorization_inner(self) -> str:
+        return self.model_dump_json()

{fabricatio-0.2.4.dev0 → fabricatio-0.2.4.dev1}/python/fabricatio/models/generic.py

@@ -1,5 +1,6 @@
 """This module defines generic classes for models in the Fabricatio library."""
 
+from abc import abstractmethod
 from pathlib import Path
 from typing import Callable, Iterable, List, Optional, Self, Union, final
 
@@ -8,6 +9,7 @@ from fabricatio._rust import blake3_hash
 from fabricatio._rust_instances import template_manager
 from fabricatio.config import configs
 from fabricatio.fs.readers import magika, safe_text_read
+from fabricatio.journal import logger
 from fabricatio.parser import JsonCapture
 from pydantic import (
     BaseModel,
@@ -27,6 +29,18 @@ class Base(BaseModel):
     model_config = ConfigDict(use_attribute_docstrings=True)
 
 
+class Display(Base):
+    """Class that provides a method to display the model in a formatted JSON string."""
+
+    def display(self) -> str:
+        """Display the model in a formatted JSON string.
+
+        Returns:
+            str: The formatted JSON string of the model.
+        """
+        return self.model_dump_json(indent=1)
+
+
 class Named(Base):
     """Class that includes a name attribute."""
 
@@ -199,6 +213,28 @@ class WithDependency(Base):
         )
 
 
+class PrepareVectorization(Base):
+    """Class that prepares the vectorization of the model."""
+
+    @abstractmethod
+    def _prepare_vectorization_inner(self) -> str:
+        """Prepare the vectorization of the model."""
+
+    def prepare_vectorization(self, max_length: Optional[int] = None) -> str:
+        """Prepare the vectorization of the model.
+
+        Returns:
+            str: The prepared vectorization of the model.
+        """
+        max_length = max_length or configs.embedding.max_sequence_length
+        chunk = self._prepare_vectorization_inner()
+        if len(chunk) > max_length:
+            logger.error(err := f"Chunk exceeds maximum sequence length {max_length}.")
+            raise ValueError(err)
+
+        return chunk
+
+
 class ScopedConfig(Base):
     """Class that manages a scoped configuration."""
 

{fabricatio-0.2.4.dev0 → fabricatio-0.2.4.dev1}/python/fabricatio/models/usages.py

@@ -5,7 +5,6 @@ from typing import Callable, Dict, Iterable, List, Optional, Self, Set, Type, Un
 
 import asyncstdlib
 import litellm
-import orjson
 from fabricatio._rust_instances import template_manager
 from fabricatio.config import configs
 from fabricatio.journal import logger
@@ -23,6 +22,7 @@ from litellm.types.utils import (
     StreamingChoices,
 )
 from litellm.utils import CustomStreamWrapper
+from more_itertools import duplicates_everseen
 from pydantic import Field, NonNegativeInt, PositiveInt
 
 
@@ -212,11 +212,10 @@ class LLMUsage(ScopedConfig):
                     **kwargs,
                 )
             ) and (validated := validator(response)):
-                logger.debug(f"Successfully validated the response at {i}th attempt. response: \n{response}")
+                logger.debug(f"Successfully validated the response at {i}th attempt.")
                 return validated
-            logger.debug(f"Failed to validate the response at {i}th attempt. response: \n{response}")
-        logger.error(f"Failed to validate the response after {max_validations} attempts.")
-        raise ValueError("Failed to validate the response.")
+        logger.error(err := f"Failed to validate the response after {max_validations} attempts.")
+        raise ValueError(err)
 
     async def aask_validate_batch[T](
         self,
@@ -255,7 +254,7 @@ class LLMUsage(ScopedConfig):
                 configs.templates.liststr_template,
                 {"requirement": requirement, "k": k},
             ),
-            lambda resp: JsonCapture.validate_with(resp, orjson.loads, list, str, k),
+            lambda resp: JsonCapture.validate_with(resp, target_type=list, elements_type=str, length=k),
             **kwargs,
         )
 
@@ -282,6 +281,9 @@ class LLMUsage(ScopedConfig):
             - Ensures response compliance through JSON parsing and format validation.
             - Relies on `aask_validate` to implement retry mechanisms with validation.
         """
+        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(
             configs.templates.make_choice_template,
             {
@@ -291,19 +293,16 @@ class LLMUsage(ScopedConfig):
             },
         )
         names = {c.name for c in choices}
+
         logger.debug(f"Start choosing between {names} with prompt: \n{prompt}")
 
         def _validate(response: str) -> List[T] | None:
-            ret = JsonCapture.convert_with(response, orjson.loads)
-
-            if not isinstance(ret, List) or (0 < k != len(ret)):
-                logger.error(f"Incorrect Type or length of response: \n{ret}")
-                return None
-            if any(n not in names for n in ret):
-                logger.error(f"Invalid choice in response: \n{ret}")
+            ret = JsonCapture.validate_with(response, target_type=List, elements_type=str, length=k)
+            if ret is None or set(ret) - names:
                 return None
-
-            return [next(toolbox for toolbox in choices if toolbox.name == toolbox_str) for toolbox_str in ret]
+            return [
+                next(candidate for candidate in choices if candidate.name == candidate_name) for candidate_name in ret
+            ]
 
         return await self.aask_validate(
             question=prompt,
@@ -357,19 +356,12 @@ class LLMUsage(ScopedConfig):
         Returns:
             bool: The judgment result (True or False) based on the AI's response.
         """
-
-        def _validate(response: str) -> bool | None:
-            ret = JsonCapture.convert_with(response, orjson.loads)
-            if not isinstance(ret, bool):
-                return None
-            return ret
-
         return await self.aask_validate(
             question=template_manager.render_template(
                 configs.templates.make_judgment_template,
                 {"prompt": prompt, "affirm_case": affirm_case, "deny_case": deny_case},
             ),
-            validator=_validate,
+            validator=lambda resp: JsonCapture.validate_with(resp, target_type=bool),
             **kwargs,
         )
 

{fabricatio-0.2.4.dev0 → fabricatio-0.2.4.dev1}/python/fabricatio/parser.py

@@ -2,6 +2,7 @@
 
 from typing import Any, Callable, Optional, Self, Tuple, Type
 
+import orjson
 import regex
 from pydantic import BaseModel, ConfigDict, Field, PositiveInt, PrivateAttr, ValidationError
 from regex import Pattern, compile
@@ -27,11 +28,7 @@ class Capture(BaseModel):
     _compiled: Pattern = PrivateAttr()
 
     def model_post_init(self, __context: Any) -> None:
-        """Initialize the compiled regular expression pattern after the model is initialized.
-
-        Args:
-            __context (Any): The context in which the model is initialized.
-        """
+        """Initialize the compiled pattern."""
         self._compiled = compile(self.pattern, self.flags)
 
     def capture(self, text: str) -> Tuple[str, ...] | str | None:
@@ -69,7 +66,6 @@ class Capture(BaseModel):
         if (cap := self.capture(text)) is None:
             return None
         try:
-            logger.debug(f"Trying to convert: \n{cap}")
             return convertor(cap)
         except (ValueError, SyntaxError, ValidationError) as e:
             logger.error(f"Failed to convert text using {convertor.__name__} to convert.\nerror: {e}\n {cap}")
@@ -78,19 +74,19 @@ class Capture(BaseModel):
     def validate_with[K, T, E](
         self,
         text: str,
-        deserializer: Callable[[Tuple[str, ...]], K] | Callable[[str], K],
         target_type: Type[T],
         elements_type: Optional[Type[E]] = None,
         length: Optional[int] = None,
+        deserializer: Callable[[Tuple[str, ...]], K] | Callable[[str], K] = orjson.loads,
     ) -> T | None:
         """Validate the given text using the pattern.
 
         Args:
             text (str): The text to search the pattern in.
-            deserializer (Callable[[Tuple[str, ...]], K] | Callable[[str], K]): The function to deserialize the captured text.
-            target_type (Type[T]): The expected type of the output.
-            elements_type (Optional[Type[E]]): The expected type of the elements in the output.
+            target_type (Type[T]): The expected type of the output, dict or list.
+            elements_type (Optional[Type[E]]): The expected type of the elements in the output dict keys or list elements.
             length (Optional[int]): The expected length of the output, bool(length)==False means no length validation.
+            deserializer (Callable[[Tuple[str, ...]], K] | Callable[[str], K]): The function to deserialize the captured text.
 
         Returns:
             T | None: The validated text if the pattern is found and the output is of the expected type, otherwise None.

{fabricatio-0.2.4.dev0 → fabricatio-0.2.4.dev1}/tests/test_models/test_action.py

@@ -61,13 +61,13 @@ async def test_action_act_with_output_key():
 
 
 def test_action_briefing_without_personality(basic_action):
-    briefing = basic_action.briefing()
+    briefing = basic_action.briefing
     assert "personality" not in briefing.lower()
 
 
 def test_action_briefing_with_personality():
     action = DemoAction(personality="Helper")
-    briefing = action.briefing()
+    briefing = action.briefing
     assert "personality" in briefing.lower()
     assert "Helper" in briefing
 

{fabricatio-0.2.4.dev0 → fabricatio-0.2.4.dev1}/tests/test_models/test_task.py

@@ -27,8 +27,8 @@ async def test_task_status_changes(basic_task):
 
 @pytest.mark.asyncio
 async def test_task_publishing(basic_task):
-    await basic_task.publish()
-    assert basic_task._status == TaskStatus.Pending
+    basic_task.publish()
+    assert basic_task.is_pending()
 
 
 @pytest.mark.asyncio

{fabricatio-0.2.4.dev0 → fabricatio-0.2.4.dev1}/uv.lock

@@ -1,5 +1,4 @@
 version = 1
-revision = 1
 requires-python = "==3.12.*"
 
 [[package]]
@@ -216,7 +215,7 @@ wheels = [
 
 [[package]]
 name = "fabricatio"
-version = "0.2.4.dev0"
+version = "0.2.4.dev1"
 source = { editable = "." }
 dependencies = [
     { name = "appdirs" },
@@ -278,7 +277,6 @@ requires-dist = [
     { name = "regex", specifier = ">=2024.11.6" },
     { name = "rich", specifier = ">=13.9.4" },
 ]
-provides-extras = ["rag", "full"]
 
 [package.metadata.requires-dev]
 dev = [