revert import change

packages/helpermodules/timecheck.py

@@ -2,7 +2,7 @@
 """
 import copy
 import logging
-from datetime import datetime, timedelta
+import datetime
 from dateutil.relativedelta import relativedelta
 from typing import Dict, List, Optional, Tuple, TypeVar, Union
 
@@ -11,9 +11,9 @@
 log = logging.getLogger(__name__)
 
 
-def is_now_in_locking_time(now: datetime,
-                           lock: datetime,
-                           unlock: datetime) -> bool:
+def is_now_in_locking_time(now: datetime.datetime,
+                           lock: datetime.datetime,
+                           unlock: datetime.datetime) -> bool:
     # Es gibt nur einen Entsperrzeitpunkt.
     if lock is None:
         if now < unlock:
@@ -64,19 +64,19 @@ def check_plans_timeframe(plans: Dict[int, T]) -> Optional[T]:
 def check_timeframe(plan: Union[AutolockPlan, TimeChargingPlan]) -> bool:
     """ Returns: True -> Zeitfenster gültig, False -> Zeitfenster nicht gültig
     """
-    def is_timeframe_valid(now: datetime, begin: datetime, end: datetime) -> bool:
+    def is_timeframe_valid(now: datetime.datetime, begin: datetime.datetime, end: datetime.datetime) -> bool:
         return True if (not now < begin) and now < end else False
 
     state = False
     try:
-        now = datetime.today()
-        begin = datetime.strptime(plan.time[0], '%H:%M')
-        end = datetime.strptime(plan.time[1], '%H:%M')
+        now = datetime.datetime.today()
+        begin = datetime.datetime.strptime(plan.time[0], '%H:%M')
+        end = datetime.datetime.strptime(plan.time[1], '%H:%M')
 
         if plan.frequency.selected == "once":
-            beginDate = datetime.strptime(plan.frequency.once[0], "%Y-%m-%d")
+            beginDate = datetime.datetime.strptime(plan.frequency.once[0], "%Y-%m-%d")
             begin = begin.replace(beginDate.year, beginDate.month, beginDate.day)
-            endDate = datetime.strptime(plan.frequency.once[1], "%Y-%m-%d")
+            endDate = datetime.datetime.strptime(plan.frequency.once[1], "%Y-%m-%d")
             end = end.replace(endDate.year, endDate.month, endDate.day)
             state = is_timeframe_valid(now, begin, end)
 
@@ -108,10 +108,10 @@ def is_timeframe_valid(now: datetime, begin: datetime, end: datetime) -> bool:
         return state
 
 
-def _calc_begin(end: datetime, hours: int) -> datetime:
+def _calc_begin(end: datetime.datetime, hours: int) -> datetime.datetime:
     """ berechnet den Zeitpunkt, der die angegebenen Stunden vor dem Endzeitpunkt liegt.
     """
-    prev = timedelta(hours)
+    prev = datetime.timedelta(hours)
     return end - prev
 
 
@@ -126,11 +126,11 @@ def check_duration(plan: ScheduledChargingPlan, duration: float, buffer: int) ->
     pos: verbleibende Sekunden
     """
 
-    now = datetime.today()
-    end = datetime.strptime(plan.time, '%H:%M')
+    now = datetime.datetime.today()
+    end = datetime.datetime.strptime(plan.time, '%H:%M')
     remaining_time = None
     if plan.frequency.selected == "once":
-        endDate = datetime.strptime(plan.frequency.once, "%Y-%m-%d")
+        endDate = datetime.datetime.strptime(plan.frequency.once, "%Y-%m-%d")
         end = end.replace(endDate.year, endDate.month, endDate.day)
         remaining_time = _get_remaining_time(now, duration, end)
     elif plan.frequency.selected == "daily":
@@ -160,33 +160,33 @@ def _get_next_charging_day(weekly_temp: List[bool], weekday: int) -> int:
         return 7
 
 
