fabricatio 0.3.14.dev1__cp312-cp312-win_amd64.whl → 0.3.14.dev4__cp312-cp312-win_amd64.whl

fabricatio/capabilities/rating.py

@@ -1,10 +1,10 @@
 """A module that provides functionality to rate tasks based on a rating manual and score range."""
 
+from abc import ABC
 from itertools import permutations
 from random import sample
 from typing import Dict, List, Optional, Set, Tuple, Union, Unpack, overload
 
-from fabricatio.rust import CONFIG, TEMPLATE_MANAGER
 from more_itertools import flatten, windowed
 from pydantic import Field, NonNegativeInt, PositiveInt, create_model
 
@@ -13,10 +13,11 @@ from fabricatio.journal import logger
 from fabricatio.models.generic import Display, ProposedAble
 from fabricatio.models.kwargs_types import CompositeScoreKwargs, ValidateKwargs
 from fabricatio.parser import JsonCapture
+from fabricatio.rust import CONFIG, TEMPLATE_MANAGER
 from fabricatio.utils import ok, override_kwargs
 
 
-class Rating(Propose):
+class Rating(Propose, ABC):
     """A class that provides functionality to rate tasks based on a rating manual and score range.
 
     References:
@@ -24,11 +25,11 @@ class Rating(Propose):
     """
 
     async def rate_fine_grind(
-            self,
-            to_rate: str | List[str],
-            rating_manual: Dict[str, str],
-            score_range: Tuple[float, float],
-            **kwargs: Unpack[ValidateKwargs[Dict[str, float]]],
+        self,
+        to_rate: str | List[str],
+        rating_manual: Dict[str, str],
+        score_range: Tuple[float, float],
+        **kwargs: Unpack[ValidateKwargs[Dict[str, float]]],
     ) -> Dict[str, float] | List[Dict[str, float]] | List[Optional[Dict[str, float]]] | None:
         """Rate a given string based on a rating manual and score range.
 
@@ -87,36 +88,34 @@ class Rating(Propose):
 
     @overload
     async def rate(
-            self,
-            to_rate: str,
-            topic: str,
-            criteria: Set[str],
-            manual: Optional[Dict[str, str]] = None,
-            score_range: Tuple[float, float] = (0.0, 1.0),
-            **kwargs: Unpack[ValidateKwargs],
-    ) -> Dict[str, float]:
-        ...
+        self,
+        to_rate: str,
+        topic: str,
+        criteria: Set[str],
+        manual: Optional[Dict[str, str]] = None,
+        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],
-            manual: Optional[Dict[str, str]] = None,
-            score_range: Tuple[float, float] = (0.0, 1.0),
-            **kwargs: Unpack[ValidateKwargs],
-    ) -> List[Dict[str, float]]:
-        ...
+        self,
+        to_rate: List[str],
+        topic: str,
+        criteria: Set[str],
+        manual: Optional[Dict[str, str]] = None,
+        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],
-            manual: Optional[Dict[str, str]] = None,
-            score_range: Tuple[float, float] = (0.0, 1.0),
-            **kwargs: Unpack[ValidateKwargs],
+        self,
+        to_rate: Union[str, List[str]],
+        topic: str,
+        criteria: Set[str],
+        manual: Optional[Dict[str, str]] = None,
+        score_range: Tuple[float, float] = (0.0, 1.0),
+        **kwargs: Unpack[ValidateKwargs],
     ) -> Dict[str, float] | List[Dict[str, float]] | List[Optional[Dict[str, float]]] | None:
         """Rate a given string or a sequence of strings based on a topic, criteria, and score range.
 
@@ -133,15 +132,15 @@ class Rating(Propose):
             or a list of dictionaries with the ratings for each criterion if a sequence of strings is provided.
         """
         manual = (
-                manual
-                or await self.draft_rating_manual(topic, criteria, **override_kwargs(kwargs, default=None))
-                or dict(zip(criteria, criteria, strict=True))
+            manual
+            or await self.draft_rating_manual(topic, criteria, **override_kwargs(kwargs, default=None))
+            or dict(zip(criteria, criteria, strict=True))
         )
 
         return await self.rate_fine_grind(to_rate, manual, score_range, **kwargs)
 
     async def draft_rating_manual(
-            self, topic: str, criteria: Optional[Set[str]] = None, **kwargs: Unpack[ValidateKwargs[Dict[str, str]]]
+        self, topic: str, criteria: Optional[Set[str]] = None, **kwargs: Unpack[ValidateKwargs[Dict[str, str]]]
     ) -> Optional[Dict[str, str]]:
         """Drafts a rating manual based on a topic and dimensions.
 
