thinking-processes 1.6.0__tar.gz → 1.7.0__tar.gz

{thinking_processes-1.6.0/thinking_processes.egg-info → thinking_processes-1.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: thinking-processes
-Version: 1.6.0
+Version: 1.7.0
 Summary: Diagramming tools for the Thinking Processes from the Theory of Constraints
 Author-email: Boris Wiegand <boris.wiegand@stahl-holding-saar.de>
 License:                     GNU GENERAL PUBLIC LICENSE

{thinking_processes-1.6.0 → thinking_processes-1.7.0}/pyproject.toml

@@ -7,7 +7,7 @@ include = ["thinking_processes*"]
 
 [project]
 name = "thinking-processes"
-version = "1.6.0"
+version = "1.7.0"
 dependencies = [
   "graphviz",
   "drawpyo"

{thinking_processes-1.6.0 → thinking_processes-1.7.0}/thinking_processes/evaporating_cloud.py

@@ -31,11 +31,11 @@ class EvaporatingCloud(Diagram):
             self, objective: str = '?',
             need_a: str = '?', need_b: str = '?',
             conflict_part_a: str = '?', conflict_part_b: str = '?'):
-        self.__objective = objective
-        self.__need_a = need_a
-        self.__need_b = need_b
-        self.__conflict_part_a = conflict_part_a
-        self.__conflict_part_b = conflict_part_b
+        self.objective = objective
+        self.need_a = need_a
+        self.need_b = need_b
+        self.conflict_part_a = conflict_part_a
+        self.conflict_part_b = conflict_part_b
         self.__assumptions_between_conflict_parts: list[tuple[str,bool|None]] = []
         self.__assumptions_on_need_a: list[tuple[str,bool|None]] = []
         self.__assumptions_on_need_b: list[tuple[str,bool|None]] = []
@@ -49,11 +49,39 @@ class EvaporatingCloud(Diagram):
     def add_assumption_on_need_b(self, text: str, is_true: bool|None = None):
         self.__assumptions_on_need_b.append((text, is_true))
 
+    def get_total_nr_of_assumptions(self) -> int:
+        return (
+            len(self.__assumptions_between_conflict_parts)
+            + len(self.__assumptions_on_need_a)
+            + len(self.__assumptions_on_need_b)
+        )
+
+    def remove_assumption(self, text: str):
+        """
+        removes any assumption equalling the given text. 
+        if there is no matching node in the diagram, nothing happens.  
+        """
+        self.__assumptions_between_conflict_parts = [
+            (assumption, is_true) 
+            for assumption, is_true in self.__assumptions_between_conflict_parts
+            if assumption != text
+        ]
+        self.__assumptions_on_need_a = [
+            (assumption, is_true) 
+            for assumption, is_true in self.__assumptions_on_need_a
+            if assumption != text
+        ]
+        self.__assumptions_on_need_b = [
+            (assumption, is_true) 
+            for assumption, is_true in self.__assumptions_on_need_b
+            if assumption != text
+        ]
+
     @override
     def to_graphviz(self) -> Graph:
         graph = Digraph(graph_attr=dict(rankdir="RL", nodesep='0.5'))
         graph.node(
-            'objective', self.__objective, 
+            'objective', self.objective, 
             fillcolor='lightgreen', shape='rect', style='rounded,filled',
         )
         with graph.subgraph(graph_attr=dict(concentrate='true', rank='same')) as subgraph:
@@ -65,11 +93,11 @@ class EvaporatingCloud(Diagram):
                 )
         with graph.subgraph(graph_attr=dict(rank="same")) as subgraph:
             subgraph.node(
-                'need_a', self.__need_a, 
+                'need_a', self.need_a, 
                 fillcolor='lightblue', shape='rect', style='rounded,filled',
             )
             subgraph.node(
-                'need_b', self.__need_b, 
+                'need_b', self.need_b, 
                 fillcolor='lightblue', shape='rect', style='rounded,filled',
             )
         graph.edge('need_a', 'objective')
@@ -83,11 +111,11 @@ class EvaporatingCloud(Diagram):
                 )
         with graph.subgraph(graph_attr=dict(rank="same")) as subgraph:
             subgraph.node(
-                'conflict_part_a', self.__conflict_part_a, 
+                'conflict_part_a', self.conflict_part_a, 
                 fillcolor='darkorange', shape='rect', style='rounded,filled',
             )
             subgraph.node(
-                'conflict_part_b', self.__conflict_part_b, 
+                'conflict_part_b', self.conflict_part_b, 
                 fillcolor='darkorange', shape='rect', style='rounded,filled',
             )
             subgraph.edge('conflict_part_a', 'conflict_part_b', dir='both')
@@ -112,7 +140,7 @@ class EvaporatingCloud(Diagram):
             color = 'green'
         else:
             color = 'red'
-        graph.node(node_id, assumption, color=color)
+        graph.node(node_id, assumption, color=color, fillcolor='white')
         graph.edge(node_id, target_a, dir='none', color='gray')
         if target_b is not None:
             graph.edge(node_id, target_b, dir='none', color='gray')
@@ -126,11 +154,11 @@ class EvaporatingCloud(Diagram):
             else:
                 return 'false_'
         return '\n'.join([
-            f'obj: {self.__objective}',
-            f'need_a: {self.__need_a}',
-            f'need_b: {self.__need_b}',
-            f'conflict_a: {self.__conflict_part_a}',
-            f'conflict_b: {self.__conflict_part_b}',
+            f'obj: {self.objective}',
+            f'need_a: {self.need_a}',
+            f'need_b: {self.need_b}',
+            f'conflict_a: {self.conflict_part_a}',
+            f'conflict_b: {self.conflict_part_b}',
         ] + [
             f'{assumption_state_prefix(assumption_state)}assumption_on_conflict: {assumption}'
             for assumption, assumption_state in sorted(self.__assumptions_between_conflict_parts)
@@ -147,15 +175,15 @@ class EvaporatingCloud(Diagram):
         ec = EvaporatingCloud()
         for line in s.splitlines():
             if line.startswith('obj:'):
-                ec.__objective = line.split(':', maxsplit=1)[1].strip()
+                ec.objective = line.split(':', maxsplit=1)[1].strip()
             elif line.startswith('need_a:'):
-                ec.__need_a = line.split(':', maxsplit=1)[1].strip()
+                ec.need_a = line.split(':', maxsplit=1)[1].strip()
             elif line.startswith('need_b:'):
-                ec.__need_b = line.split(':', maxsplit=1)[1].strip()
+                ec.need_b = line.split(':', maxsplit=1)[1].strip()
             elif line.startswith('conflict_a:'):
-                ec.__conflict_part_a = line.split(':', maxsplit=1)[1].strip()
+                ec.conflict_part_a = line.split(':', maxsplit=1)[1].strip()
             elif line.startswith('conflict_b:'):
-                ec.__conflict_part_b = line.split(':', maxsplit=1)[1].strip()
+                ec.conflict_part_b = line.split(':', maxsplit=1)[1].strip()
             else:
                 if line.startswith('true_'):
                     assumption_state = True

{thinking_processes-1.6.0 → thinking_processes-1.7.0}/thinking_processes/prerequisite_tree/node.py

@@ -38,8 +38,15 @@ class Obstacle:
     def text(self) -> str:
         return self.__obstacle
 
+    @text.setter
+    def text(self, value: str):
+        self.__obstacle = value
+
     def iter_solutions(self) -> Iterator['Solution']:
         return iter(self.__solutions)
+
+    def iter_subnodes(self) -> Iterator['Solution']:
+        return iter(self.__solutions)
     
     def add_solution(self, solution: str) -> 'Solution':
         child_node = Solution(f'{self.__id}.{len(self.__solutions)}', solution)
@@ -75,10 +82,17 @@ class Solution:
     @property
     def text(self) -> str:
         return self.__solution
-    
+
+    @text.setter
+    def text(self, value: str):
+        self.__solution = value
+
     def iter_obstacles(self) -> Iterator[Obstacle]:
         return iter(self.__obstacles)
 
+    def iter_subnodes(self) -> Iterator[Obstacle]:
+            return iter(self.__obstacles)
+
     def add_obstacle(self, obstacle: str) -> Obstacle:
         child_node = Obstacle(f'{self.__id}.{len(self.__obstacles)}', obstacle)
         self.__obstacles.append(child_node)

{thinking_processes-1.6.0 → thinking_processes-1.7.0}/thinking_processes/prerequisite_tree/prerequisite_tree.py

@@ -32,7 +32,7 @@ class PrerequisiteTree(Diagram):
         """
         creates a new prerequisite tree with the given objective
         """
-        self.__objective = objective
+        self.objective = objective
         self.__obstacles: list[Obstacle] = []
 
     def add_obstacle(self, obstacle: str) -> Obstacle:
@@ -58,7 +58,7 @@ class PrerequisiteTree(Diagram):
     @override
     def to_graphviz(self) -> Graph:
         graph = Digraph(graph_attr=dict(rankdir="BT"))
-        graph.node('objective', self.__objective, fillcolor='green', style='filled,rounded')
+        graph.node('objective', self.objective, fillcolor='green', style='filled,rounded')
         for obstacle in self.__obstacles:
             obstacle.add_to_graphviz_graph(graph, 'objective')
         return graph
@@ -153,4 +153,18 @@ class PrerequisiteTree(Diagram):
                 obstacle_to_string(o, level + 1)
                 for o in solution.iter_obstacles()
             ])
-        return f'{self.__objective}\n{"\n".join(map(lambda o: obstacle_to_string(o, 1), self.__obstacles))}'
+        return f'{self.objective}\n{"\n".join(map(lambda o: obstacle_to_string(o, 1), self.__obstacles))}'
+
+    def get_node_by_id(self, node_id: str) -> Obstacle|Solution:
+        """
+        returns the node with the given id.
+        The id of a node is a string that is generated when the node is created.
+        Raises an IndexError if no node with the given id exists in this tree. 
+        """
+        candidate_nodes = list(self.__obstacles)
+        while candidate_nodes:
+            node = candidate_nodes.pop()
+            if node.id == node_id:
+                return node
+            candidate_nodes.extend(node.iter_subnodes())
+        raise IndexError(f'no node with id "{node_id}" found in this tree')

{thinking_processes-1.6.0 → thinking_processes-1.7.0/thinking_processes.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: thinking-processes
-Version: 1.6.0
+Version: 1.7.0
 Summary: Diagramming tools for the Thinking Processes from the Theory of Constraints
 Author-email: Boris Wiegand <boris.wiegand@stahl-holding-saar.de>
 License:                     GNU GENERAL PUBLIC LICENSE