148 lines
3.7 KiB
Python
148 lines
3.7 KiB
Python
import time
|
|
import threading
|
|
from text2numde import text2num, is_number, sentence2num
|
|
from playsound3 import playsound
|
|
from datetime import datetime, timedelta
|
|
import re
|
|
import math
|
|
|
|
wecker_thread = None
|
|
wecker_stop = threading.Event()
|
|
wecker_status = "idle"
|
|
wecker_target_time: datetime | None = None
|
|
|
|
|
|
def parse_time_wecker(text):
|
|
|
|
text = text.lower().strip()
|
|
|
|
match = re.search(r"\b([\w]+)\s*uhr(?:\s*([\w]+))?\b", text)
|
|
if not match:
|
|
return None
|
|
|
|
hour_text = match.group(1)
|
|
minute_text= match.group(2)
|
|
|
|
|
|
try:
|
|
hour = text2num(hour_text)
|
|
minute = text2num(minute_text) if minute_text else 0
|
|
except ValueError:
|
|
print("Konnte die Zahl nicht erkennen.")
|
|
return None
|
|
|
|
if hour < 0 or hour > 23:
|
|
return None
|
|
if minute < 0 or minute > 59:
|
|
return None
|
|
|
|
print(f"{hour:02d}:{minute:02d}")
|
|
return hour, minute
|
|
|
|
def calculate_target_datetime(hour: int, minute: int) -> datetime:
|
|
now = datetime.now()
|
|
|
|
target = now.replace(hour=hour, minute=minute, second=0, microsecond=0)
|
|
|
|
if target <= now:
|
|
target += timedelta(days=1)
|
|
|
|
return target
|
|
|
|
|
|
def minutes_until(target: datetime) -> int:
|
|
#return int(((target - now)).total_seconds() // 60) hatte das davor aber das hat abgerundet
|
|
seconds = (target - datetime.now()).total_seconds()
|
|
return math.ceil(seconds / 60)
|
|
|
|
|
|
def start_wecker(target_time: datetime):
|
|
global wecker_thread, wecker_status, wecker_target_time
|
|
|
|
if wecker_status == "running":
|
|
return False # wecker läuft bereits
|
|
|
|
wecker_stop.clear()
|
|
wecker_target_time = target_time
|
|
wecker_status = "running"
|
|
|
|
def run():
|
|
global wecker_status
|
|
seconds = (wecker_target_time - datetime.now()).total_seconds()
|
|
if seconds < 0:
|
|
seconds = 0
|
|
|
|
if not wecker_stop.wait(seconds):
|
|
wecker_status = "finished"
|
|
print("wecker abgelaufen") # """ TTS """
|
|
|
|
wecker_thread = threading.Thread(target=run, daemon=True)
|
|
wecker_thread.start()
|
|
return True
|
|
"""
|
|
print(f"wecker startet für {seconds} Sekunden...")
|
|
time.sleep(seconds)
|
|
print("wecker abgelaufen!")
|
|
playsound("/home/tino/Desktop/Abschlussprojekt/test assistant/cloneAssistantAllInOne/RasPi_Voice_Assistant--WIP/clock-alarm-8761.mp3")
|
|
sound.stop()
|
|
"""
|
|
|
|
""" # Beispielnutzung
|
|
spoken_input = "eine sekunde" # This could come from a voice assistant
|
|
seconds = parse_time(spoken_input)
|
|
if seconds:
|
|
start_wecker(seconds) """
|
|
|
|
def stop_wecker():
|
|
global wecker_status
|
|
if wecker_status != "running":
|
|
print("Kein wecker gestellt")
|
|
return False
|
|
|
|
wecker_stop.set()
|
|
wecker_status = "stopped"
|
|
return True
|
|
|
|
def wecker_status_info():
|
|
if wecker_status != "running":
|
|
return {"status": wecker_status, "target_time": 0}
|
|
|
|
|
|
return {
|
|
"status": "running",
|
|
"target_time": wecker_target_time
|
|
}
|
|
|
|
def format_duration(seconds):
|
|
if seconds < 60:
|
|
return f"{seconds} {second_text(seconds)}"
|
|
|
|
minutes = seconds // 60
|
|
secs = seconds % 60
|
|
|
|
if minutes < 10:
|
|
if secs == 0:
|
|
return f"{minutes} {minute_text(minutes)}"
|
|
return f"{minutes} {minute_text(minutes)} und {secs} {second_text(secs)}"
|
|
|
|
if minutes < 60:
|
|
return f"{minutes} {minute_text(minutes)}"
|
|
|
|
hours = minutes // 60
|
|
mins = minutes % 60
|
|
|
|
if mins == 0:
|
|
return f"{hours} {hour_text(hours)}"
|
|
return f"{hours} {hour_text(hours)} und {mins} {minute_text(mins)}"
|
|
|
|
|
|
|
|
def minute_text(n):
|
|
return "Minute" if n == 1 else "Minuten"
|
|
|
|
def second_text(n):
|
|
return "Sekunde" if n == 1 else "Sekunden"
|
|
|
|
def hour_text(n):
|
|
return "Stunde" if n == 1 else "Stunden"
|