Python3 version:

- clean date ranges functions, make sure a timestamp range limit is an integer

Author: mohierf

alignak/daterange.py

@@ -55,12 +55,87 @@
 import re
 from datetime import datetime, timedelta
 
-from alignak.util import get_sec_from_morning, get_day, get_start_of_day, get_end_of_day
 from alignak.alignakobject import AlignakObject
 
 logger = logging.getLogger(__name__)  # pylint: disable=invalid-name
 
 
+def get_start_of_day(year, month, day):
+    """Get the timestamp associated to the first second of a specific day
+
+    :param year: date year
+    :type year: int
+    :param month: date month
+    :type month: int
+    :param day: date day
+    :type day: int
+    :return: timestamp
+    :rtype: int
+    """
+    # DST is not known in the provided date
+    try:
+        timestamp = time.mktime((year, month, day, 00, 00, 00, 0, 0, -1))
+    except (OverflowError, ValueError):
+        # Windows mktime sometimes crashes on (1970, 1, 1, ...)
+        timestamp = 0.0
+
+    return int(timestamp)
+
+
+def get_end_of_day(year, month, day):
+    """Get the timestamp associated to the last second of a specific day
+
+    :param year: date year
+    :type year: int
+    :param month: date month (int)
+    :type month: int
+    :param day: date day
+    :type day: int
+    :return: timestamp
+    :rtype: int
+    """
+    # DST is not known in the provided date
+    timestamp = time.mktime((year, month, day, 23, 59, 59, 0, 0, -1))
+    return int(timestamp)
+
+
+def get_day(timestamp):
+    """Get timestamp of the beginning of the day (local) given by timestamp
+
+    :param timestamp: time to get day from
+    :type timestamp: int
+    :return: timestamp
+    :rtype: int
+    """
+    return int(timestamp - get_sec_from_morning(timestamp))
+
+
+def get_wday(timestamp):
+    """Get week day from date
+
+    :param timestamp: timestamp date
+    :type timestamp: int
+    :return: weekday (0-6)
+    :rtype: int
+    TODO: Not timezone aware
+    """
+    t_lt = time.localtime(timestamp)
+    return t_lt.tm_wday
+
+
+def get_sec_from_morning(timestamp):
+    """Get the number of seconds elapsed since the beginning of the
+    day deducted from the provided timestamp
+
+    :param timestamp: time to use for computation
+    :type timestamp: int
+    :return: timestamp
+    :rtype: int
+    """
+    t_lt = time.localtime(timestamp)
+    return t_lt.tm_hour * 3600 + t_lt.tm_min * 60 + t_lt.tm_sec
+
+
 def find_day_by_weekday_offset(year, month, weekday, offset):
     """Get the day number based on a date and offset
 
@@ -302,7 +377,6 @@ def get_start_and_end_time(self, ref=None):  # pylint: disable=unused-argument,n
         :type ref: int
         :return: None
         """
-        logger.warning("Calling function get_start_and_end_time which is not implemented")
         raise NotImplementedError()
 
     def is_time_valid(self, timestamp):
@@ -375,13 +449,8 @@ def is_time_day_invalid(self, timestamp):
         :type timestamp: int
         :return: False if t in range, True otherwise
         :rtype: bool
-        TODO: Remove this function. Duplication
         """
-        (start_time, end_time) = self.get_start_and_end_time(timestamp)
-        if start_time <= timestamp <= end_time:
-            return False
-
-        return True
+        return not self.is_time_day_valid(timestamp)
 
     def get_next_future_timerange_valid(self, timestamp):
         """Get the next valid timerange (next timerange start in timeranges attribute)
@@ -665,11 +734,10 @@ def get_start_and_end_time(self, ref=None):
         :param ref: time in seconds
         :type ref: int
         :return: tuple with start and end time
-        :rtype: tuple
+        :rtype: tuple (int, int)
         """
-        start_time = get_start_of_day(self.syear, int(self.smon), self.smday)
-        end_time = get_end_of_day(self.eyear, int(self.emon), self.emday)
-        return (start_time, end_time)
+        return (get_start_of_day(self.syear, int(self.smon), self.smday),
+                get_end_of_day(self.eyear, int(self.emon), self.emday))
 
 
 class StandardDaterange(AbstractDaterange):
@@ -732,7 +800,7 @@ def get_start_and_end_time(self, ref=None):
         :param ref: time in seconds
         :type ref: int
         :return: tuple with start and end time
-        :rtype: tuple
+        :rtype: tuple (int, int)
         """
         now = time.localtime(ref)
         self.syear = now.tm_year
@@ -744,7 +812,7 @@ def get_start_and_end_time(self, ref=None):
         day_diff = (day_id - now.tm_wday) % 7
         morning = datetime.fromtimestamp(today_morning) + timedelta(days=day_diff)
         night = datetime.fromtimestamp(tonight) + timedelta(days=day_diff)
