fabricatio 0.2.1.dev2__tar.gz → 0.2.1.dev4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.1.dev2
+Version: 0.2.1.dev4
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12
@@ -15,6 +15,7 @@ Requires-Dist: gitpython>=3.1.44
 Requires-Dist: litellm>=1.60.0
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: magika>=0.5.1
+Requires-Dist: more-itertools>=10.6.0
 Requires-Dist: orjson>=3.10.15
 Requires-Dist: pydantic>=2.10.6
 Requires-Dist: pydantic-settings>=2.7.1
@@ -22,7 +23,6 @@ Requires-Dist: pymitter>=1.0.0
 Requires-Dist: questionary>=2.1.0
 Requires-Dist: regex>=2024.11.6
 Requires-Dist: rich>=13.9.4
-Requires-Dist: faiss-cpu>=1.10.0 ; extra == 'rag'
 Requires-Dist: pymilvus>=2.5.4 ; extra == 'rag'
 Requires-Dist: fabricatio[rag] ; extra == 'full'
 Provides-Extra: rag

fabricatio-0.2.1.dev4/examples/make_a_rating/rating.py

@@ -0,0 +1,103 @@
+"""Example of proposing a task to a role."""
+
+import asyncio
+from typing import Dict, List, Set, Unpack
+
+import orjson
+from fabricatio import Action, JsonCapture, Role, WorkFlow, logger
+from fabricatio.models.events import Event
+from fabricatio.models.task import Task
+
+
+class Rate(Action):
+    """Rate the task."""
+
+    name: str = "rate"
+    output_key: str = "task_output"
+
+    async def _execute(self, to_rate: List[str], rate_topic: str, criteria: Set[str], **_) -> List[Dict[str, float]]:
+        logger.info(f"Rating the: \n{to_rate}")
+        """Rate the task."""
+        return await self.rate(
+            to_rate,
+            rate_topic,
+            criteria,
+        )
+
+
+class WhatToRate(Action):
+    """Figure out what to rate."""
+
+    name: str = "figure out what to rate"
+
+    output_key: str = "to_rate"
+
+    async def _execute(self, task_input: Task, rate_topic: str, **cxt: Unpack) -> List[str]:
+        def _validate(resp: str) -> List[str] | None:
+            if (
+                (cap := JsonCapture.convert_with(resp, orjson.loads)) is not None
+                and isinstance(cap, list)
+                and all(isinstance(i, str) for i in cap)
+            ):
+                return cap
+            return None
+
+        return await self.aask_validate(
+            f"This is task briefing:\n{task_input.briefing}\n\n"
+            f"We are talking about {rate_topic}. you need to extract targets to rate into a the JSON array\n"
+            f"The response SHALL be a JSON array of strings within the codeblock\n"
+            f"# Example\n"
+            f'```json\n["this is a target to rate", "this is another target to rate"]\n```',
+            _validate,
+        )
+
+
+class MakeCriteria(Action):
+    """Make criteria for rating."""
+
+    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]:
+        criteria = await self.draft_rating_criteria_from_examples(rate_topic, to_rate)
+        logger.info(f"Criteria: \n{criteria}")
+        return set(criteria)
+
+
+async def main() -> None:
+    """Main function."""
+    role = Role(
+        name="TaskRater",
+        description="A role that can rate tasks.",
+        registry={
+            Event.instantiate_from("rate_food").push_wildcard().push("pending"): WorkFlow(
+                name="Rate food",
+                steps=(WhatToRate, Rate),
+                extra_init_context={
+                    "rate_topic": "If this food is cheap and delicious",
+                    "criteria": {"taste", "price", "quality", "safety", "healthiness"},
+                },
+            ),
+            Event.instantiate_from("make_criteria_for_food").push_wildcard().push("pending"): WorkFlow(
+                name="Make criteria for food",
+                steps=(WhatToRate, MakeCriteria, Rate),
+                extra_init_context={
+                    "rate_topic": "if the food is 'good'",
+                },
+            ),
+        },
+    )
+    task = await role.propose(
+        "rate these food, so that i can decide what to eat today. choco cake, strawberry icecream, giga burger, cup of coffee, rotten bread from the trash bin, and a salty of fruit salad",
+    )
+    rating = await task.move_to("rate_food").delegate()
+
+    logger.success(f"Result: \n{rating}")
+
+    generated_criteria = await task.move_to("make_criteria_for_food").delegate()
+
+    logger.success(f"Generated Criteria: \n{generated_criteria}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

{fabricatio-0.2.1.dev2 → fabricatio-0.2.1.dev4}/examples/minor/hello_fabricatio.py

@@ -5,7 +5,7 @@ from typing import Any
 
 from fabricatio import Action, Role, Task, WorkFlow, logger
 
-task = Task(name="say hello", goal="say hello", description="say hello to the world")
+task = Task(name="say hello", goal=["say hello"], description="say hello to the world")
 
 
 class Hello(Action):

{fabricatio-0.2.1.dev2 → fabricatio-0.2.1.dev4}/examples/propose_task/propose.py

@@ -5,7 +5,7 @@ from typing import Any
 
 from fabricatio import Action, Role, Task, WorkFlow, logger
 
-task = Task(name="say hello", goal="say hello", description="say hello to the world")
+task = Task(name="say hello", goal=["say hello"], description="say hello to the world")
 
 
 class Talk(Action):

{fabricatio-0.2.1.dev2 → fabricatio-0.2.1.dev4}/examples/simple_chat/chat.py

@@ -5,7 +5,7 @@ from typing import Any
 
 from fabricatio import Action, Role, Task, WorkFlow, logger
 
-task = Task(name="say hello", goal="say hello", description="say hello to the world")
+task = Task(name="say hello", goal=["say hello"], description="say hello to the world")
 
 
 class Talk(Action):

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

@@ -1,6 +1,6 @@
 [project]
 name = "fabricatio"
-version = "0.2.1-dev2"
+version = "0.2.1-dev4"
 description = "A LLM multi-agent framework."
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -34,6 +34,7 @@ dependencies = [
     "litellm>=1.60.0",
     "loguru>=0.7.3",
     "magika>=0.5.1",
+    "more-itertools>=10.6.0",
     "orjson>=3.10.15",
     "pydantic>=2.10.6",
     "pydantic-settings>=2.7.1",
@@ -76,7 +77,6 @@ dev = [
 
 [project.optional-dependencies]
 rag = [
-    "faiss-cpu>=1.10.0",
     "pymilvus>=2.5.4",
 ]
 

fabricatio-0.2.1.dev4/python/fabricatio/capabilities/rating.py

@@ -0,0 +1,277 @@
+"""A module that provides functionality to rate tasks based on a rating manual and score range."""
+
+from asyncio import gather
+from itertools import permutations
+from typing import Dict, List, Set, Tuple, Union, Unpack, overload
+
+import orjson
+from fabricatio._rust_instances import template_manager
+from fabricatio.config import configs
+from fabricatio.journal import logger
+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 pydantic import NonNegativeInt, PositiveInt
+
+
+class GiveRating(WithBriefing, LLMUsage):
+    """A class that provides functionality to rate tasks based on a rating manual and score range."""
+
+    async def rate_fine_grind(
+        self,
+        to_rate: str,
+        rating_manual: Dict[str, str],
+        score_range: Tuple[float, float],
+        **kwargs: Unpack[ValidateKwargs],
+    ) -> Dict[str, float]:
+        """Rate a given string based on a rating manual and score range.
+
+        Args:
+            to_rate (str): The string to be rated.
+            rating_manual (Dict[str, str]): A dictionary containing the rating criteria.
+            score_range (Tuple[float, float]): A tuple representing the valid score range.
+            **kwargs (Unpack[ValidateKwargs]): Additional keyword arguments for the LLM usage.
+
+        Returns:
+            Dict[str, float]: A dictionary with the ratings for each dimension.
+        """
+
+        def _validator(response: str) -> Dict[str, float] | None:
+            if (
+                (json_data := JsonCapture.convert_with(response, orjson.loads)) is not None
+                and isinstance(json_data, dict)
+                and json_data.keys() == rating_manual.keys()
+                and all(isinstance(v, float) for v in json_data.values())
+                and all(score_range[0] <= v <= score_range[1] for v in json_data.values())
+            ):
+                return json_data
+            return None
+
+        logger.info(f"Rating for {to_rate}")
+        return await self.aask_validate(
+            question=(
+                template_manager.render_template(
+                    configs.templates.rate_fine_grind_template,
+                    {
+                        "to_rate": to_rate,
+                        "min_score": score_range[0],
+                        "max_score": score_range[1],
+                        "rating_manual": rating_manual,
+                    },
+                )
+            ),
+            validator=_validator,
+            system_message=f"# your personal briefing: \n{self.briefing}",
+            **kwargs,
+        )
+
+    @overload
+    async def rate(
+        self,
+        to_rate: str,
+        topic: str,
+        criteria: Set[str],
+        score_range: Tuple[float, float] = (0.0, 1.0),
+        **kwargs: Unpack[ValidateKwargs],
+    ) -> Dict[str, float]: ...
+
+    @overload
+    async def rate(
+        self,
+        to_rate: List[str],
+        topic: str,
+        criteria: Set[str],
+        score_range: Tuple[float, float] = (0.0, 1.0),
+        **kwargs: Unpack[ValidateKwargs],
+    ) -> List[Dict[str, float]]: ...
+
+    async def rate(
+        self,
+        to_rate: Union[str, List[str]],
+        topic: str,
+        criteria: Set[str],
+        score_range: Tuple[float, float] = (0.0, 1.0),
+        **kwargs: Unpack[ValidateKwargs],
+    ) -> Union[Dict[str, float], List[Dict[str, float]]]:
+        """Rate a given string or a sequence of strings based on a topic, criteria, and score range.
+
+        Args:
+            to_rate (Union[str, List[str]]): The string or sequence of strings to be rated.
+            topic (str): The topic related to the task.
+            criteria (Set[str]): A set of criteria for rating.
+            score_range (Tuple[float, float], optional): A tuple representing the valid score range. Defaults to (0.0, 1.0).
+            **kwargs (Unpack[ValidateKwargs]): Additional keyword arguments for the LLM usage.
+
+        Returns:
+            Union[Dict[str, float], List[Dict[str, float]]]: A dictionary with the ratings for each criterion if a single string is provided,
+            or a list of dictionaries with the ratings for each criterion if a sequence of strings is provided.
+        """
+        manual = await self.draft_rating_manual(topic, criteria, **kwargs)
+        if isinstance(to_rate, str):
+            return await self.rate_fine_grind(to_rate, manual, score_range, **kwargs)
+        if isinstance(to_rate, list):
+            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")
+
+    async def draft_rating_manual(
+        self, topic: str, criteria: Set[str], **kwargs: Unpack[ValidateKwargs]
+    ) -> Dict[str, str]:
+        """Drafts a rating manual based on a topic and dimensions.
+
+        Args:
+            topic (str): The topic for the rating manual.
+            criteria (Set[str]): A set of dimensions for the rating manual.
+            **kwargs (Unpack[ValidateKwargs]): Additional keyword arguments for the LLM usage.
+
+        Returns:
+            Dict[str, str]: A dictionary representing the drafted rating manual.
+        """
+
+        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)
+                and json_data.keys() == criteria
+                and all(isinstance(v, str) for v in json_data.values())
+            ):
+                return json_data
+            return None
+
+        return await self.aask_validate(
+            question=(
+                template_manager.render_template(
+                    configs.templates.draft_rating_manual_template,
+                    {
+                        "topic": topic,
+                        "criteria": criteria,
+                    },
+                )
+            ),
+            validator=_validator,
+            system_message=f"# your personal briefing: \n{self.briefing}",
+            **kwargs,
+        )
+
+    async def draft_rating_criteria(
+        self,
+        topic: str,
+        criteria_count: NonNegativeInt = 0,
+        **kwargs: Unpack[ValidateKwargs],
+    ) -> Set[str]:
+        """Drafts rating dimensions based on a topic.
+
+        Args:
+            topic (str): The topic for the rating dimensions.
+            criteria_count (NonNegativeInt, optional): The number of dimensions to draft, 0 means no limit. Defaults to 0.
+            **kwargs (Unpack[ValidateKwargs]): Additional keyword arguments for the LLM usage.
+
+        Returns:
+            Set[str]: A set of rating dimensions.
+        """
+
+        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)
+            ):
+                return set(json_data)
+            return None
+
+        return await self.aask_validate(
+            question=(
+                template_manager.render_template(
+                    configs.templates.draft_rating_criteria_template,
+                    {
+                        "topic": topic,
+                        "criteria_count": criteria_count,
+                    },
+                )
+            ),
+            validator=_validator,
+            system_message=f"# your personal briefing: \n{self.briefing}",
+            **kwargs,
+        )
+
+    async def draft_rating_criteria_from_examples(
+        self,
+        topic: str,
+        examples: List[str],
+        reasons_count: PositiveInt = 2,
+        criteria_count: PositiveInt = 5,
+        **kwargs: Unpack[ValidateKwargs],
+    ) -> Set[str]:
+        """Asynchronously drafts a set of rating criteria based on provided examples.
+
+        This function generates rating criteria by analyzing examples and extracting reasons for comparison,
+        then further condensing these reasons into a specified number of criteria.
+
+        Parameters:
+            topic (str): The subject topic for the rating criteria.
+            examples (List[str]): A list of example texts to analyze.
+            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.
+        """
+
+        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(
+            await self.aask_validate_batch(
+                questions=[
+                    template_manager.render_template(
+                        configs.templates.extract_reasons_from_examples_template,
+                        {
+                            "topic": topic,
+                            "first": pair[0],
+                            "second": pair[1],
+                            "reasons_count": reasons_count,
+                        },
+                    )
+                    for pair in (permutations(examples, 2))
+                ],
+                validator=_reasons_validator,
+                **kwargs,
+            )
+        )
+        # extract certain mount of criteria from reasons according to their importance and frequency
+        return await self.aask_validate(
+            question=(
+                template_manager.render_template(
+                    configs.templates.extract_criteria_from_reasons_template,
+                    {
+                        "topic": topic,
+                        "reasons": list(reasons),
+                        "criteria_count": criteria_count,
+                    },
+                )
+            ),
+            validator=_criteria_validator,
+            **kwargs,
+        )