@@ -156,9 +155,9 @@ class Rating(Propose):
 
         def _validator(response: str) -> Dict[str, str] | None:
             if (
-                    (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())
+                (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())
             ):
                 return json_data
             return None
@@ -184,10 +183,10 @@ class Rating(Propose):
         )
 
     async def draft_rating_criteria(
-            self,
-            topic: str,
-            criteria_count: NonNegativeInt = 0,
-            **kwargs: Unpack[ValidateKwargs[Set[str]]],
+        self,
+        topic: str,
+        criteria_count: NonNegativeInt = 0,
+        **kwargs: Unpack[ValidateKwargs[Set[str]]],
     ) -> Optional[Set[str]]:
         """Drafts rating dimensions based on a topic.
 
@@ -216,13 +215,13 @@ class Rating(Propose):
         )
 
     async def draft_rating_criteria_from_examples(
-            self,
-            topic: str,
-            examples: List[str],
-            m: NonNegativeInt = 0,
-            reasons_count: PositiveInt = 2,
-            criteria_count: PositiveInt = 5,
-            **kwargs: Unpack[ValidateKwargs],
+        self,
+        topic: str,
+        examples: List[str],
+        m: NonNegativeInt = 0,
+        reasons_count: PositiveInt = 2,
+        criteria_count: PositiveInt = 5,
+        **kwargs: Unpack[ValidateKwargs],
     ) -> Optional[Set[str]]:
         """Asynchronously drafts a set of rating criteria based on provided examples.
 
@@ -287,10 +286,10 @@ class Rating(Propose):
         )
 
     async def drafting_rating_weights_klee(
-            self,
-            topic: str,
-            criteria: Set[str],
-            **kwargs: Unpack[ValidateKwargs[float]],
+        self,
+        topic: str,
+        criteria: Set[str],
+        **kwargs: Unpack[ValidateKwargs[float]],
     ) -> Dict[str, float]:
         """Drafts rating weights for a given topic and criteria using the Klee method.
 
@@ -333,14 +332,14 @@ class Rating(Propose):
         return dict(zip(criteria_seq, [w / total for w in weights], strict=True))
 
     async def composite_score(
-            self,
-            topic: str,
-            to_rate: List[str],
-            criteria: Optional[Set[str]] = None,
-            weights: Optional[Dict[str, float]] = None,
-            manual: Optional[Dict[str, str]] = None,
-            approx: bool = False,
-            **kwargs: Unpack[ValidateKwargs[List[Dict[str, float]]]],
+        self,
+        topic: str,
+        to_rate: List[str],
+        criteria: Optional[Set[str]] = None,
+        weights: Optional[Dict[str, float]] = None,
+        manual: Optional[Dict[str, str]] = None,
+        approx: bool = False,
+        **kwargs: Unpack[ValidateKwargs[List[Dict[str, float]]]],
     ) -> List[float]:
         """Calculates the composite scores for a list of items based on a given topic and criteria.
 
@@ -370,17 +369,15 @@ class Rating(Propose):
         return [sum(ratings[c] * weights[c] for c in criteria) for ratings in ratings_seq]
 
     @overload