-        return (float(morning.strftime("%s")), float(night.strftime("%s")))
+        return (int(morning.strftime("%s")), int(night.strftime("%s")))
 
 
 class MonthWeekDayDaterange(Daterange):
@@ -823,7 +891,7 @@ def get_start_and_end_time(self, ref=None):
         :param ref: time in seconds
         :type ref: int
         :return: tuple with start and end time
-        :rtype: tuple
+        :rtype: tuple (int, int)
         """
         now = time.localtime(ref)
         if self.syear == 0:
@@ -867,7 +935,7 @@ def get_start_and_end_time(self, ref=None):
         :param ref: time in seconds
         :type ref: int
         :return: tuple with start and end time
-        :rtype: tuple
+        :rtype: tuple (int, int)
         """
         now = time.localtime(ref)
 
@@ -931,7 +999,7 @@ def get_start_and_end_time(self, ref=None):
         :param ref: time in seconds
         :type ref: int
         :return: tuple with start and end time
-        :rtype: tuple
+        :rtype: tuple (int, int)
         """
         now = time.localtime(ref)
         if self.syear == 0:

alignak/objects/schedulingitem.py

@@ -958,10 +958,10 @@ def is_enable_action_dependent(self, hosts, services):
         :rtype: bool
         """
         # Use to know if notification is raise or not
-        enable_notif = False
+        enable_action = False
         for (dep_id, status, _, _) in self.act_depend_of:
             if 'n' in status:
-                enable_notif = True
+                enable_action = True
             else:
                 if dep_id in hosts:
                     dep = hosts[dep_id]
@@ -973,8 +973,8 @@ def is_enable_action_dependent(self, hosts, services):
                 if True in dep_match:
                     p_is_down = True
                 if not p_is_down:
-                    enable_notif = True
-        return enable_notif
+                    enable_action = True
+        return enable_action
 
     def check_and_set_unreachability(self, hosts, services):
         """

alignak/util.py

@@ -227,86 +227,6 @@ def jsonify_r(obj):  # pragma: no cover, not for unit tests...
 
 
 # ################################## TIME ##################################
-def get_end_of_day(year, month_id, day):
-    """Get the timestamp of the end (local) of a specific day
-
-    :param year: date year
-    :type year: int
-    :param month_id: date month (int)
-    :type month_id: int
-    :param day: date day
-    :type day: int
-    :return: timestamp
-    :rtype: int
-    TODO: Not timezone aware
-    """
-    end_time = (year, month_id, day, 23, 59, 59, 0, 0, -1)
-    end_time_epoch = time.mktime(end_time)
-    return end_time_epoch
-
-
-def get_day(timestamp):
-    """Get timestamp of the beginning of the day (local) given by timestamp
-
-    :param timestamp: time to get day from
-    :type timestamp: int
-    :return: timestamp
-    :rtype: int
-    TODO: Not timezone aware
-    """
-    return int(timestamp - get_sec_from_morning(timestamp))
-
-
-def get_wday(timestamp):
-    """Get week day from date
-
-    :param timestamp: timestamp date
-    :type timestamp: int
-    :return: weekday (0-6)
-    :rtype: int
-    TODO: Not timezone aware
-    """
-    t_lt = time.localtime(timestamp)
-    return t_lt.tm_wday
-
-
-def get_sec_from_morning(timestamp):
-    """Get the numbers of seconds elapsed since the beginning of the day (local) given by timestamp
-
-    :param timestamp: time to get amount of second from
-    :type timestamp: int
-    :return: timestamp
-    :rtype: int
-    TODO: Not timezone aware
-    """
-    t_lt = time.localtime(timestamp)
-    return t_lt.tm_hour * 3600 + t_lt.tm_min * 60 + t_lt.tm_sec
-
-
-def get_start_of_day(year, month_id, day):
-    """Get the timestamp of the beginning (local) of a specific day
-
-    :param year: date year
-    :type year: int
-    :param month_id: date month (int)
-    :type month_id: int
-    :param day: date day
-    :type day: int
-    :return: timestamp
-    :rtype: float
-    TODO: Not timezone aware
-    """
-    # DST is not known
-    start_time = (year, month_id, day, 00, 00, 00, 0, 0, -1)
-    try:
-        start_time_epoch = time.mktime(start_time)
-    except OverflowError:
-        # Windows mktime sometimes crashes on (1970, 1, 1, ...)
-        start_time_epoch = 0.0
-
-    return start_time_epoch
-
-
 def format_t_into_dhms_format(timestamp):
     """ Convert an amount of second into day, hour, min and sec
 

test/test_dateranges.py

