fabricatio 0.2.1.dev4__tar.gz → 0.2.3.dev0__tar.gz

{fabricatio-0.2.1.dev4 → fabricatio-0.2.3.dev0}/PKG-INFO

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

{fabricatio-0.2.1.dev4 → fabricatio-0.2.3.dev0}/examples/make_a_rating/rating.py

@@ -58,12 +58,26 @@ class MakeCriteria(Action):
     name: str = "make criteria"
     output_key: str = "criteria"
 
-    async def _execute(self, task_input: Task, rate_topic: str, to_rate: List[str], **cxt: Unpack) -> Set[str]:
+    async def _execute(self, rate_topic: str, to_rate: List[str], **cxt: Unpack) -> Set[str]:
         criteria = await self.draft_rating_criteria_from_examples(rate_topic, to_rate)
         logger.info(f"Criteria: \n{criteria}")
         return set(criteria)
 
 
+class MakeCompositeScore(Action):
+    """Make a composite score."""
+
+    name: str = "make composite score"
+
+    output_key: str = "task_output"
+
+    async def _execute(self, rate_topic: str, to_rate: List[str], **cxt: Unpack) -> List[float]:
+        return await self.composite_score(
+            rate_topic,
+            to_rate,
+        )
+
+
 async def main() -> None:
     """Main function."""
     role = Role(
@@ -85,6 +99,13 @@ async def main() -> None:
                     "rate_topic": "if the food is 'good'",
                 },
             ),
+            Event.instantiate_from("make_composite_score").push_wildcard().push("pending"): WorkFlow(
+                name="Make composite score",
+                steps=(WhatToRate, MakeCompositeScore),
+                extra_init_context={
+                    "rate_topic": "if the food is 'good'",
+                },
+            ),
         },
     )
     task = await role.propose(
@@ -98,6 +119,10 @@ async def main() -> None:
 
     logger.success(f"Generated Criteria: \n{generated_criteria}")
 
+    composite_score = await task.move_to("make_composite_score").delegate()
+
+    logger.success(f"Composite Score: \n{composite_score}")
+
 
 if __name__ == "__main__":
     asyncio.run(main())

{fabricatio-0.2.1.dev4 → fabricatio-0.2.3.dev0}/examples/task_handle/handle_task.py

@@ -56,6 +56,30 @@ class WriteDocumentation(Action):
         return await self.aask(task_input.briefing, system_message=task_input.dependencies_prompt)
 
 
+class TestCancel(Action):
+    """Action that says hello to the world."""
+
+    name: str = "cancel"
+    description: str = "cancel the task"
+    output_key: str = "counter"
+
+    async def _execute(self, counter: int, **_) -> int:
+        logger.info(f"Counter: {counter}")
+        await asyncio.sleep(5)
+        counter += 1
+        return counter
+
+
+class WriteToOutput(Action):
+    """Action that says hello to the world."""
+
+    name: str = "write to output"
+    output_key: str = "task_output"
+
+    async def _execute(self, **_) -> str:
+        return "hi, this is the output"
+
+
 async def main() -> None:
     """Main function."""
     role = Role(
@@ -68,20 +92,32 @@ async def main() -> None:
             Event.instantiate_from("doc").push_wildcard().push("pending"): WorkFlow(
                 name="write documentation", steps=(WriteDocumentation, DumpText)
             ),
+            Event.instantiate_from("cancel_test").push_wildcard().push("pending"): WorkFlow(
+                name="cancel_test",
+                steps=(TestCancel, TestCancel, TestCancel, TestCancel, TestCancel, TestCancel, WriteToOutput),
+                extra_init_context={"counter": 0},
+            ),
         },
     )
 
-    prompt = "i want you to write a cli app implemented with python , which can calculate the sum to a given n, all write to a single file names `cli.py`, put it in `output` folder."
-
-    proposed_task = await role.propose(prompt)
-    path = await proposed_task.move_to("coding").delegate()
+    proposed_task = await role.propose(
+        "i want you to write a cli app implemented with python , which can calculate the sum to a given n, all write to a single file names `cli.py`, put it in `output` folder."
+    )
+    path = await proposed_task.delegate("coding")
     logger.success(f"Code Path: {path}")
 
-    proposed_task = await role.propose(f"write Readme.md file for the code, source file {path},save it in `README.md`")
-    proposed_task.override_dependencies([path])
-    doc = await proposed_task.move_to("doc").delegate()
+    proposed_task = await role.propose(
+        f"write Readme.md file for the code, source file {path},save it in `README.md`,which is in the `output` folder, too."
+    )
+    proposed_task.override_dependencies(path)
+    doc = await proposed_task.delegate("doc")
     logger.success(f"Documentation: \n{doc}")
 