-    async def best(self, candidates: List[str], k: int = 1, **kwargs: Unpack[CompositeScoreKwargs]) -> List[str]:
-        ...
+    async def best(self, candidates: List[str], k: int = 1, **kwargs: Unpack[CompositeScoreKwargs]) -> List[str]: ...
 
     @overload
     async def best[T: Display](
-            self, candidates: List[T], k: int = 1, **kwargs: Unpack[CompositeScoreKwargs]
-    ) -> List[T]:
-        ...
+        self, candidates: List[T], k: int = 1, **kwargs: Unpack[CompositeScoreKwargs]
+    ) -> List[T]: ...
 
     async def best[T: Display](
-            self, candidates: List[str] | List[T], k: int = 1, **kwargs: Unpack[CompositeScoreKwargs]
+        self, candidates: List[str] | List[T], k: int = 1, **kwargs: Unpack[CompositeScoreKwargs]
     ) -> Optional[List[str] | List[T]]:
         """Choose the best candidates from the list of candidates based on the composite score.
 
@@ -404,5 +401,4 @@ class Rating(Propose):
         rating_seq = await self.composite_score(
             to_rate=[c.display() if isinstance(c, Display) else c for c in candidates], **kwargs
         )
-        return [a[0] for a in sorted(zip(candidates, rating_seq, strict=True), key=lambda x: x[1], reverse=True)[
-                              :k]]  # pyright: ignore [reportReturnType]
+        return [a[0] for a in sorted(zip(candidates, rating_seq, strict=True), key=lambda x: x[1], reverse=True)[:k]]  # pyright: ignore [reportReturnType]

fabricatio/capabilities/review.py

@@ -1,19 +1,19 @@
 """A module that provides functionality to rate tasks based on a rating manual and score range."""
 
+from abc import ABC
 from typing import Dict, Optional, Set, Unpack
 
-from fabricatio.rust import CONFIG, TEMPLATE_MANAGER
-
 from fabricatio.capabilities.propose import Propose
 from fabricatio.capabilities.rating import Rating
 from fabricatio.models.extra.problem import Improvement
 from fabricatio.models.generic import Display, WithBriefing
 from fabricatio.models.kwargs_types import ReviewKwargs, ValidateKwargs
 from fabricatio.models.task import Task
+from fabricatio.rust import CONFIG, TEMPLATE_MANAGER
 from fabricatio.utils import ok
 
 
-class Review(Rating, Propose):
+class Review(Rating, Propose, ABC):
     """Class that provides functionality to review tasks and strings using a language model.
 
     This class extends GiveRating and Propose capabilities to analyze content,
@@ -41,12 +41,12 @@ class Review(Rating, Propose):
         return await self.review_obj(task, **kwargs)
 
     async def review_string(
-            self,
-            input_text: str,
-            topic: str,
-            criteria: Optional[Set[str]] = None,
-            rating_manual: Optional[Dict[str, str]] = None,
-            **kwargs: Unpack[ValidateKwargs[Improvement]],
+        self,
+        input_text: str,
+        topic: str,
+        criteria: Optional[Set[str]] = None,
+        rating_manual: Optional[Dict[str, str]] = None,
+        **kwargs: Unpack[ValidateKwargs[Improvement]],
     ) -> Optional[Improvement]:
         """Review a string based on specified topic and criteria.
 
@@ -84,8 +84,9 @@ class Review(Rating, Propose):
             **kwargs,
         )
 
-    async def review_obj[M: (Display, WithBriefing)](self, obj: M, **kwargs: Unpack[ReviewKwargs[Improvement]]) -> \
-            Optional[Improvement]:
+    async def review_obj[M: (Display, WithBriefing)](
+        self, obj: M, **kwargs: Unpack[ReviewKwargs[Improvement]]
+    ) -> Optional[Improvement]:
         """Review an object that implements Display or WithBriefing interface.
 
         This method extracts displayable text from the object and performs a review

fabricatio/capabilities/task.py

@@ -1,10 +1,10 @@
 """A module for the task capabilities of the Fabricatio library."""
 
+from abc import ABC
 from types import CodeType
 from typing import Any, Dict, List, Optional, Tuple, Unpack
 
 import ujson
-from fabricatio.rust import CONFIG, TEMPLATE_MANAGER
 
 from fabricatio.capabilities.propose import Propose
 from fabricatio.journal import logger
@@ -13,15 +13,16 @@ from fabricatio.models.task import Task
 from fabricatio.models.tool import Tool, ToolExecutor
 from fabricatio.models.usages import ToolBoxUsage
 from fabricatio.parser import JsonCapture, PythonCapture
