fabricatio 0.2.8.dev1__cp312-cp312-win_amd64.whl → 0.2.8.dev3__cp312-cp312-win_amd64.whl

fabricatio/capabilities/correct.py

@@ -8,8 +8,9 @@ based on predefined criteria and templates.
 from typing import Optional, Unpack, cast
 
 from fabricatio._rust_instances import TEMPLATE_MANAGER
-from fabricatio.capabilities.review import Review, ReviewResult
+from fabricatio.capabilities.review import Review
 from fabricatio.config import configs
+from fabricatio.models.extra.problem import Improvement
 from fabricatio.models.generic import CensoredAble, Display, ProposedAble, ProposedUpdateAble, WithBriefing
 from fabricatio.models.kwargs_types import CensoredCorrectKwargs, CorrectKwargs, ReviewKwargs
 from fabricatio.models.task import Task
@@ -31,7 +32,7 @@ class Correct(Review):
         obj: M,
         reference: str = "",
         supervisor_check: bool = True,
-        **kwargs: Unpack[ReviewKwargs[ReviewResult[str]]],
+        **kwargs: Unpack[ReviewKwargs[Improvement]],
     ) -> Optional[M]:
         """Review and correct an object based on defined criteria and templates.
 
@@ -71,7 +72,7 @@ class Correct(Review):
         )
 
     async def correct_string(
-        self, input_text: str, supervisor_check: bool = True, **kwargs: Unpack[ReviewKwargs[ReviewResult[str]]]
+        self, input_text: str, supervisor_check: bool = True, **kwargs: Unpack[ReviewKwargs[Improvement]]
     ) -> Optional[str]:
         """Review and correct a string based on defined criteria and templates.
 
@@ -100,7 +101,7 @@ class Correct(Review):
         )
 
     async def correct_task[T](
-        self, task: Task[T], **kwargs: Unpack[CorrectKwargs[ReviewResult[str]]]
+        self, task: Task[T], **kwargs: Unpack[CorrectKwargs[Improvement]]
     ) -> Optional[Task[T]]:
         """Review and correct a task object based on defined criteria.
 
@@ -117,7 +118,7 @@ class Correct(Review):
         return await self.correct_obj(task, **kwargs)
 
     async def censor_obj[M: CensoredAble](
-        self, obj: M, **kwargs: Unpack[CensoredCorrectKwargs[ReviewResult[str]]]
+        self, obj: M, **kwargs: Unpack[CensoredCorrectKwargs[Improvement]]
     ) -> M:
         """Censor and correct an object based on defined criteria and templates.
 
@@ -147,7 +148,7 @@ class Correct(Review):
         return modified_obj or last_modified_obj
 
     async def correct_obj_inplace[M: ProposedUpdateAble](
-        self, obj: M, **kwargs: Unpack[CorrectKwargs[ReviewResult[str]]]
+        self, obj: M, **kwargs: Unpack[CorrectKwargs[Improvement]]
     ) -> Optional[M]:
         """Correct an object in place based on defined criteria and templates.
 

fabricatio/capabilities/propose.py

@@ -10,28 +10,43 @@ from fabricatio.models.usages import LLMUsage
 class Propose(LLMUsage):
     """A class that proposes an Obj based on a prompt."""
 
+    @overload
+    async def propose[M: ProposedAble](
+        self,
+        cls: Type[M],
+        prompt: List[str],
+        **kwargs: Unpack[ValidateKwargs[None]],
+    ) -> List[Optional[M]]: ...
+
     @overload
     async def propose[M: ProposedAble](
         self,
         cls: Type[M],
         prompt: List[str],
         **kwargs: Unpack[ValidateKwargs[M]],
-    ) -> Optional[List[M]]: ...
+    ) -> List[M]: ...
 
     @overload
     async def propose[M: ProposedAble](
         self,
         cls: Type[M],
         prompt: str,
-        **kwargs: Unpack[ValidateKwargs[M]],
+        **kwargs: Unpack[ValidateKwargs[None]],
     ) -> Optional[M]: ...
+    @overload
+    async def propose[M: ProposedAble](
+        self,
+        cls: Type[M],
+        prompt: str,
+        **kwargs: Unpack[ValidateKwargs[M]],
+    ) -> M: ...
 
     async def propose[M: ProposedAble](
         self,
         cls: Type[M],
         prompt: List[str] | str,
-        **kwargs: Unpack[ValidateKwargs[M]],
-    ) -> Optional[List[M] | M]:
+        **kwargs: Unpack[ValidateKwargs[Optional[M]]],
+    ) -> Optional[M] | List[Optional[M]] | M | List[M]:
         """Asynchronously proposes a task based on a given prompt and parameters.
 
         Parameters:
@@ -47,3 +62,4 @@ class Propose(LLMUsage):
             validator=cls.instantiate_from_string,
             **kwargs,
         )
+

fabricatio/capabilities/rag.py

@@ -22,7 +22,8 @@ from fabricatio.models.kwargs_types import (
     RetrievalKwargs,
 )
 from fabricatio.models.usages import EmbeddingUsage
-from fabricatio.models.utils import MilvusData, ok
+from fabricatio.models.utils import MilvusData
+from fabricatio.utils import ok
 from more_itertools.recipes import flatten, unique
 from pydantic import Field, PrivateAttr
 
@@ -376,7 +377,7 @@ class RAG(EmbeddingUsage):
         Returns:
             List[str]: A list of refined questions.
         """
-        return await self.aliststr(
+        return await self.alist_str(
             TEMPLATE_MANAGER.render_template(
                 configs.templates.refined_query_template,
                 {"question": [question] if isinstance(question, str) else question},

fabricatio/capabilities/rating.py

@@ -7,16 +7,15 @@ from typing import Dict, List, Optional, Set, Tuple, Union, Unpack, overload
 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 ValidateKwargs
 from fabricatio.models.usages import LLMUsage
-from fabricatio.models.utils import override_kwargs
 from fabricatio.parser import JsonCapture
+from fabricatio.utils import override_kwargs
 from more_itertools import flatten, windowed
 from pydantic import NonNegativeInt, PositiveInt
 
 
-class Rating(WithBriefing, LLMUsage):
+class Rating(LLMUsage):
     """A class that provides functionality to rate tasks based on a rating manual and score range.
 
     References:
@@ -149,9 +148,7 @@ class Rating(WithBriefing, LLMUsage):
                 return json_data
             return None
 
-        criteria = criteria or await self.draft_rating_criteria(
-            topic, **self.prepend_sys_msg(override_kwargs(dict(kwargs), default=None))
-        )
+        criteria = criteria or await self.draft_rating_criteria(topic, **override_kwargs(dict(kwargs), default=None))
 
         if criteria is None:
             logger.error(f"Failed to draft rating criteria for topic {topic}")
@@ -168,7 +165,7 @@ class Rating(WithBriefing, LLMUsage):
                 )
             ),
             validator=_validator,
-            **self.prepend_sys_msg(kwargs),
+            **kwargs,
         )
 
     async def draft_rating_criteria(
@@ -200,7 +197,7 @@ class Rating(WithBriefing, LLMUsage):
             validator=lambda resp: set(out)
             if (out := JsonCapture.validate_with(resp, list, str, criteria_count)) is not None
             else out,
-            **self.prepend_sys_msg(kwargs),
+            **kwargs,
         )
 
     async def draft_rating_criteria_from_examples(
@@ -253,7 +250,7 @@ class Rating(WithBriefing, LLMUsage):
                 validator=lambda resp: JsonCapture.validate_with(
                     resp, target_type=list, elements_type=str, length=reasons_count
                 ),
-                **self.prepend_sys_msg(kwargs),
+                **kwargs,
             )
         )
         # extract certain mount of criteria from reasons according to their importance and frequency
@@ -310,7 +307,7 @@ class Rating(WithBriefing, LLMUsage):
                 for pair in windows
             ],
             validator=lambda resp: JsonCapture.validate_with(resp, target_type=float),
-            **self.prepend_sys_msg(kwargs),
+            **kwargs,
         )
         weights = [1]
         for rw in relative_weights:

fabricatio/capabilities/review.py

@@ -1,178 +1,16 @@
 """A module that provides functionality to rate tasks based on a rating manual and score range."""
 
-from typing import Dict, List, Optional, Self, Set, Unpack, cast
+from typing import Dict, Optional, Set, Unpack
 
 from fabricatio._rust_instances import TEMPLATE_MANAGER
 from fabricatio.capabilities.propose import Propose
 from fabricatio.capabilities.rating import Rating
 from fabricatio.config import configs