+    proposed_task.publish("cancel_test")
+    await proposed_task.cancel()
+    out = await proposed_task.get_output()
+    logger.info(f"Canceled Task Output: {out}")
+
 
 if __name__ == "__main__":
     asyncio.run(main())

{fabricatio-0.2.1.dev4 → fabricatio-0.2.3.dev0}/pyproject.toml

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

{fabricatio-0.2.1.dev4 → fabricatio-0.2.3.dev0}/python/fabricatio/capabilities/rating.py

@@ -12,7 +12,7 @@ from fabricatio.models.generic import WithBriefing
 from fabricatio.models.kwargs_types import GenerateKwargs, ValidateKwargs
 from fabricatio.models.usages import LLMUsage
 from fabricatio.parser import JsonCapture
-from more_itertools import flatten
+from more_itertools import flatten, windowed
 from pydantic import NonNegativeInt, PositiveInt
 
 
@@ -275,3 +275,81 @@ class GiveRating(WithBriefing, LLMUsage):
             validator=_criteria_validator,
             **kwargs,
         )
+
+    async def drafting_rating_weights_klee(
+        self,
+        topic: str,
+        criteria: Set[str],
+        **kwargs: Unpack[ValidateKwargs],
+    ) -> Dict[str, float]:
+        """Drafts rating weights for a given topic and criteria using the Klee method.
+
+        Args:
+            topic (str): The topic for the rating weights.
+            criteria (Set[str]): A set of criteria for the rating weights.
+            **kwargs (Unpack[ValidateKwargs]): Additional keyword arguments for the LLM usage.
+
+        Returns:
+            Dict[str, float]: A dictionary representing the drafted rating weights for each criterion.
+        """
+        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)
+
+        # get the importance multiplier indicating how important is second criterion compared to the first one
+        relative_weights = await self.aask_validate_batch(
+            questions=[
+                template_manager.render_template(
+                    configs.templates.draft_rating_weights_klee_template,
+                    {
+                        "topic": topic,
+                        "first": pair[0],
+                        "second": pair[1],
+                    },
+                )
+                for pair in windows
+            ],
+            validator=_validator,
+            **GenerateKwargs(system_message=f"# your personal briefing: \n{self.briefing}", **kwargs),
+        )
+        weights = [1]
+        for rw in relative_weights:
+            weights.append(weights[-1] * rw)
+        total = sum(weights)
+        return dict(zip(criteria, [w / total for w in weights], strict=True))
+
+    async def composite_score(
+        self,
+        topic: str,
+        to_rate: List[str],
+        reasons_count: PositiveInt = 2,
+        criteria_count: PositiveInt = 5,
+        **kwargs: Unpack[ValidateKwargs],
+    ) -> List[float]:
+        """Calculates the composite scores for a list of items based on a given topic and criteria.
+
+        Args:
+            topic (str): The topic for the rating.
+            to_rate (List[str]): A list of strings to be rated.
+            reasons_count (PositiveInt, optional): The number of reasons to extract from each pair of examples. Defaults to 2.
+            criteria_count (PositiveInt, optional): The number of criteria to draft. Defaults to 5.
+            **kwargs (Unpack[ValidateKwargs]): Additional keyword arguments for the LLM usage.
+
+        Returns:
+            List[float]: A list of composite scores for the items.
+        """
+        criteria = await self.draft_rating_criteria_from_examples(
+            topic, to_rate, reasons_count, criteria_count, **kwargs
+        )
+        weights = await self.drafting_rating_weights_klee(topic, criteria, **kwargs)
+        logger.info(f"Criteria: {criteria}\nWeights: {weights}")
+        ratings_seq = await self.rate(to_rate, topic, criteria, **kwargs)
+
+        return [sum(ratings[c] * weights[c] for c in criteria) for ratings in ratings_seq]

{fabricatio-0.2.1.dev4 → fabricatio-0.2.3.dev0}/python/fabricatio/config.py

@@ -172,6 +172,9 @@ class TemplateConfig(BaseModel):
     extract_criteria_from_reasons_template: str = Field(default="extract_criteria_from_reasons")
     """The name of the extract criteria from reasons template which will be used to extract criteria from reasons."""
 
+    draft_rating_weights_klee_template: str = Field(default="draft_rating_weights_klee")
+    """The name of the draft rating weights klee template which will be used to draft rating weights with Klee method."""
+
 
 class MagikaConfig(BaseModel):
     """Magika configuration class."""

{fabricatio-0.2.1.dev4 → fabricatio-0.2.3.dev0}/python/fabricatio/core.py

