Changeset f959488 in flowtimer

Timestamp:

08/17/24 22:48:01 (9 months ago)

Author:

Enrico Schwass <ennoausberlin@…>

Branches:

guix

Children:

daa2276

Parents:

3b76475

Message:

Schedule can be initialized with a list of Phases and RecurringPhaseSequences

Location:

flowtimer

Files:

• Phase.py (modified) (5 diffs)
• RecurringPhaseSequence.py (modified) (1 diff)
• Schedule.py (modified) (2 diffs)

flowtimer/Phase.py

@@ -8 +8 @@
     """
 
-    def __init__(self, title, duration):
+    def __init__(self, title, ticks):
         """
         creates the variables associated with that class
@@ -15 +15 @@
         :param title: Name of phase
 
-        :type duration: int
-        :param duration: Duration in seconds
+        :type ticks: int
+        :param ticks: ticks in seconds
         """
 
         self.title = title
-        self.duration = duration
+        self.initial_ticks = ticks
         self.state = "initial"
-        self.time_left = self.duration
+        self.ticks_left = ticks
 
     def to_json(self):
-        return json.dumps({"title": self.title, "duration": self.duration})
-        # return json.dumps(self.__dict__)
+        return json.dumps({"title": self.title, "duration": self.initial_ticks})
 
     def __str__(self):
@@ -36 +35 @@
         """
 
-        return ("-->" + self.title + "\nDuration=" +
-                str(self.duration) + "\n")
+        return ("-->" + self.title + "\nTicks left=" +
+                str(self.ticks_left) + "\n" + str(self.state) + "\n")
 
     def abort(self):
@@ -44 +43 @@
     def start(self):
         self.state = "running"
+
+    def reset(self):
+        self.ticks_left = self.initial_ticks
+        self.state = "initial"
 
     def pause(self):
@@ -58 +61 @@
         return self.state == "paused"
 
-    def tick(self, duration):
-        self.time_left -= duration
+    def tick(self, ticks):
+        result = self.ticks_left - ticks
 
-        if self.time_left <= 0:
-            self.time_left = 0
+        if result <= 0:
+            print("Single phase finished")
+            self.ticks_left = 0
             self.state = "finished"
+        else:
+            self.ticks_left = result
+        return result

flowtimer/RecurringPhaseSequence.py

@@ -24 +24 @@
                            "repetitions": 3})
 
+    @classmethod
+    def default(cls):
+        return cls.from_json(cls.default_json_string())
+
     def __init__(self, phase_list, repetitions):
+        assert repetitions > 0
+        assert phase_list is not []
+        self.state = "initial"
         self.phase_list = phase_list
-        self.repetitions = repetitions
+        self.current_phase = phase_list[0]
+        self.initial_repetitions = repetitions
+        self.passes_left = repetitions
 
     def to_json(self):
         return json.dumps(self.__dict__, default=lambda each: each.to_json())
 
+    def upcoming_phases_in_pass(self):
+        index = self.phase_list.index(self.current_phase)
+        if index < len(self.phase_list) - 1:
+            return self.phase_list[index+1:]
+        return []
+
+    def ticks_left(self):
+        return (self.passes_left * sum([each.initial_ticks for each in self.phase_list]) +
+                self.current_phase.ticks_left +
+                sum([each.ticks_left for each in self.upcoming_phases_in_pass()]))
+
+    def finished(self):
+        return (self.passes_left < 1) and (not self.upcoming_phases_in_pass())
+
+    def abort(self):
+        self.current_phase.abort()
+        self.state = "finished"
+
+    def tick(self, ticks):
+        if not self.finished():
+            result = self.current_phase.tick(ticks)
+            print("Current phase", self.current_phase)
+            print("Passes left:", self.passes_left)
+            if self.current_phase.finished():
+                if self.upcoming_phases_in_pass():
+                    self.current_phase.reset()
+                    self.current_phase = self.upcoming_phases_in_pass()[0]
+                    self.current_phase.start()
+                    print("New phase:", self.current_phase)
+                    self.tick(abs(result))
+                    return True
+                self.passes_left -= 1
+                if self.finished():
+                    self.state = "finished"
+                else:
+                    self.current_phase.reset()
+                    self.current_phase = self.phase_list[0]
+        return True
+
     def unrolled(self):
         return [deepcopy(seq) for seq in [each for each in self.repetitions * self.phase_list]]
-        # return self.repetitions * self.phase_list

flowtimer/Schedule.py

@@ -32 +32 @@
         if (self.current_phase.finished()) and (self.phase_list[-1] == self.current_phase):
             self.state = "finished"
+            print("Finished")
             return True
         else:
@@ -43 +44 @@
             self.current_phase = self.phase_list[index+1]
 
-    def time_left(self):
-        return self.current_phase.time_left + sum([phase.time_left for phase in self.upcoming_phases()])
+    def ticks_left(self):
+        return (self.current_phase.ticks_left +
+                sum([phase.ticks_left for phase in self.upcoming_phases()]))
 
     def upcoming_phases(self):