fabricatio-0.2.1.dev2/python/fabricatio/models/advanced.py → fabricatio-0.2.1.dev4/python/fabricatio/capabilities/task.py

@@ -1,7 +1,7 @@
-"""A module for advanced models and functionalities."""
+"""A module for the task capabilities of the Fabricatio library."""
 
 from types import CodeType
-from typing import Any, Dict, List, Optional, Set, Tuple, Unpack
+from typing import Any, Dict, List, Optional, Tuple, Unpack
 
 import orjson
 from fabricatio._rust_instances import template_manager
@@ -129,116 +129,3 @@ class HandleTask(WithBriefing, ToolBoxUsage):
     async def handle(self, task: Task, data: Dict[str, Any], **kwargs: Unpack[ValidateKwargs]) -> Optional[Tuple]:
         """Asynchronously handles a task based on a given task object and parameters."""
         return await self.handle_fin_grind(task, data, **kwargs)
-
-
-class GiveRating(WithBriefing, LLMUsage):
-    """A class that provides functionality to rate tasks based on a rating manual and score range."""
-
-    async def rate_fine_grind(
-        self,
-        to_rate: str,
-        rating_manual: Dict[str, str],
-        score_range: Tuple[float, float],
-        **kwargs: Unpack[ValidateKwargs],
-    ) -> Dict[str, float]:
-        """Rates a given task based on a rating manual and score range.
-
-        Args:
-            to_rate: The task to be rated.
-            rating_manual: A dictionary containing the rating criteria.
-            score_range: A tuple representing the valid score range.
-            **kwargs: Additional keyword arguments for the LLM usage.
-
-        Returns:
-            A dictionary with the ratings for each dimension.
-        """
-
-        def _validator(response: str) -> Dict[str, float] | None:
-            if (
-                (json_data := JsonCapture.convert_with(response, orjson.loads)) is not None
-                and isinstance(json_data, dict)
-                and json_data.keys() == rating_manual.keys()
-                and all(isinstance(v, float) for v in json_data.values())
-                and all(score_range[0] <= v <= score_range[1] for v in json_data.values())
-            ):
-                return json_data
-            return None
-
-        return await self.aask_validate(
-            question=(
-                template_manager.render_template(
-                    configs.templates.rate_fine_grind_template,
-                    {
-                        "to_rate": to_rate,
-                        "min_score": score_range[0],
-                        "max_score": score_range[1],
-                        "rating_manual": rating_manual,
-                    },
-                )
-            ),
-            validator=_validator,
-            system_message=f"# your personal briefing: \n{self.briefing}",
-            **kwargs,
-        )
-
-    async def rate(
-        self,
-        to_rate: str,
-        topic: str,
-        dimensions: Set[str],
-        score_range: Tuple[float, float] = (0.0, 1.0),
-        **kwargs: Unpack[ValidateKwargs],
-    ) -> Dict[str, float]:
-        """Rates a task based on a topic and dimensions. this function will automatically draft a rating manual based on the topic and dimensions.
-
-        Args:
-            to_rate: The task to be rated.
-            topic: The topic related to the task.
-            dimensions: A set of dimensions for rating.
-            score_range: A tuple representing the valid score range
-            **kwargs: Additional keyword arguments for the LLM usage.
-
-        Returns:
-            A dictionary with the ratings for each dimension.
-        """
-        manual = await self.draft_rating_manual(topic, dimensions, **kwargs)
-        return await self.rate_fine_grind(to_rate, manual, score_range, **kwargs)
-
-    async def draft_rating_manual(
-        self, topic: str, dimensions: Set[str], **kwargs: Unpack[ValidateKwargs]
-    ) -> Dict[str, str]:
-        """Drafts a rating manual based on a topic and dimensions.
-
-        Args:
-            topic: The topic for the rating manual.
-            dimensions: A set of dimensions for the rating manual.
-            **kwargs: Additional keyword arguments for the LLM usage.
-
-        Returns:
-            A dictionary representing the drafted rating manual.
-        """
-
-        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)
-                and json_data.keys() == dimensions
-                and all(isinstance(v, str) for v in json_data.values())
-            ):
-                return json_data
-            return None
-
-        return await self.aask_validate(
-            question=(
-                template_manager.render_template(
-                    configs.templates.draft_rating_manual_template,
-                    {
-                        "topic": topic,
-                        "dimensions": dimensions,
-                    },
-                )
-            ),
-            validator=_validator,
-            system_message=f"# your personal briefing: \n{self.briefing}",
-            **kwargs,
-        )

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

