Fixed Simple Alarm and updating Smart

alarm.py

-# # Code adapted from https://raspberrydiy.com/raspberry-pi-alarm-clock/
-# import vlc
-# from time import sleep
-# # from dataclasses import dataclass, field
-#
-# # @dataclass
-# # class AlarmClock:
-#
-# #     sound: str
-#
-#
-# # Constants
-# VLC_INSTANCE = vlc.Instance("--input-repeat=999")
-# PLAYER = VLC_INSTANCE.media_player_new()
-# SONG = VLC_INSTANCE.media_new("/home/pi/Music/song.mp3")
-# VOLUME = 100
-#
-# PLAYER.set_media(SONG)
-# PLAYER.audio_set_volume(VOLUME)
-#
-# def play_alarm(volume: int = VOLUME):
-#     PLAYER.set_media(SONG)
-#     PLAYER.audio_set_volume(volume)
-#
-# def stop_alarm():
-#     pass
-#
-# def snooze_alarm(snooze_time: int = 60):
-#     pass
-#
-#
-#
 from enum import Enum, auto
 from datetime import time, datetime
 
@@ -59,30 +27,28 @@ class BaseAlarmClock:
         return self._wake_time
 
     def set_alarm(self, wake_time: time) -> time:
-        print(f"SETTING ALARM to: {wake_time}")
+        # print(f"SETTING ALARM to: {wake_time}")
         self._current_state = AlarmState.SET
         self._wake_time = wake_time
         return self._wake_time
 
     def start_alarm(self) -> None:
-        print("STARTING ALARM")
+        # print("STARTING ALARM")
         self._current_state = AlarmState.RUNNING
 
     def sound_alarm(self) -> None:
-        print("SOUNDING ALARM")
+        # print("SOUNDING ALARM")
         self._current_state = AlarmState.PLAYING
 
     def snooze_alarm(self) -> None:
-        print("SNOOZING ALARM")
+        # print("SNOOZING ALARM")
         self._current_state = AlarmState.SNOOZED
 
     def stop_alarm(self, deactivate: bool = True) -> None:
-        print("STOPPING ALARM")
-        if self._current_state is AlarmState.PLAYING:
-            print("STOPPED PLAYING ALARM")
+        # print("STOPPING ALARM")
+        # if self._current_state is AlarmState.PLAYING:
+        #     print("STOPPED PLAYING ALARM")
         self._current_state = AlarmState.DEACTIVATED if deactivate else AlarmState.SET
 
-    def alarm_check_reached(self, current_time: time = datetime.now().time()) -> bool:
-        # result = current_time >= self.wake_time if self.current_state is AlarmState.RUNNING else False
-        # print(f"{result = }")
+    def alarm_check_reached(self, current_time: time) -> bool:
         return current_time >= self._wake_time if self._current_state is AlarmState.RUNNING else False

simple_alarm_clock.py

@@ -10,31 +10,54 @@ from pynput import keyboard
 # 4. Snooze Alarm   - Stop the alarm sound and wait for some time to play the alarm again
 # 5. Stop Alarm     - If the alarm is active or is playing, stop the alarm (deactivate state)
 
-ALARM_TIME = time(19, 13, 0)
+ALARM_TIME = time(15, 5, 0)
 SNOOZE_KEY = keyboard.Key.up
 ALARM_OFF_KEY = keyboard.Key.esc
 SNOOZE_SEC = 5
 
 