+from fabricatio.rust import CONFIG, TEMPLATE_MANAGER
 
 
-class ProposeTask(Propose):
+class ProposeTask(Propose, ABC):
     """A class that proposes a task based on a prompt."""
 
     async def propose_task[T](
-            self,
-            prompt: str,
-            **kwargs: Unpack[ValidateKwargs[Task[T]]],
+        self,
+        prompt: str,
+        **kwargs: Unpack[ValidateKwargs[Task[T]]],
     ) -> Optional[Task[T]]:
         """Asynchronously proposes a task based on a given prompt and parameters.
 
@@ -39,15 +40,15 @@ class ProposeTask(Propose):
         return await self.propose(Task, prompt, **kwargs)
 
 
-class HandleTask(ToolBoxUsage):
+class HandleTask(ToolBoxUsage,ABC):
     """A class that handles a task based on a task object."""
 
     async def draft_tool_usage_code(
-            self,
-            task: Task,
-            tools: List[Tool],
-            data: Dict[str, Any],
-            **kwargs: Unpack[ValidateKwargs],
+        self,
+        task: Task,
+        tools: List[Tool],
+        data: Dict[str, Any],
+        **kwargs: Unpack[ValidateKwargs],
     ) -> Optional[Tuple[CodeType, List[str]]]:
         """Asynchronously drafts the tool usage code for a task based on a given task object and tools."""
         logger.info(f"Drafting tool usage code for task: {task.briefing}")
@@ -59,7 +60,7 @@ class HandleTask(ToolBoxUsage):
 
         def _validator(response: str) -> Tuple[CodeType, List[str]] | None:
             if (source := PythonCapture.convert_with(response, lambda resp: compile(resp, "<string>", "exec"))) and (
-                    to_extract := JsonCapture.convert_with(response, ujson.loads)
+                to_extract := JsonCapture.convert_with(response, ujson.loads)
             ):
                 return source, to_extract
 
@@ -84,12 +85,12 @@ class HandleTask(ToolBoxUsage):
         )
 
     async def handle_fine_grind(
-            self,
-            task: Task,
-            data: Dict[str, Any],
-            box_choose_kwargs: Optional[ChooseKwargs] = None,
-            tool_choose_kwargs: Optional[ChooseKwargs] = None,
-            **kwargs: Unpack[ValidateKwargs],
+        self,
+        task: Task,
+        data: Dict[str, Any],
+        box_choose_kwargs: Optional[ChooseKwargs] = None,
+        tool_choose_kwargs: Optional[ChooseKwargs] = None,
+        **kwargs: Unpack[ValidateKwargs],
     ) -> Optional[Tuple]:
         """Asynchronously handles a task based on a given task object and parameters."""
         logger.info(f"Handling task: \n{task.briefing}")

fabricatio/decorators.py

@@ -8,9 +8,8 @@ from shutil import which
 from types import ModuleType
 from typing import Callable, Coroutine, List, Optional
 
-from fabricatio.rust import CONFIG
-
 from fabricatio.journal import logger
+from fabricatio.rust import CONFIG
 
 
 def precheck_package[**P, R](package_name: str, msg: str) -> Callable[[Callable[P, R]], Callable[P, R]]:
@@ -25,7 +24,7 @@ def precheck_package[**P, R](package_name: str, msg: str) -> Callable[[Callable[
     """
 
     def _wrapper(
-            func: Callable[P, R] | Callable[P, Coroutine[None, None, R]],
+        func: Callable[P, R] | Callable[P, Coroutine[None, None, R]],
     ) -> Callable[P, R] | Callable[P, Coroutine[None, None, R]]:
         if iscoroutinefunction(func):
 