-from fabricatio.models.generic import Base, Display, ProposedAble, WithBriefing
+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.models.utils import ask_edit
-from questionary import Choice, checkbox, text
-from questionary import print as q_print
-from rich import print as r_print
-
-
-class ProblemSolutions(Base):
-    """Represents a problem-solution pair identified during a review process.
-
-    This class encapsulates a single problem with its corresponding potential solutions,
-    providing a structured way to manage review findings.
-
-    Attributes:
-        problem (str): The problem statement identified during review.
-        solutions (List[str]): A collection of potential solutions to address the problem.
-    """
-
-    problem: str
-    """The problem identified in the review."""
-    solutions: List[str]
-    """A collection of potential solutions to address the problem."""
-
-    def update_problem(self, problem: str) -> Self:
-        """Update the problem description.
-
-        Args:
-            problem (str): The new problem description to replace the current one.
-
-        Returns:
-            Self: The current instance with updated problem description.
-        """
-        self.problem = problem
-        return self
-
-    def update_solutions(self, solutions: List[str]) -> Self:
-        """Update the list of potential solutions.
-
-        Args:
-            solutions (List[str]): The new collection of solutions to replace the current ones.
-
-        Returns:
-            Self: The current instance with updated solutions.
-        """
-        self.solutions = solutions
-        return self
-
-    async def edit_problem(self) -> Self:
-        """Interactively edit the problem description using a prompt.
-
-        Returns:
-            Self: The current instance with updated problem description.
-        """
-        self.problem = await text("Please edit the problem below:", default=self.problem).ask_async()
-        return self
-
-    async def edit_solutions(self) -> Self:
-        """Interactively edit the list of potential solutions using a prompt.
-
-        Returns:
-            Self: The current instance with updated solutions.
-        """
-        q_print(self.problem, style="bold cyan")
-        self.solutions = await ask_edit(self.solutions)
-        return self
-
-
-class ReviewResult[T](ProposedAble, Display):
-    """Represents the outcome of a review process with identified problems and solutions.
-
-    This class maintains a structured collection of problems found during a review,
-    their proposed solutions, and a reference to the original reviewed object.
-
-    Attributes:
-        review_topic (str): The subject or focus area of the review.
-        problem_solutions (List[ProblemSolutions]): Collection of problems identified
-            during review along with their potential solutions.
-
-    Type Parameters:
-        T: The type of the object being reviewed.
-    """
-
-    review_topic: str
-    """The subject or focus area of the review."""
-
-    problem_solutions: List[ProblemSolutions]
-    """Collection of problems identified during review along with their potential solutions."""
-
-    _ref: T
-    """Reference to the original object that was reviewed."""
-
-    def update_topic(self, topic: str) -> Self:
-        """Update the review topic.
-
-        Args:
-            topic (str): The new topic to be associated with this review.
-
-        Returns:
-            Self: The current instance with updated review topic.
-        """
-        self.review_topic = topic
-        return self
-
-    def update_ref[K](self, ref: K) -> "ReviewResult[K]":
-        """Update the reference to the reviewed object.
-
-        Args:
-            ref (K): The new reference object to be associated with this review.
-
-        Returns:
-            ReviewResult[K]: The current instance with updated reference type.
-        """
-        self._ref = ref  # pyright: ignore [reportAttributeAccessIssue]
-        return cast("ReviewResult[K]", self)
-
-    def deref(self) -> T:
-        """Retrieve the referenced object that was reviewed.
-
-        Returns:
-            T: The original object that was reviewed.
-        """
-        return self._ref
-
-    async def supervisor_check(self, check_solutions: bool = True) -> Self:
-        """Perform an interactive review session to filter problems and solutions.
-
-        Presents an interactive prompt allowing a supervisor to select which
-        problems (and optionally solutions) should be retained in the final review.
-
-        Args:
-            check_solutions (bool, optional): When True, also prompts for filtering
-                individual solutions for each retained problem. Defaults to False.
-
-        Returns:
-            Self: The current instance with filtered problems and solutions.
-        """
-        if isinstance(self._ref, str):
-            display = self._ref
-        elif isinstance(self._ref, WithBriefing):
-            display = self._ref.briefing
-        elif isinstance(self._ref, Display):
-            display = self._ref.display()
-        else:
-            raise TypeError(f"Unsupported type for review: {type(self._ref)}")
-        # Choose the problems to retain
-        r_print(display)
-        chosen_ones: List[ProblemSolutions] = await checkbox(
-            f"Please choose the problems you want to retain.(Default: retain all)\n\t`{self.review_topic}`",
-            choices=[Choice(p.problem, p, checked=True) for p in self.problem_solutions],
-        ).ask_async()
-        self.problem_solutions = [await p.edit_problem() for p in chosen_ones]
-        if not check_solutions:
-            return self
-
-        # Choose the solutions to retain
-        for to_exam in self.problem_solutions:
-            to_exam.update_solutions(
-                await checkbox(
-                    f"Please choose the solutions you want to retain.(Default: retain all)\n\t`{to_exam.problem}`",
-                    choices=[Choice(s, s, checked=True) for s in to_exam.solutions],
-                ).ask_async()
-            )
-            await to_exam.edit_solutions()
-
-        return self
+from fabricatio.utils import ok
 
 
 class Review(Rating, Propose):