-def _missed_date_today(now: datetime,
-                       end: datetime,
+def _missed_date_today(now: datetime.datetime,
+                       end: datetime.datetime,
                        buffer: float):
-    return end < now + timedelta(seconds=buffer)
+    return end < now + datetime.timedelta(seconds=buffer)
 
 
-def check_following_days(now: datetime,
+def check_following_days(now: datetime.datetime,
                          duration: float,
-                         end: datetime,
+                         end: datetime.datetime,
                          remaining_time_today: Optional[float],
                          buffer: float,
-                         num_of_following_days: int = 1) -> Tuple[Optional[float], datetime]:
+                         num_of_following_days: int = 1) -> Tuple[Optional[float], datetime.datetime]:
     # Zeitpunkt heute darf noch nicht verstrichen sein
     if remaining_time_today and not _missed_date_today(now, end, buffer):
         return remaining_time_today, end
-    end = end+timedelta(days=num_of_following_days)
+    end = end+datetime.timedelta(days=num_of_following_days)
     remaining_time = _get_remaining_time(now, duration, end)
     return remaining_time, end
 
 
-def _get_remaining_time(now: datetime, duration: float, end: datetime) -> float:
+def _get_remaining_time(now: datetime.datetime, duration: float, end: datetime.datetime) -> float:
     """ Return
     ------
     neg: Zeitpunkt vorbei
     pos: verbleibende Sekunden
     """
-    delta = timedelta(hours=int(duration), minutes=((duration % 1) * 60))
+    delta = datetime.timedelta(hours=int(duration), minutes=((duration % 1) * 60))
     start_time = end-delta
     return (start_time-now).total_seconds()
 
@@ -205,9 +205,9 @@ def is_list_valid(hour_list: List[int]) -> bool:
     False: aktuelle Stunde ist nicht in der Liste enthalten
     """
     try:
-        now = datetime.today()
+        now = datetime.datetime.today()
         for hour in hour_list:
-            timestamp = datetime.fromtimestamp(float(hour))
+            timestamp = datetime.datetime.fromtimestamp(float(hour))
             if timestamp.hour == now.hour:
                 return True
             else:
@@ -234,9 +234,9 @@ def check_timestamp(timestamp: str, duration: int) -> bool:
     True: Zeit ist noch nicht abgelaufen
     False: Zeit ist abgelaufen
     """
-    stamp = datetime.strptime(timestamp, "%m/%d/%Y, %H:%M:%S")
-    now = datetime.today()
-    delta = timedelta(seconds=duration)
+    stamp = datetime.datetime.strptime(timestamp, "%m/%d/%Y, %H:%M:%S")
+    now = datetime.datetime.today()
+    delta = datetime.timedelta(seconds=duration)
     if (now - delta) > stamp:
         return False
     else:
@@ -245,7 +245,7 @@ def check_timestamp(timestamp: str, duration: int) -> bool:
 
 def create_timestamp() -> str:
     try:
-        stamp = datetime.today().strftime("%m/%d/%Y, %H:%M:%S")
+        stamp = datetime.datetime.today().strftime("%m/%d/%Y, %H:%M:%S")
         return stamp
     except Exception:
         raise
@@ -255,42 +255,42 @@ def create_timestamp_unix() -> int:
     """ Unix Zeitstempel
     """
     try:
-        return int(datetime.now().timestamp())
+        return int(datetime.datetime.now().timestamp())
     except Exception:
         raise
 
 
 def create_timestamp_YYYYMM() -> str:
     try:
-        stamp = datetime.today().strftime("%Y%m")
+        stamp = datetime.datetime.today().strftime("%Y%m")
         return stamp
     except Exception:
         raise
 
 
 def create_timestamp_YYYYMMDD() -> str:
     try:
-        stamp = datetime.today().strftime("%Y%m%d")
+        stamp = datetime.datetime.today().strftime("%Y%m%d")
         return stamp
     except Exception:
         raise
 
 
 def create_timestamp_time() -> str:
     try:
-        stamp = datetime.today().strftime("%H:%M")
+        stamp = datetime.datetime.today().strftime("%H:%M")
         return stamp
     except Exception:
         raise
 
 
 def convert_to_unix_timestamp(timestamp: str) -> float:
-    return datetime.strptime(timestamp, "%m/%d/%Y, %H:%M:%S").timestamp()
+    return datetime.datetime.strptime(timestamp, "%m/%d/%Y, %H:%M:%S").timestamp()
 
 
 def get_relative_date_string(date_string: str, day_offset: int = 0, month_offset: int = 0, year_offset: int = 0) -> str:
     print_format = "%Y%m%d" if len(date_string) > 6 else "%Y%m"
-    my_date = datetime.strptime(date_string, print_format)
+    my_date = datetime.datetime.strptime(date_string, print_format)
     return (my_date + relativedelta(years=year_offset, months=month_offset, days=day_offset)).strftime(print_format)
 
 
@@ -309,8 +309,8 @@ def get_difference_to_now(timestamp_begin: str) -> Tuple[str, int]:
         int: Differenz in Sekunden
     """
     try:
-        begin = datetime.strptime(timestamp_begin[:-3], "%m/%d/%Y, %H:%M")
-        now = datetime.today()
+        begin = datetime.datetime.strptime(timestamp_begin[:-3], "%m/%d/%Y, %H:%M")
+        now = datetime.datetime.today()
         diff = (now - begin)
         return [__convert_timedelta_to_time_string(diff), int(diff.total_seconds())]
     except Exception:
@@ -334,8 +334,8 @@ def get_difference(timestamp_begin: str, timestamp_end: str) -> Optional[int]:
         Differenz in Sekunden
     """
     try:
-        begin = datetime.strptime(timestamp_begin, "%m/%d/%Y, %H:%M:%S")
-        end = datetime.strptime(timestamp_end, "%m/%d/%Y, %H:%M:%S")
+        begin = datetime.datetime.strptime(timestamp_begin, "%m/%d/%Y, %H:%M:%S")
+        end = datetime.datetime.strptime(timestamp_end, "%m/%d/%Y, %H:%M:%S")
         diff = (begin - end)
         return int(diff.total_seconds())
     except Exception:
@@ -363,7 +363,7 @@ def duration_sum(first: str, second: str) -> str:
         return "00:00"
 
 
-def __get_timedelta_obj(time: str) -> timedelta:
+def __get_timedelta_obj(time: str) -> datetime.timedelta:
     """ erstellt aus einem String ein timedelta-Objekt.
 
     Parameter
@@ -373,18 +373,18 @@ def __get_timedelta_obj(time: str) -> timedelta:
     """
     time_charged = time.split(":")
     if len(time_charged) == 2:
-        delta = timedelta(hours=int(time_charged[0]),
-                          minutes=int(time_charged[1]))
+        delta = datetime.timedelta(hours=int(time_charged[0]),
+                                   minutes=int(time_charged[1]))
     elif len(time_charged) == 3:
-        delta = timedelta(days=int(time_charged[0]),
-                          hours=int(time_charged[1]),
-                          minutes=int(time_charged[2]))
+        delta = datetime.timedelta(days=int(time_charged[0]),
+                                   hours=int(time_charged[1]),
+                                   minutes=int(time_charged[2]))
     else:
         raise Exception("Unknown charge duration: "+time)
     return delta
 
 
-def __convert_timedelta_to_time_string(timedelta_obj: timedelta) -> str:
+def __convert_timedelta_to_time_string(timedelta_obj: datetime.timedelta) -> str:
     diff_hours = int(timedelta_obj.total_seconds() / 3600)
     diff_minutes = int((timedelta_obj.total_seconds() % 3600) / 60)
     return f"{diff_hours}:{diff_minutes:02d}"