@@ -19,9 +19,10 @@
 # along with Alignak.  If not, see <http://www.gnu.org/licenses/>.
 
 """
-This file is used to test dateranges
+This file is used to test the date ranges management
 
-We make timestamp with time.mktime because timestamp not same is you are in timezone UTC or Paris
+We make timestamp with time.mktime because the timestamp is not the same
+dependening upon the timezone
 """
 # pylint: disable=R0904
 
@@ -50,7 +51,7 @@ def test_get_start_of_day(self):
         """
         now = time.localtime()
         start = time.mktime((2015, 7, 26, 0, 0, 0, 0, 0, now.tm_isdst))
-        timestamp = alignak.util.get_start_of_day(2015, 7, 26)
+        timestamp = alignak.daterange.get_start_of_day(2015, 7, 26)
         # time.timezone is the offset related of the current timezone of the system
         print("Start: %s, timestamp: %s" % (start, timestamp))
         if start != timestamp:
@@ -69,7 +70,7 @@ def test_get_start_of_day_tz_aware(self):
         start = time.mktime((now.tm_year, now.tm_mon, now.tm_mday, 0, 0, 0, 0, 0, -1))
         print("Start: %s" % start)
         # Alignak returns the start of day ts in local time
-        timestamp = alignak.util.get_start_of_day(now.tm_year, now.tm_mon, now.tm_mday)
+        timestamp = alignak.daterange.get_start_of_day(now.tm_year, now.tm_mon, now.tm_mday)
         print("Timestamp: %s" % timestamp)
         # time.timezone is the offset related of the current timezone of the system
         if start != timestamp:
@@ -82,7 +83,7 @@ def test_get_end_of_day(self):
         """
         now = time.localtime()
         start = time.mktime((2016, 8, 20, 23, 59, 59, 0, 0, now.tm_isdst))
-        timestamp = alignak.util.get_end_of_day(2016, 8, 20)
+        timestamp = alignak.daterange.get_end_of_day(2016, 8, 20)
         print("Start: %s, timestamp: %s" % (start, timestamp))
         # time.timezone is the offset related of the current timezone of the system
         if start != timestamp:
@@ -182,10 +183,14 @@ def test_standarddaterange_start_end_time(self):
         caldate = StandardDaterange({'day': 'friday', 'other': '00:00-24:00'})
         for date_now in data:
             with freeze_time(date_now, tz_offset=0):
-                ret = caldate.get_start_and_end_time()
-                print("* %s" % date_now)
-                assert data[date_now]['start'] == ret[0]
-                assert data[date_now]['end'] == ret[1]
+                # ret = caldate.get_start_and_end_time()
+                # print("* %s" % date_now)
+                # assert data[date_now]['start'] == ret[0]
+                # assert data[date_now]['end'] == ret[1]
+                start, end = caldate.get_start_and_end_time()
+                print("-> res: %s (%s) - %s (%s)" % (start, type(start), end, type(end)))
+                assert data[date_now]['start'] == start
+                assert data[date_now]['end'] == end
 
     def test_monthweekdaydaterange_start_end_time(self):
         """ Test MonthWeekDayDaterange.get_start_and_end_time to get start and end date of date range
@@ -242,6 +247,7 @@ def test_monthdatedaterange_start_end_time(self):
             local_hour_offset = "-%02d" % local_hour_offset
         else:
             local_hour_offset = "+%02d" % -local_hour_offset
+
         data = {
             '2015-07-20 01:50:00 %s' % local_hour_offset: {
                 'start': 1437868800 + local_offset,
@@ -266,12 +272,18 @@ def test_monthdatedaterange_start_end_time(self):
         caldate = MonthDateDaterange(params)
         for date_now in data:
             with freeze_time(date_now, tz_offset=0):
-                print("Date: %s" % date_now)
-                ret = caldate.get_start_and_end_time()
-                print("* %s / %s" % (type(ret[0]), type(data[date_now]['start'])))
-                print("* %s / %s" % (int(ret[0]), int(ret[1])))
-                assert data[date_now]['start'] == int(ret[0])
-                assert data[date_now]['end'] == int(ret[1])
+                print("Date: %s: %s" % (date_now, data[date_now]))
+                start, end = caldate.get_start_and_end_time()
+                print("-> res: %s (%s) - %s (%s)" % (start, type(start), end, type(end)))
+                assert data[date_now]['start'] == start
+                assert data[date_now]['end'] == end
+
+                # ret = caldate.get_start_and_end_time()
+                # print("-> res: %s" % ret)
+                # print("* %s / %s" % (type(ret[0]), type(ret[1])))
+                # print("* %s / %s" % (int(ret[0]), int(ret[1])))
+                # assert data[date_now]['start'] == int(ret[0])
+                # assert data[date_now]['end'] == int(ret[1])
 
     def test_weekdaydaterange_start_end_time(self):
         """ Test WeekDayDaterange.get_start_and_end_time to get start and end date of date range