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

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/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(frozen=True,)
+    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")

fabricatio/models/extra/advanced_judge.py

@@ -2,23 +2,23 @@
 
 from typing import List
 
-from fabricatio.models.generic import ProposedAble
+from fabricatio.models.generic import Display, ProposedAble
 
 
-class JudgeMent(ProposedAble):
+class JudgeMent(ProposedAble,Display):
     """Represents a judgment result containing supporting/denying evidence and final verdict.
 
-    The class stores both affirmative and denies evidence lists along with the final boolean judgment.
+    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 judgment made according to all extracted evidence."""
+    """The final judgment made according to all extracted clues."""
 
     def __bool__(self) -> bool:
         """Return the final judgment value.

fabricatio/models/extra/article_base.py

@@ -2,9 +2,8 @@
 
 from abc import ABC, abstractmethod
 from enum import StrEnum
-from functools import cache
 from itertools import chain
-from typing import Generator, List, Optional, Self, Tuple
+from typing import Generator, List, Optional, Self, Tuple, overload
 
 from fabricatio.models.generic import (
     AsPrompt,
@@ -30,7 +29,6 @@ class ReferringType(StrEnum):
 type RefKey = Tuple[str, Optional[str], Optional[str]]
 
 
-@cache
 class ArticleRef(CensoredAble, Display, ProposedUpdateAble):
     """Reference to a specific chapter, section or subsection within the article. You SHALL not refer to an article component that is external and not present within our own article.
 
@@ -127,13 +125,13 @@ class Patch[T](ProposedUpdateAble, Display):
 
     tweaked: List[T]
     """Tweaked content list"""
+
     def update_from_inner(self, other: Self) -> Self:
         """Updates the current instance with the attributes of another instance."""
         self.tweaked.clear()
         self.tweaked.extend(other.tweaked)
         return self
 
-
     @classmethod
     def default(cls) -> Self:
         """Defaults to empty list."""
@@ -144,8 +142,6 @@ class ArticleRefPatch(Patch[ArticleRef]):
     """Patch for article refs."""
 
 
-
-
 class ArticleOutlineBase(
     ArticleMetaData,
     ResolveUpdateConflict,
@@ -340,6 +336,34 @@ class ArticleBase[T: ChapterBase](FinalizedDumpAble, AsPrompt, ABC):
                 yield sec
                 yield from sec.subsections
 
+    def iter_support_on(self, rev: bool = False) -> Generator[ArticleRef, None, None]:
+        """Iterates over all references that the article components support.
+
+        Args:
+            rev (bool): If True, iterate in reverse order.
+
+        Yields:
+            ArticleRef: Each reference that the article components support.
+        """
+        if rev:
+            yield from chain(*[a.support_to for a in self.iter_dfs_rev()])
+            return
+        yield from chain(*[a.support_to for a in self.iter_dfs()])
+
+    def iter_depend_on(self, rev: bool = False) -> Generator[ArticleRef, None, None]:
+        """Iterates over all references that the article components depend on.
+
+        Args:
+            rev (bool): If True, iterate in reverse order.
+
+        Yields:
+            ArticleRef: Each reference that the article components depend on.
+        """
+        if rev:
+            yield from chain(*[a.depend_on for a in self.iter_dfs_rev()])
+            return
+        yield from chain(*[a.depend_on for a in self.iter_dfs()])
+
     def iter_sections(self) -> Generator[Tuple[ChapterBase, SectionBase], None, None]:
         """Iterates through all sections in the article.
 
@@ -369,7 +393,13 @@ class ArticleBase[T: ChapterBase](FinalizedDumpAble, AsPrompt, ABC):
                 return component, summary
         return None
 
-    def find_illegal_ref(self) -> Optional[Tuple[ArticleRef, str]]:
+    @overload
+    def find_illegal_ref(self, gather_identical: bool) -> Optional[Tuple[ArticleRef | List[ArticleRef], str]]: ...
+
+    @overload
+    def find_illegal_ref(self) -> Optional[Tuple[ArticleRef, str]]: ...
+
+    def find_illegal_ref(self, gather_identical: bool = False) -> Optional[Tuple[ArticleRef | List[ArticleRef], str]]:
         """Finds the first illegal component in the outline.
 
         Returns:
@@ -380,8 +410,15 @@ class ArticleBase[T: ChapterBase](FinalizedDumpAble, AsPrompt, ABC):
             for ref in chain(component.depend_on, component.support_to):
                 if not ref.deref(self):
                     summary += f"Invalid internal reference in `{component.__class__.__name__}` titled `{component.title}`, because the referred {ref.referring_type} is not exists within the article, see the original obj dump: {ref.model_dump()}\n"
-                if summary:
+                if summary and not gather_identical:
                     return ref, summary
+                if summary and gather_identical:
+                    return [
+                        identical_ref
+                        for identical_ref in chain(self.iter_depend_on(), self.iter_support_on())
+                        if identical_ref == ref
+                    ], summary
+
         return None
 
     def finalized_dump(self) -> str: