Refactor ProcessStep code and undo replacement of implicit steps by explicit ones.

[plomtask] / plomtask / processes.py

diff --git a/plomtask/processes.py b/plomtask/processes.py
index 0a9b95b3f5faf89fd5a4a9a0991c7bb9a70ca9c5..4ad6e75ca205099f6afc9b492097b8ca1fd11832 100644 (file)
--- a/plomtask/processes.py
+++ b/plomtask/processes.py
@@ -4,9 +4,10 @@ from dataclasses import dataclass
 from typing import Set, Any
 from sqlite3 import Row
 from plomtask.db import DatabaseConnection, BaseModel
 from typing import Set, Any
 from sqlite3 import Row
 from plomtask.db import DatabaseConnection, BaseModel

-from plomtask.misc import VersionedAttribute
+from plomtask.versioned_attributes import VersionedAttribute

 from plomtask.conditions import Condition, ConditionsRelations
 from plomtask.conditions import Condition, ConditionsRelations

-from plomtask.exceptions import NotFoundException, BadFormatException
+from plomtask.exceptions import (NotFoundException, BadFormatException,
+                                 HandledException)

 
 
 @dataclass
 
 
 @dataclass


@@ -21,19 +22,24 @@ class ProcessStepsNode:
 
 class Process(BaseModel[int], ConditionsRelations):
     """Template for, and metadata for, Todos, and their arrangements."""
 
 class Process(BaseModel[int], ConditionsRelations):
     """Template for, and metadata for, Todos, and their arrangements."""

-    table_name = 'processes'
-

     # pylint: disable=too-many-instance-attributes
     # pylint: disable=too-many-instance-attributes

-
-    def __init__(self, id_: int | None) -> None:
-        super().__init__(id_)
+    table_name = 'processes'
+    to_save = ['calendarize']
+    to_save_versioned = ['title', 'description', 'effort']
+    to_save_relations = [('process_conditions', 'process', 'conditions', 0),
+                         ('process_blockers', 'process', 'blockers', 0),
+                         ('process_enables', 'process', 'enables', 0),
+                         ('process_disables', 'process', 'disables', 0)]
+    to_search = ['title.newest', 'description.newest']
+
+    def __init__(self, id_: int | None, calendarize: bool = False) -> None:
+        BaseModel.__init__(self, id_)
+        ConditionsRelations.__init__(self)

         self.title = VersionedAttribute(self, 'process_titles', 'UNNAMED')
         self.description = VersionedAttribute(self, 'process_descriptions', '')
         self.effort = VersionedAttribute(self, 'process_efforts', 1.0)
         self.explicit_steps: list[ProcessStep] = []
         self.title = VersionedAttribute(self, 'process_titles', 'UNNAMED')
         self.description = VersionedAttribute(self, 'process_descriptions', '')
         self.effort = VersionedAttribute(self, 'process_efforts', 1.0)
         self.explicit_steps: list[ProcessStep] = []

-        self.conditions: list[Condition] = []
-        self.enables: list[Condition] = []
-        self.disables: list[Condition] = []
+        self.calendarize = calendarize

 
     @classmethod
     def from_table_row(cls, db_conn: DatabaseConnection,
 
     @classmethod
     def from_table_row(cls, db_conn: DatabaseConnection,


@@ -49,7 +55,7 @@ class Process(BaseModel[int], ConditionsRelations):
                                       process.id_):
             step = ProcessStep.from_table_row(db_conn, row_)
             process.explicit_steps += [step]  # pylint: disable=no-member
                                       process.id_):
             step = ProcessStep.from_table_row(db_conn, row_)
             process.explicit_steps += [step]  # pylint: disable=no-member

-        for name in ('conditions', 'enables', 'disables'):
+        for name in ('conditions', 'blockers', 'enables', 'disables'):

             table = f'process_{name}'
             assert isinstance(process.id_, int)
             for c_id in db_conn.column_where(table, 'condition',
             table = f'process_{name}'
             assert isinstance(process.id_, int)
             for c_id in db_conn.column_where(table, 'condition',


@@ -87,6 +93,13 @@ class Process(BaseModel[int], ConditionsRelations):
             for child in explicit_children:
                 assert isinstance(child.id_, int)
                 node.steps[child.id_] = make_node(child)
             for child in explicit_children:
                 assert isinstance(child.id_, int)
                 node.steps[child.id_] = make_node(child)

+                # # ensure that one (!) explicit step of process replaces
+                # # one (!) implicit step of same process
+                # for i in [i for i, s in node.steps.items()
+                #           if not s.process_step.owner_id == child.id_
+                #           and s.process.id_ == child.step_process_id]:
+                #     del node.steps[i]
+                #     break

             node.seen = node_id in seen_step_ids
             seen_step_ids.add(node_id)
             for id_, step in node.steps.items():
             node.seen = node_id in seen_step_ids
             seen_step_ids.add(node_id)
             for id_, step in node.steps.items():


@@ -104,21 +117,13 @@ class Process(BaseModel[int], ConditionsRelations):
             walk_steps(step_id, step_node)
         return steps
 
             walk_steps(step_id, step_node)
         return steps
 

-    def _add_step(self,
-                  db_conn: DatabaseConnection,
-                  id_: int | None,
-                  step_process_id: int,
-                  parent_step_id: int | None) -> ProcessStep:
-        """Create new ProcessStep, save and add it to self.explicit_steps.
-
-        Also checks against step recursion.
+    def set_steps(self, db_conn: DatabaseConnection,
+                  steps: list[ProcessStep]) -> None:
+        """Set self.explicit_steps in bulk.

 
 

-        The new step's parent_step_id will fall back to None either if no
-        matching ProcessStep is found (which can be assumed in case it was
-        just deleted under its feet), or if the parent step would not be
-        owned by the current Process.
+        Checks against recursion, and turns into top-level steps any of
+        unknown or non-owned parent.

         """
         """

-

         def walk_steps(node: ProcessStep) -> None:
             if node.step_process_id == self.id_:
                 raise BadFormatException('bad step selection causes recursion')
         def walk_steps(node: ProcessStep) -> None:
             if node.step_process_id == self.id_:
                 raise BadFormatException('bad step selection causes recursion')


@@ -126,60 +131,44 @@ class Process(BaseModel[int], ConditionsRelations):
             for step in step_process.explicit_steps:
                 walk_steps(step)
 
             for step in step_process.explicit_steps:
                 walk_steps(step)
 

-        if parent_step_id is not None:
-            try:
-                parent_step = ProcessStep.by_id(db_conn, parent_step_id)
-                if parent_step.owner_id != self.id_:
-                    parent_step_id = None
-            except NotFoundException:
-                parent_step_id = None
-        assert isinstance(self.id_, int)
-        step = ProcessStep(id_, self.id_, step_process_id, parent_step_id)
-        walk_steps(step)
-        self.explicit_steps += [step]
-        step.save(db_conn)  # NB: This ensures a non-None step.id_.
-        return step
-
-    def set_steps(self, db_conn: DatabaseConnection,
-                  steps: list[tuple[int | None, int, int | None]]) -> None:
-        """Set self.explicit_steps in bulk."""

         assert isinstance(self.id_, int)
         for step in self.explicit_steps:
             step.uncache()
         self.explicit_steps = []
         db_conn.delete_where('process_steps', 'owner', self.id_)
         assert isinstance(self.id_, int)
         for step in self.explicit_steps:
             step.uncache()
         self.explicit_steps = []
         db_conn.delete_where('process_steps', 'owner', self.id_)

-        for step_tuple in steps:
-            self._add_step(db_conn, step_tuple[0],
-                           step_tuple[1], step_tuple[2])
+        for step in steps:
+            step.save(db_conn)
+            if step.parent_step_id is not None:
+                try:
+                    parent_step = ProcessStep.by_id(db_conn,
+                                                    step.parent_step_id)
+                    if parent_step.owner_id != self.id_:
+                        step.parent_step_id = None
+                except NotFoundException:
+                    step.parent_step_id = None
+            walk_steps(step)
+            self.explicit_steps += [step]

 
     def save(self, db_conn: DatabaseConnection) -> None:
         """Add (or re-write) self and connected items to DB."""
 
     def save(self, db_conn: DatabaseConnection) -> None:
         """Add (or re-write) self and connected items to DB."""

-        self.save_core(db_conn)
+        super().save(db_conn)

         assert isinstance(self.id_, int)
         assert isinstance(self.id_, int)

-        self.title.save(db_conn)
-        self.description.save(db_conn)
-        self.effort.save(db_conn)
-        db_conn.rewrite_relations('process_conditions', 'process', self.id_,
-                                  [[c.id_] for c in self.conditions])
-        db_conn.rewrite_relations('process_enables', 'process', self.id_,
-                                  [[c.id_] for c in self.enables])
-        db_conn.rewrite_relations('process_disables', 'process', self.id_,
-                                  [[c.id_] for c in self.disables])

         db_conn.delete_where('process_steps', 'owner', self.id_)
         for step in self.explicit_steps:
             step.save(db_conn)
 
     def remove(self, db_conn: DatabaseConnection) -> None:
         db_conn.delete_where('process_steps', 'owner', self.id_)
         for step in self.explicit_steps:
             step.save(db_conn)
 
     def remove(self, db_conn: DatabaseConnection) -> None:

-        """Remove from DB, with dependencies."""
+        """Remove from DB, with dependencies.
+
+        Guard against removal of Processes in use.
+        """

         assert isinstance(self.id_, int)
         assert isinstance(self.id_, int)

-        db_conn.delete_where('process_conditions', 'process', self.id_)
-        db_conn.delete_where('process_enables', 'process', self.id_)
-        db_conn.delete_where('process_disables', 'process', self.id_)
+        for _ in db_conn.row_where('process_steps', 'step_process', self.id_):
+            raise HandledException('cannot remove Process in use')
+        for _ in db_conn.row_where('todos', 'process', self.id_):
+            raise HandledException('cannot remove Process in use')

         for step in self.explicit_steps:
             step.remove(db_conn)
         for step in self.explicit_steps:
             step.remove(db_conn)

-        db_conn.delete_where('process_titles', 'parent', self.id_)
-        db_conn.delete_where('process_descriptions', 'parent', self.id_)
-        db_conn.delete_where('process_efforts', 'parent', self.id_)

         super().remove(db_conn)
 
 
         super().remove(db_conn)
 
 


@@ -195,10 +184,6 @@ class ProcessStep(BaseModel[int]):
         self.step_process_id = step_process_id
         self.parent_step_id = parent_step_id
 
         self.step_process_id = step_process_id
         self.parent_step_id = parent_step_id
 

-    def save(self, db_conn: DatabaseConnection) -> None:
-        """Default to simply calling self.save_core for simple cases."""
-        self.save_core(db_conn)
-

     def remove(self, db_conn: DatabaseConnection) -> None:
         """Remove from DB, and owner's .explicit_steps."""
         owner = Process.by_id(db_conn, self.owner_id)
     def remove(self, db_conn: DatabaseConnection) -> None:
         """Remove from DB, and owner's .explicit_steps."""
         owner = Process.by_id(db_conn, self.owner_id)