@@ -38,11 +38,11 @@ class Env(BaseModel):
 
     @overload
     def on[**P, R](
-            self,
-            event: str | Event,
-            func: Optional[Callable[P, R]] = None,
-            /,
-            ttl: int = -1,
+        self,
+        event: str | Event,
+        func: Optional[Callable[P, R]] = None,
+        /,
+        ttl: int = -1,
     ) -> Callable[[Callable[P, R]], Callable[P, R]]:
         """
         Registers an event listener with a specific function that listens indefinitely or for a specified number of times.
@@ -58,11 +58,11 @@ class Env(BaseModel):
         ...
 
     def on[**P, R](
-            self,
-            event: str | Event,
-            func: Optional[Callable[P, R]] = None,
-            /,
-            ttl=-1,
+        self,
+        event: str | Event,
+        func: Optional[Callable[P, R]] = None,
+        /,
+        ttl=-1,
     ) -> Callable[[Callable[P, R]], Callable[P, R]] | Self:
         """Registers an event listener with a specific function that listens indefinitely or for a specified number of times.
 
@@ -78,14 +78,13 @@ class Env(BaseModel):
             event = event.collapse()
         if func is None:
             return self._ee.on(event, ttl=ttl)
-
         self._ee.on(event, func, ttl=ttl)
         return self
 
     @overload
     def once[**P, R](
-            self,
-            event: str | Event,
+        self,
+        event: str | Event,
     ) -> Callable[[Callable[P, R]], Callable[P, R]]:
         """
         Registers an event listener that listens only once.
@@ -100,9 +99,9 @@ class Env(BaseModel):
 
     @overload
     def once[**P, R](
-            self,
-            event: str | Event,
-            func: Callable[[Callable[P, R]], Callable[P, R]],
+        self,
+        event: str | Event,
+        func: Callable[[Callable[P, R]], Callable[P, R]],
     ) -> Self:
         """
         Registers an event listener with a specific function that listens only once.
@@ -117,9 +116,9 @@ class Env(BaseModel):
         ...
 
     def once[**P, R](
-            self,
-            event: str | Event,
-            func: Optional[Callable[P, R]] = None,
+        self,
+        event: str | Event,
+        func: Optional[Callable[P, R]] = None,
     ) -> Callable[[Callable[P, R]], Callable[P, R]] | Self:
         """Registers an event listener with a specific function that listens only once.
 
@@ -163,5 +162,20 @@ class Env(BaseModel):
             event = event.collapse()
         return await self._ee.emit_async(event, *args, **kwargs)
 
+    def emit_future[**P](self, event: str | Event, *args: P.args, **kwargs: P.kwargs) -> None:
+        """Emits an event to all registered listeners and returns a future object.
+
+        Args:
+            event (str | Event): The event to emit.
+            *args: Positional arguments to pass to the listeners.
+            **kwargs: Keyword arguments to pass to the listeners.
+
+        Returns:
+            None: The future object.
+        """
+        if isinstance(event, Event):
+            event = event.collapse()
+        return self._ee.emit_future(event, *args, **kwargs)
+
 
 env = Env()

{fabricatio-0.2.1.dev4 → fabricatio-0.2.3.dev0}/python/fabricatio/models/action.py

@@ -2,7 +2,7 @@
 
 import traceback
 from abc import abstractmethod
-from asyncio import Queue
+from asyncio import Queue, create_task
 from typing import Any, Dict, Self, Tuple, Type, Union, Unpack
 
 from fabricatio.capabilities.rating import GiveRating
@@ -108,7 +108,11 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
         try:
             for step in self._instances:
                 logger.debug(f"Executing step: {step.name}")
-                modified_ctx = await step.act(await self._context.get())
+                act_task = create_task(step.act(await self._context.get()))
+                if task.is_cancelled():
+                    act_task.cancel(f"Cancelled by task: {task.name}")
+                    break
+                modified_ctx = await act_task
                 await self._context.put(modified_ctx)
                 current_action = step.name
             logger.info(f"Finished executing workflow: {self.name}")

{fabricatio-0.2.1.dev4 → fabricatio-0.2.3.dev0}/python/fabricatio/models/task.py

@@ -60,7 +60,7 @@ class Task[T](WithBriefing, WithJsonExample, WithDependency):
     dependencies: List[str] = Field(default_factory=list)
     """A list of file paths, These file are needed to read or write to meet a specific requirement of this task, if it is not directly given out, it SHALL just be a empty list meaning `NOT ASSIGNED`"""
 
-    _output: Queue = PrivateAttr(default_factory=lambda: Queue(maxsize=1))
+    _output: Queue[T | None] = PrivateAttr(default_factory=Queue)
     """The output queue of the task."""
 
     _status: TaskStatus = PrivateAttr(default=TaskStatus.Pending)
@@ -131,7 +131,7 @@ class Task[T](WithBriefing, WithJsonExample, WithDependency):
             self.description = description
         return self
 
-    async def get_output(self) -> T:
+    async def get_output(self) -> T | None:
         """Get the output of the task.
 
         Returns:
@@ -232,6 +232,7 @@ class Task[T](WithBriefing, WithJsonExample, WithDependency):
         """
         logger.info(f"Cancelling task `{self.name}`")
         self._status = TaskStatus.Cancelled
+        await self._output.put(None)
         await env.emit_async(self.cancelled_label, self)
         return self
 
@@ -243,27 +244,38 @@ class Task[T](WithBriefing, WithJsonExample, WithDependency):
         """
         logger.info(f"Failing task `{self.name}`")
         self._status = TaskStatus.Failed
+        await self._output.put(None)
         await env.emit_async(self.failed_label, self)
         return self
 
-    async def publish(self) -> Self:
+    def publish(self, new_namespace: Optional[EventLike] = None) -> Self:
         """Publish the task to the event bus.
 
+        Args:
+            new_namespace(EventLike, optional): The new namespace to move the task to.
+
         Returns:
-            Task: The published instance of the `Task` class
+            Task: The published instance of the `Task` class.
         """
+        if new_namespace:
+            self.move_to(new_namespace)
         logger.info(f"Publishing task `{(label := self.pending_label)}`")
-        await env.emit_async(label, self)
+        env.emit_future(label, self)
         return self
 
-    async def delegate(self) -> T:
-        """Delegate the task to the event bus and wait for the output.
+    async def delegate(self, new_namespace: Optional[EventLike] = None) -> T | None:
+        """Delegate the task to the event.
+
+        Args:
+            new_namespace(EventLike, optional): The new namespace to move the task to.
 
         Returns:
-            T: The output of the task
+            T|None: The output of the task.
         """
+        if new_namespace:
+            self.move_to(new_namespace)
         logger.info(f"Delegating task `{(label := self.pending_label)}`")
-        await env.emit_async(label, self)
+        env.emit_future(label, self)
         return await self.get_output()
 
     @property
@@ -277,3 +289,43 @@ class Task[T](WithBriefing, WithJsonExample, WithDependency):
             configs.templates.task_briefing_template,
             self.model_dump(),
         )
+
+    def is_running(self) -> bool:
+        """Check if the task is running.
+
+        Returns:
+            bool: True if the task is running, False otherwise.
+        """
+        return self._status == TaskStatus.Running
+
+    def is_finished(self) -> bool:
+        """Check if the task is finished.
+
+        Returns:
+            bool: True if the task is finished, False otherwise.
+        """
+        return self._status == TaskStatus.Finished
+
+    def is_failed(self) -> bool:
+        """Check if the task is failed.
+
+        Returns:
+            bool: True if the task is failed, False otherwise.
+        """
+        return self._status == TaskStatus.Failed
+
+    def is_cancelled(self) -> bool:
+        """Check if the task is cancelled.
+
+        Returns:
+            bool: True if the task is cancelled, False otherwise.
+        """
+        return self._status == TaskStatus.Cancelled
+
+    def is_pending(self) -> bool:
+        """Check if the task is pending.
+
+        Returns:
+            bool: True if the task is pending, False otherwise.
+        """
+        return self._status == TaskStatus.Pending

fabricatio-0.2.3.dev0/templates/built-in/draft_rating_weights_klee.hbs

@@ -0,0 +1,23 @@
+# Task:
+Please compare the following criteria for the topic "{{topic}}":
+
+First Criterion: {{first}}
+Second Criterion: {{second}}
+
+How much more important is the `{{second}}` compared to the `{{first}}` within the topic of `{{topic}}`? Provide a Positive floating-point number where 1.0 means they are equally important, values greater than 1.0 mean the `{{second}}` is more important, and values less than 1.0 mean the `{{first}}` is more important.
+Your response SHALL be a Positive floating-point number within a JSON codeblock.
+# Examples:
+
+Topic: "Best icecream"
+First Criterion: "Taste"
+Second Criterion: "Texture"
+
+----- Start of response example -----
+```json
+1.5
+```
+----- End of response example -----
+
+# Warning:
+- Your response must be a POSITIVE floating-point number within a JSON codeblock.
+- No explanation or additional information is needed, only the POSITIVE floating-point number.

{fabricatio-0.2.1.dev4 → fabricatio-0.2.3.dev0}/templates/built-in/extract_criteria_from_reasons.hbs

@@ -21,4 +21,4 @@ Extract 4 criteria from the given reasons list
 
 # Warning:
 - The output must be formatted as a JSON array with exactly {{criteria_count}} strings, each representing a distinct criterion. Follow the structure shown in the response example closely. Responses not matching this format will fail validation.
-
+- The criteria extracted should be relevant and distinct, ranking DESCENDING in terms of importance or frequency in the given reasons list.

{fabricatio-0.2.1.dev4 → fabricatio-0.2.3.dev0}/uv.lock

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