-def simple_alarm_mode(alarm_clock: BaseAlarmClock):
-    alarm_clock.start_alarm()
-    while not alarm_clock.alarm_check_reached():
-        print(f"ALARM SLEEPING @: {datetime.now().time()}")
-        sleep(1)
-    alarm_clock.sound_alarm()
-    while alarm_clock.current_state is not AlarmState.DEACTIVATED:
-        with keyboard.Events() as events:
-            for event in events:
-                if event.key == ALARM_OFF_KEY:
-                    alarm_clock.stop_alarm()
-                    break
-                elif event.key == SNOOZE_KEY:
-                    alarm_clock.snooze_alarm()
-                    sleep(SNOOZE_SEC)
-                    alarm_clock.sound_alarm()
-                    break
+class SimpleAlarmClock(BaseAlarmClock):
+    def set_alarm(self, wake_time: time) -> time:
+        print(f"SETTING ALARM to: {wake_time}")
+        return super(SimpleAlarmClock, self).set_alarm(wake_time)
+
+    def start_alarm(self) -> None:
+        print("STARTING ALARM")
+        super(SimpleAlarmClock, self).start_alarm()
+
+    def sound_alarm(self) -> None:
+        print("SOUNDING ALARM")
+        super(SimpleAlarmClock, self).sound_alarm()
+
+    def snooze_alarm(self) -> None:
+        print("SNOOZING ALARM")
+        super(SimpleAlarmClock, self).snooze_alarm()
+
+    def stop_alarm(self, deactivate: bool = True) -> None:
+        print("STOPPING ALARM")
+        if self._current_state is AlarmState.PLAYING:
+            print("STOPPED PLAYING ALARM")
+        super(SimpleAlarmClock, self).stop_alarm()
+
+    def simple_alarm_mode(self):
+        self.start_alarm()
+        while not self.alarm_check_reached(datetime.now().time()):
+            print(f"ALARM SLEEPING @: {datetime.now().time()}")
+            sleep(1)
+        self.sound_alarm()
+        while self.current_state is not AlarmState.DEACTIVATED:
+            with keyboard.Events() as events:
+                for event in events:
+                    if event.key == ALARM_OFF_KEY:
+                        self.stop_alarm()
+                        break
+                    elif event.key == SNOOZE_KEY:
+                        self.snooze_alarm()
+                        sleep(SNOOZE_SEC)
+                        self.sound_alarm()
+                        break
 
 
 if __name__ == '__main__':
-    alarm_clock = BaseAlarmClock(ALARM_TIME)
-    simple_alarm_mode(alarm_clock)
+    alarm_clock = SimpleAlarmClock(ALARM_TIME)
+    alarm_clock.simple_alarm_mode()

smart_alarm_clock.py

+from typing import Optional
+
 from alarm import BaseAlarmClock, AlarmState
 from datetime import time, datetime
 from time import sleep
 from pynput import keyboard
-import vlc
+import numpy as np
\ No newline at end of file
+import vlc
+
+
+SNOOZE_KEY = keyboard.Key.up
+ALARM_OFF_KEY = keyboard.Key.esc
+SNOOZE_SEC = 5
+
+
+def softmax(arr):
+    val = np.exp(arr)
+    return val / sum(val)
+
+
+class SmartAlarmClock(BaseAlarmClock):
+
+    def __init__(self, wake_time: Optional[time] = None, vlc_player=None):
+        if wake_time:
+            self.set_alarm(wake_time)
+        super().__init__()
+
+    def set_alarm(self, wake_time: time) -> time:
+        print(f"SETTING ALARM to: {wake_time}")
+        return super(SmartAlarmClock, self).set_alarm(wake_time)
+
+    def start_alarm(self) -> None:
+        print("STARTING ALARM")
+        super(SmartAlarmClock, self).start_alarm()
+
+    def sound_alarm(self) -> None:
+        print("SOUNDING ALARM")
+        super(SmartAlarmClock, self).sound_alarm()
+
+    def snooze_alarm(self) -> None:
+        print("SNOOZING ALARM")
+        super(SmartAlarmClock, self).snooze_alarm()
+
+    def stop_alarm(self, deactivate: bool = True) -> None:
+        print("STOPPING ALARM")
+        if self._current_state is AlarmState.PLAYING:
+            print("STOPPED PLAYING ALARM")
+        super(SmartAlarmClock, self).stop_alarm()
+
+    def smart_alarm_mode(self, model):
+        self.start_alarm()
+        while not self.alarm_check_reached(datetime.now().time()):
+            print(f"ALARM SLEEPING @: {datetime.now().time()}")
+            sleep(1)
+        self.sound_alarm()
+        while self.current_state is not AlarmState.DEACTIVATED:
+            with keyboard.Events() as events:
+                for event in events:
+                    if event.key == ALARM_OFF_KEY:
+                        self.stop_alarm()
+                        break
+                    elif event.key == SNOOZE_KEY:
+                        self.snooze_alarm()
+                        sleep(SNOOZE_SEC)
+                        self.sound_alarm()
+                        break
+
+
+if __name__ == '__main__':
+    alarm_hour = int(input("What hour do you want the alarm to go off at?"))
+    alarm_minute = int(input("What minute do you want the alarm to go off at?"))
+    alarm_second = int(input("What second do you want the alarm to go off at?"))
+    alarm_time = time(alarm_hour, alarm_minute, alarm_second)
+    alarm_clock_class = SmartAlarmClock(alarm_time)
+    ai_model = None
+    alarm_clock_class.smart_alarm_mode(ai_model)