@@ -49,7 +48,7 @@ def precheck_package[**P, R](package_name: str, msg: str) -> Callable[[Callable[
 
 
 def depend_on_external_cmd[**P, R](
-        bin_name: str, install_tip: Optional[str], homepage: Optional[str] = None
+    bin_name: str, install_tip: Optional[str], homepage: Optional[str] = None
 ) -> Callable[[Callable[P, R]], Callable[P, R]]:
     """Decorator to check for the presence of an external command.
 
@@ -124,8 +123,8 @@ def confirm_to_execute[**P, R](func: Callable[P, R]) -> Callable[P, Optional[R]]
         @wraps(func)
         async def _wrapper(*args: P.args, **kwargs: P.kwargs) -> Optional[R]:
             if await confirm(
-                    f"Are you sure to execute function: {func.__name__}{signature(func)} \n📦 Args:{args}\n🔑 Kwargs:{kwargs}\n",
-                    instruction="Please input [Yes/No] to proceed (default: Yes):",
+                f"Are you sure to execute function: {func.__name__}{signature(func)} \n📦 Args:{args}\n🔑 Kwargs:{kwargs}\n",
+                instruction="Please input [Yes/No] to proceed (default: Yes):",
             ).ask_async():
                 return await func(*args, **kwargs)
             logger.warning(f"Function: {func.__name__}{signature(func)} canceled by user.")
@@ -136,8 +135,8 @@ def confirm_to_execute[**P, R](func: Callable[P, R]) -> Callable[P, Optional[R]]
         @wraps(func)
         def _wrapper(*args: P.args, **kwargs: P.kwargs) -> Optional[R]:
             if confirm(
-                    f"Are you sure to execute function: {func.__name__}{signature(func)} \n📦 Args:{args}\n��� Kwargs:{kwargs}\n",
-                    instruction="Please input [Yes/No] to proceed (default: Yes):",
+                f"Are you sure to execute function: {func.__name__}{signature(func)} \n📦 Args:{args}\n��� Kwargs:{kwargs}\n",
+                instruction="Please input [Yes/No] to proceed (default: Yes):",
             ).ask():
                 return func(*args, **kwargs)
             logger.warning(f"Function: {func.__name__}{signature(func)} canceled by user.")
@@ -219,7 +218,7 @@ def use_temp_module[**P, R](modules: ModuleType | List[ModuleType]) -> Callable[
 
 
 def logging_exec_time[**P, R](
-        func: Callable[P, R] | Callable[P, Coroutine[None, None, R]],
+    func: Callable[P, R] | Callable[P, Coroutine[None, None, R]],
 ) -> Callable[P, R] | Callable[P, Coroutine[None, None, R]]:
     """Decorator to log the execution time of a function.
 
@@ -232,6 +231,7 @@ def logging_exec_time[**P, R](
     from time import time
 
     if iscoroutinefunction(func):
+
         @wraps(func)
         async def _async_wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
             start_time = time()

fabricatio/{core.py → emitter.py}

@@ -1,23 +1,21 @@
 """Core module that contains the Env class for managing event handling."""
+from dataclasses import dataclass
+from typing import Callable, ClassVar, Optional, Self, overload
 
-from typing import Callable, Optional, Self, overload
+from pymitter import EventEmitter
 
 from fabricatio.rust import CONFIG, Event
-from pydantic import BaseModel, ConfigDict, PrivateAttr
-from pymitter import EventEmitter
 
 
-class Env(BaseModel):
+@dataclass
+class Env:
     """Environment class that manages event handling using EventEmitter."""
 
-    model_config = ConfigDict(use_attribute_docstrings=True)
-    _ee: EventEmitter = PrivateAttr(
-        default_factory=lambda: EventEmitter(
-            delimiter=CONFIG.pymitter.delimiter,
-            new_listener=CONFIG.pymitter.new_listener_event,
-            max_listeners=CONFIG.pymitter.max_listeners,
-            wildcard=True,
-        )
+    ee: ClassVar[EventEmitter] = EventEmitter(
+        delimiter=CONFIG.pymitter.delimiter,
+        new_listener=CONFIG.pymitter.new_listener_event,
+        max_listeners=CONFIG.pymitter.max_listeners,
+        wildcard=True,
     )
 
     @overload
@@ -75,8 +73,8 @@ class Env(BaseModel):
         if isinstance(event, Event):
             event = event.collapse()
         if func is None:
-            return self._ee.on(event, ttl=ttl)
-        self._ee.on(event, func, ttl=ttl)
+            return self.ee.on(event, ttl=ttl)
+        self.ee.on(event, func, ttl=ttl)
         return self
 
     @overload
@@ -130,9 +128,9 @@ class Env(BaseModel):
         if isinstance(event, Event):
             event = event.collapse()
         if func is None:
-            return self._ee.once(event)
+            return self.ee.once(event)
 
-        self._ee.once(event, func)
+        self.ee.once(event, func)
         return self
 
     def emit[**P](self, event: str | Event, *args: P.args, **kwargs: P.kwargs) -> None:
@@ -146,7 +144,7 @@ class Env(BaseModel):
         if isinstance(event, Event):
             event = event.collapse()
 
-        self._ee.emit(event, *args, **kwargs)
+        self.ee.emit(event, *args, **kwargs)
 
     async def emit_async[**P](self, event: str | Event, *args: P.args, **kwargs: P.kwargs) -> None:
         """Asynchronously emits an event to all registered listeners.
@@ -158,7 +156,7 @@ class Env(BaseModel):
         """
         if isinstance(event, Event):
             event = event.collapse()
-        return await self._ee.emit_async(event, *args, **kwargs)
+        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.
@@ -173,7 +171,7 @@ class Env(BaseModel):
         """
         if isinstance(event, Event):
             event = event.collapse()
-        return self._ee.emit_future(event, *args, **kwargs)
+        return self.ee.emit_future(event, *args, **kwargs)
 
 
 env = Env()

fabricatio/journal.py

@@ -2,9 +2,10 @@
 
 import sys
 
-from fabricatio.rust import CONFIG
 from loguru import logger
 
+from fabricatio.rust import CONFIG
+
 logger.remove()
 logger.add(sys.stderr, level=CONFIG.debug.log_level)
 

fabricatio/models/action.py

@@ -14,12 +14,11 @@ from abc import abstractmethod
 from asyncio import Queue, create_task
 from typing import Any, ClassVar, Dict, Generator, Self, Sequence, Tuple, Type, Union, final
 
-from pydantic import Field, PrivateAttr
-
 from fabricatio.journal import logger
 from fabricatio.models.generic import WithBriefing
 from fabricatio.models.task import Task
 from fabricatio.utils import override_kwargs
+from pydantic import Field, PrivateAttr
 
 OUTPUT_KEY = "task_output"
 
@@ -99,9 +98,9 @@ class Action(WithBriefing):
             return f"## Your personality: \n{self.personality}\n# The action you are going to perform: \n{super().briefing}"
         return f"# The action you are going to perform: \n{super().briefing}"
 
-    def to_task_output(self, task_output_key: str = OUTPUT_KEY) -> Self:
+    def to_task_output(self, to: Union[str, "WorkFlow"] = OUTPUT_KEY) -> Self:
         """Set the output key to OUTPUT_KEY and return the action instance."""
-        self.output_key = task_output_key
+        self.output_key = to.task_output_key if isinstance(to, WorkFlow) else to
         return self
 
 
@@ -110,13 +109,10 @@ class WorkFlow(WithBriefing):
 
     Handles context propagation between actions, error handling, and task lifecycle
     events like cancellation and completion.
-
-    Attributes:
-        steps (Tuple): Sequence of Action instances or classes to execute.
-        task_input_key (str): Key for storing task instance in context.
-        task_output_key (str): Key to retrieve final result from context.
     """
 
+    name: str = "WorkFlow"
+    """The name of the workflow, which is used to identify and describe the workflow."""
     description: str = ""
     """The description of the workflow, which describes the workflow's purpose and requirements."""
 
@@ -129,10 +125,10 @@ class WorkFlow(WithBriefing):
     steps: Sequence[Union[Type[Action], Action]] = Field(frozen=True)
     """The sequence of actions to be executed, can be action classes or instances."""
 
-    task_input_key: str = Field(default=INPUT_KEY)
+    task_input_key: ClassVar[str] = INPUT_KEY
     """Key used to store the input task in the context dictionary."""
 
-    task_output_key: str = Field(default=OUTPUT_KEY)
+    task_output_key: ClassVar[str] = OUTPUT_KEY
     """Key used to extract the final result from the context dictionary."""
 
     extra_init_context: Dict[str, Any] = Field(default_factory=dict, frozen=True)
@@ -143,7 +139,9 @@ class WorkFlow(WithBriefing):
 
         Args:
             __context: The context to be used for initialization.
+
         """
+        self.name = self.name or self.__class__.__name__
         # Convert any action classes to instances
         self._instances = tuple(step if isinstance(step, Action) else step() for step in self.steps)