fabricatio 0.2.8.dev3__cp312-cp312-win_amd64.whl → 0.2.9__cp312-cp312-win_amd64.whl

fabricatio/models/extra/problem.py

@@ -1,52 +1,57 @@
 """A class representing a problem-solution pair identified during a review process."""
 
-from typing import List, Literal, Self
+from itertools import chain
+from typing import Any, List, Optional, Self, Tuple, Unpack
 
-from fabricatio.models.generic import Display, ProposedAble, ProposedUpdateAble, WithBriefing
+from fabricatio.journal import logger
+from fabricatio.models.generic import SketchedAble, WithBriefing
 from fabricatio.utils import ask_edit
+from pydantic import Field
 from questionary import Choice, checkbox, text
 from rich import print as r_print
 
 
-class Problem(ProposedAble, WithBriefing, Display):
+class Problem(SketchedAble, WithBriefing):
     """Represents a problem identified during review."""
 
-    description: str
-    """Description of the problem, The """
+    description: str = Field(alias="cause")
+    """The cause of the problem, including the root cause, the context, and the impact, make detailed enough for engineer to understand the problem and its impact."""
 
-    severity: Literal["low", "medium", "high"]
-    """Severity level of the problem."""
-
-    category: str
-    """Category of the problem."""
+    severity_level: int = Field(ge=0, le=10)
+    """Severity level of the problem, which is a number between 0 and 10, 0 means the problem is not severe, 10 means the problem is extremely severe."""
 
     location: str
     """Location where the problem was identified."""
 
-    recommendation: str
-    """Recommended solution or action."""
-
 
-class Solution(ProposedAble, WithBriefing, Display):
+class Solution(SketchedAble, WithBriefing):
     """Represents a proposed solution to a problem."""
 
-    operation: str
-    """Description or identifier of the operation."""
+    description: str = Field(alias="mechanism")
+    """Description of the solution, including a detailed description of the execution steps, and the mechanics, principle or fact."""
 
-    feasibility: Literal["low", "medium", "high"]
-    """Feasibility level of the solution."""
+    execute_steps: List[str]
+    """A list of steps to execute to implement the solution, which is expected to be able to finally solve the corresponding problem, and which should be an Idiot-proof tutorial."""
 
-    impact: Literal["low", "medium", "high"]
-    """Impact level of the solution."""
+    feasibility_level: int = Field(ge=0, le=10)
+    """Feasibility level of the solution, which is a number between 0 and 10, 0 means the solution is not feasible, 10 means the solution is complete feasible."""
 
+    impact_level: int = Field(ge=0, le=10)
+    """Impact level of the solution, which is a number between 0 and 10, 0 means the solution is not impactful, 10 means the solution is extremely impactful."""
 
-class ProblemSolutions(ProposedUpdateAble):
+
+class ProblemSolutions(SketchedAble):
     """Represents a problem-solution pair identified during a review process."""
 
     problem: Problem
     """The problem identified in the review."""
     solutions: List[Solution]
-    """A collection of potential solutions."""
+    """A collection of potential solutions, spread the thought, add more solution as possible.Do not leave this as blank"""
+
+    def model_post_init(self, context: Any, /) -> None:
+        """Initialize the problem-solution pair with a problem and a list of solutions."""
+        if len(self.solutions) == 0:
+            logger.warning(f"No solution found for problem {self.problem.name}, please add more solutions manually.")
 
     def update_from_inner(self, other: Self) -> Self:
         """Update the current instance with another instance's attributes."""
@@ -64,6 +69,10 @@ class ProblemSolutions(ProposedUpdateAble):
         self.solutions = solutions
         return self
 