@@ -185,7 +23,7 @@ class Review(Rating, Propose):
     appropriate topic and criteria.
     """
 
-    async def review_task[T](self, task: Task[T], **kwargs: Unpack[ReviewKwargs]) -> ReviewResult[Task[T]]:
+    async def review_task[T](self, task: Task[T], **kwargs: Unpack[ReviewKwargs]) -> Optional[Improvement]:
         """Review a task using specified review criteria.
 
         This method analyzes a task object to identify problems and propose solutions
@@ -197,10 +35,10 @@ class Review(Rating, Propose):
                 including topic and optional criteria.
 
         Returns:
-            ReviewResult[Task[T]]: A review result containing identified problems and proposed solutions,
+            Improvement[Task[T]]: A review result containing identified problems and proposed solutions,
                 with a reference to the original task.
         """
-        return cast("ReviewResult[Task[T]]", await self.review_obj(task, **kwargs))
+        return await self.review_obj(task, **kwargs)
 
     async def review_string(
         self,
@@ -208,8 +46,8 @@ class Review(Rating, Propose):
         topic: str,
         criteria: Optional[Set[str]] = None,
         rating_manual: Optional[Dict[str, str]] = None,
-        **kwargs: Unpack[ValidateKwargs[ReviewResult[str]]],
-    ) -> ReviewResult[str]:
+        **kwargs: Unpack[ValidateKwargs[Improvement]],
+    ) -> Optional[Improvement]:
         """Review a string based on specified topic and criteria.
 
         This method analyzes a text string to identify problems and propose solutions
@@ -224,7 +62,7 @@ class Review(Rating, Propose):
             **kwargs (Unpack[ValidateKwargs]): Additional keyword arguments for the LLM usage.
 
         Returns:
-            ReviewResult[str]: A review result containing identified problems and proposed solutions,
+            Improvement: A review result containing identified problems and proposed solutions,
                 with a reference to the original text.
         """
         default = None
@@ -232,28 +70,21 @@ class Review(Rating, Propose):
             # this `default` is the default for the `propose` method
             default = kwargs.pop("default")
 
-        criteria = criteria or (await self.draft_rating_criteria(topic, **kwargs))
-        if not criteria:
-            raise ValueError("No criteria provided for review.")
+        criteria = ok(criteria or (await self.draft_rating_criteria(topic, **kwargs))," No criteria could be use.")
         manual = rating_manual or await self.draft_rating_manual(topic, criteria, **kwargs)
 
         if default is not None:
             kwargs["default"] = default
-        res = await self.propose(
-            ReviewResult,
+        return await self.propose(
+            Improvement,
             TEMPLATE_MANAGER.render_template(
                 configs.templates.review_string_template,
                 {"text": input_text, "topic": topic, "criteria_manual": manual},
             ),
             **kwargs,
         )
-        if not res:
-            raise ValueError("Failed to generate review result.")
-        return res.update_ref(input_text).update_topic(topic)
 
-    async def review_obj[M: (Display, WithBriefing)](
-        self, obj: M, **kwargs: Unpack[ReviewKwargs[ReviewResult[str]]]
-    ) -> ReviewResult[M]:
+    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
@@ -268,14 +99,14 @@ class Review(Rating, Propose):
             TypeError: If the object does not implement Display or WithBriefing.
 
         Returns:
-            ReviewResult[M]: A review result containing identified problems and proposed solutions,
+            Improvement: A review result containing identified problems and proposed solutions,
                 with a reference to the original object.
         """
         if isinstance(obj, Display):
-            text = obj.display()
+            text_to_review = obj.display()
         elif isinstance(obj, WithBriefing):
-            text = obj.briefing
+            text_to_review = obj.briefing
         else:
             raise TypeError(f"Unsupported type for review: {type(obj)}")
 
-        return (await self.review_string(text, **kwargs)).update_ref(obj)
+        return await self.review_string(text_to_review, **kwargs)

fabricatio/capabilities/task.py

@@ -1,14 +1,13 @@
 """A module for the task capabilities of the Fabricatio library."""
 
 from types import CodeType
-from typing import Any, Dict, List, Optional, Tuple, Unpack, cast
+from typing import Any, Dict, List, Optional, Tuple, Unpack
 
 import orjson
 from fabricatio._rust_instances import TEMPLATE_MANAGER
 from fabricatio.capabilities.propose import Propose
 from fabricatio.config import configs
 from fabricatio.journal import logger
-from fabricatio.models.generic import WithBriefing
 from fabricatio.models.kwargs_types import ChooseKwargs, ValidateKwargs
 from fabricatio.models.task import Task
 from fabricatio.models.tool import Tool, ToolExecutor
@@ -16,7 +15,7 @@ from fabricatio.models.usages import ToolBoxUsage
 from fabricatio.parser import JsonCapture, PythonCapture
 
 
-class ProposeTask(WithBriefing, Propose):
+class ProposeTask(Propose):
     """A class that proposes a task based on a prompt."""
 
     async def propose_task[T](
@@ -34,13 +33,13 @@ class ProposeTask(WithBriefing, Propose):
             A Task object based on the proposal result.
         """
         if not prompt:
-            logger.error(err := f"{self.name}: Prompt must be provided.")
+            logger.error(err := "Prompt must be provided.")
             raise ValueError(err)
 
-        return await self.propose(Task, prompt, **self.prepend_sys_msg(cast("Dict[str, Any]", kwargs)))
+        return await self.propose(Task, prompt, **kwargs)
 
 
-class HandleTask(WithBriefing, ToolBoxUsage):
+class HandleTask(ToolBoxUsage):
     """A class that handles a task based on a task object."""
 
     async def draft_tool_usage_code(
@@ -54,7 +53,7 @@ class HandleTask(WithBriefing, ToolBoxUsage):
         logger.info(f"Drafting tool usage code for task: {task.briefing}")
 
         if not tools:
-            err = f"{self.name}: Tools must be provided to draft the tool usage code."
+            err = "Tools must be provided to draft the tool usage code."
             logger.error(err)
             raise ValueError(err)
 
@@ -81,7 +80,7 @@ class HandleTask(WithBriefing, ToolBoxUsage):
         return await self.aask_validate(
             question=q,
             validator=_validator,
-            **self.prepend_sys_msg(cast("Dict[str, Any]", kwargs)),
+            **kwargs,
         )
 
     async def handle_fine_grind(
@@ -96,7 +95,7 @@ class HandleTask(WithBriefing, ToolBoxUsage):
         logger.info(f"Handling task: \n{task.briefing}")
 
         tools = await self.gather_tools_fine_grind(task, box_choose_kwargs, tool_choose_kwargs)
-        logger.info(f"{self.name} have gathered {[t.name for t in tools]}")
+        logger.info(f"Gathered {[t.name for t in tools]}")
 
         if tools and (pack := await self.draft_tool_usage_code(task, tools, data, **kwargs)):
             executor = ToolExecutor(candidates=tools, data=data)

fabricatio/config.py

@@ -238,6 +238,8 @@ class TemplateConfig(BaseModel):
     as_prompt_template: str = Field(default="as_prompt")
     """The name of the as prompt template which will be used to convert a string to a prompt."""
 
+    check_string_template: str = Field(default="check_string")
+    """The name of the check string template which will be used to check a string."""
 
 class MagikaConfig(BaseModel):
     """Magika configuration class."""

fabricatio/fs/curd.py

@@ -145,5 +145,9 @@ def gather_files(directory: str | Path | PathLike, extension: str) -> list[str]:
 
     Returns:
         list[str]: A list of file paths with the specified extension.
+
+    Example:
+        >>> gather_files('/path/to/directory', 'txt')
+        ['/path/to/directory/file1.txt', '/path/to/directory/file2.txt']
     """
     return [file.as_posix() for file in Path(directory).rglob(f"*.{extension}")]

fabricatio/models/action.py

@@ -18,7 +18,7 @@ from fabricatio.models.usages import ToolBoxUsage
 from pydantic import Field, PrivateAttr
 
 
-class Action(HandleTask, ProposeTask, Correct):
+class Action(WithBriefing, HandleTask, ProposeTask, Correct):
     """Class that represents an action to be executed in a workflow.
 
     Actions are the atomic units of work in a workflow. Each action performs
@@ -97,6 +97,8 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
     A workflow manages the execution of multiple actions in sequence, passing
     a shared context between them and handling task lifecycle events.
     """
+    description:str =""
+    """The description of the workflow, which describes the workflow's purpose and requirements."""
 
     _context: Queue[Dict[str, Any]] = PrivateAttr(default_factory=lambda: Queue(maxsize=1))
     """Queue for storing the workflow execution context."""
@@ -104,7 +106,9 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
     _instances: Tuple[Action, ...] = PrivateAttr(default_factory=tuple)
     """Instantiated action objects to be executed in this workflow."""
 
-    steps: Tuple[Union[Type[Action], Action], ...] = Field(...)
+    steps: Tuple[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="task_input")
@@ -157,13 +161,14 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
             # Process each action in sequence
             for step in self._instances:
                 current_action = step.name
-                logger.info(f"Executing step: {current_action}")
+                logger.info(f"Executing step >> {current_action}")
 
                 # Get current context and execute action
                 context = await self._context.get()
                 act_task = create_task(step.act(context))
                 # Handle task cancellation
                 if task.is_cancelled():
+                    logger.warning(f"Task cancelled by task: {task.name}")
                     act_task.cancel(f"Cancelled by task: {task.name}")
                     break
 
@@ -171,7 +176,7 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
                 modified_ctx = await act_task
                 logger.success(f"Step execution finished: {current_action}")
                 if step.output_key:
-                    logger.success(f"Setting output: {step.output_key}")
+                    logger.success(f"Setting output to `{step.output_key}`")
                 await self._context.put(modified_ctx)
 
             logger.success(f"Workflow execution finished: {self.name}")
@@ -182,7 +187,7 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
 
             if self.task_output_key not in final_ctx:
                 logger.warning(
-                    f"Task output key: {self.task_output_key} not found in the context, None will be returned. "
+                    f"Task output key: `{self.task_output_key}` not found in the context, None will be returned. "
                     f"You can check if `Action.output_key` is set the same as `WorkFlow.task_output_key`."
                 )
 

fabricatio/models/extra/advanced_judge.py

@@ -1,22 +1,29 @@
-"""A module containing the JudgeMent class."""
+"""Module containing the JudgeMent class for holding judgment results."""
 
 from typing import List
 
-from fabricatio.models.generic import ProposedAble
+from fabricatio.models.generic import Display, ProposedAble
 
 
-class JudgeMent(ProposedAble):
-    """A class representing a judgment made by a judge."""
+class JudgeMent(ProposedAble,Display):
+    """Represents a judgment result containing supporting/denying evidence and final verdict.
+
+    The class stores both affirmative and denies evidence, truth and reasons lists along with the final boolean judgment.
+    """
+    deny_evidence: List[str]
+    """List of clues supporting the denial."""
 
     affirm_evidence: List[str]
-    """List of evidence supporting the affirmation."""
+    """List of clues supporting the affirmation."""
 
-    deny_evidence: List[str]
-    """List of evidence supporting the denial."""
 
     final_judgement: bool
-    """The final judgement."""
+    """The final judgment made according to all extracted clues."""
 
     def __bool__(self) -> bool:
-        """Return the final judgement."""
+        """Return the final judgment value.
+
+        Returns:
+            bool: The stored final_judgement value indicating the judgment result.
+        """
         return self.final_judgement