@@ -163,6 +163,15 @@ class TemplateConfig(BaseModel):
     draft_rating_manual_template: str = Field(default="draft_rating_manual")
     """The name of the draft rating manual template which will be used to draft rating manual."""
 
+    draft_rating_criteria_template: str = Field(default="draft_rating_criteria")
+    """The name of the draft rating criteria template which will be used to draft rating criteria."""
+
+    extract_reasons_from_examples_template: str = Field(default="extract_reasons_from_examples")
+    """The name of the extract reasons from examples template which will be used to extract reasons from examples."""
+
+    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."""
+
 
 class MagikaConfig(BaseModel):
     """Magika configuration class."""

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

@@ -5,15 +5,16 @@ from abc import abstractmethod
 from asyncio import Queue
 from typing import Any, Dict, Self, Tuple, Type, Union, Unpack
 
+from fabricatio.capabilities.rating import GiveRating
+from fabricatio.capabilities.task import HandleTask, ProposeTask
 from fabricatio.journal import logger
-from fabricatio.models.advanced import HandleTask, ProposeTask
 from fabricatio.models.generic import WithBriefing
 from fabricatio.models.task import Task
 from fabricatio.models.usages import ToolBoxUsage
 from pydantic import Field, PrivateAttr
 
 
-class Action(HandleTask, ProposeTask):
+class Action(HandleTask, ProposeTask, GiveRating):
     """Class that represents an action to be executed in a workflow."""
 
     personality: str = Field(default="")

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

@@ -24,8 +24,13 @@ class ValidateKwargs(LLMKwargs):
     max_validations: NotRequired[PositiveInt]
 
 
-class ChooseKwargs(ValidateKwargs):
-    """A type representing the keyword arguments for the choose method."""
+class GenerateKwargs(ValidateKwargs):
+    """A type representing the keyword arguments for the generate method."""
 
     system_message: NotRequired[str]
+
+
+class ChooseKwargs(GenerateKwargs):
+    """A type representing the keyword arguments for the choose method."""
+
     k: NotRequired[NonNegativeInt]

{fabricatio-0.2.1.dev2 → fabricatio-0.2.1.dev4}/python/fabricatio/models/role.py

@@ -2,17 +2,17 @@
 
 from typing import Any, Self, Set
 
+from fabricatio.capabilities.rating import GiveRating
+from fabricatio.capabilities.task import HandleTask, ProposeTask
 from fabricatio.core import env
 from fabricatio.journal import logger
 from fabricatio.models.action import WorkFlow
-from fabricatio.models.advanced import ProposeTask
 from fabricatio.models.events import Event
 from fabricatio.models.tool import ToolBox
-from fabricatio.models.usages import ToolBoxUsage
 from pydantic import Field
 
 
-class Role(ProposeTask, ToolBoxUsage):
+class Role(ProposeTask, HandleTask, GiveRating):
     """Class that represents a role with a registry of events and workflows."""
 
     registry: dict[Event | str, WorkFlow] = Field(...)