+    def has_solutions(self) -> bool:
+        """Check if the problem-solution pair has any solutions."""
+        return len(self.solutions) > 0
+
     async def edit_problem(self) -> Self:
         """Interactively edit the problem description."""
         self.problem = Problem.model_validate_strings(
@@ -78,13 +87,33 @@ class ProblemSolutions(ProposedUpdateAble):
         self.solutions = [Solution.model_validate_strings(s) for s in string_seq]
         return self
 
+    def decided(self) -> bool:
+        """Check if the improvement is decided."""
+        return len(self.solutions) == 1
+
+    def final_solution(self, always_use_first: bool = False) -> Optional[Solution]:
+        """Get the final solution."""
+        if not always_use_first and not self.decided():
+            logger.error(
+                f"There is {len(self.solutions)} solutions for problem {self.problem.name}, please decide which solution is eventually adopted."
+            )
+            return None
+        return self.solutions[0]
 
-class Improvement(ProposedAble, Display):
+
+class Improvement(SketchedAble):
     """A class representing an improvement suggestion."""
 
+    focused_on: str
+    """The focused on topic of the improvement"""
+
     problem_solutions: List[ProblemSolutions]
     """Collection of problems identified during review along with their potential solutions."""
 
+    def all_problems_have_solutions(self) -> bool:
+        """Check if all problems have solutions."""
+        return all(ps.has_solutions() for ps in self.problem_solutions)
+
     async def supervisor_check(self, check_solutions: bool = True) -> Self:
         """Perform an interactive review session to filter problems and solutions.
 
@@ -118,3 +147,15 @@ class Improvement(ProposedAble, Display):
             await to_exam.edit_solutions()
 
         return self
+
+    def decided(self) -> bool:
+        """Check if the improvement is decided."""
+        return all(ps.decided() for ps in self.problem_solutions)
+
+    @classmethod
+    def gather(cls, *improvements: Unpack[Tuple["Improvement", ...]]) -> Self:
+        """Gather multiple improvements into a single instance."""
+        return cls(
+            focused_on=";".join(imp.focused_on for imp in improvements),
+            problem_solutions=list(chain(*(imp.problem_solutions for imp in improvements))),
+        )

fabricatio/models/extra/rule.py

@@ -1,23 +1,52 @@
-"""A module containing classes related to rule sets and rules."""
+"""A module containing classes related to rule sets and rules.
 
-from typing import List
+This module provides the `Rule` and `RuleSet` classes, which are used to define and manage
+individual rules and collections of rules, respectively. These classes are designed to
+facilitate the creation, organization, and application of rules in various contexts,
+ensuring clarity, consistency, and enforceability. The module supports detailed
+descriptions, examples, and metadata for each rule and rule set, making it suitable for
+complex rule management systems.
+"""
 
-from fabricatio.models.generic import Described, Display, PersistentAble, ProposedAble, WithBriefing
+from typing import List, Self, Tuple, Unpack
 
+from fabricatio.models.generic import Language, PersistentAble, SketchedAble, WithBriefing
+from more_itertools import flatten
 
-class Rule(WithBriefing,ProposedAble,Display):
+
+class Rule(WithBriefing, Language, SketchedAble, PersistentAble):
     """Represents a rule or guideline for a specific topic."""
 
     violation_examples: List[str]
-    """Examples of violations of the rule."""
+    """A list of concrete examples demonstrating violations of this rule. Each example should
+    be a clear scenario or case that illustrates how the rule can be broken, including the
+    context, actions, and consequences of the violation. These examples should help in
+    understanding the boundaries of the rule."""
+
     compliance_examples: List[str]
-    """Examples of how to comply with the rule."""
+    """A list of concrete examples demonstrating proper compliance with this rule. Each example
+    should be a clear scenario or case that illustrates how to correctly follow the rule,
+    including the context, actions, and positive outcomes of compliance. These examples should
+    serve as practical guidance for implementing the rule correctly."""
 
 
-class RuleSet(ProposedAble, Display, PersistentAble, Described):
+class RuleSet(SketchedAble, PersistentAble, WithBriefing, Language):
     """Represents a collection of rules and guidelines for a particular topic."""
 
-    title: str
-    """The title of the rule set."""
     rules: List[Rule]
-    """The rules and guidelines contained in the rule set."""
+    """The collection of rules and guidelines contained in this rule set. Each rule should be
+    a well-defined, specific guideline that contributes to the overall purpose of the rule set.
+    The rules should be logically organized and consistent with each other, forming a coherent
+    framework for the topic or domain covered by the rule set."""
+
+    @classmethod
+    def gather(cls, *rulesets: Unpack[Tuple["RuleSet",...]]) -> Self:
+        """Gathers multiple rule sets into a single rule set."""
+        if not rulesets:
+            raise ValueError("No rulesets provided")
+        return cls(
+            language=rulesets[0].language,
+            name=";".join(ruleset.name for ruleset in rulesets),
+            description=";".join(ruleset.description for ruleset in rulesets),
+            rules=list(flatten(r.rules for r in rulesets)),
+        )