DateTime.py

Go to the documentation of this file.

#  Copyright 2008-2015 Nokia Networks
#  Copyright 2016-     Robot Framework Foundation
#
#  Licensed under the Apache License, Version 2.0 (the "License");
#  you may not use this file except in compliance with the License.
#  You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
#  Unless required by applicable law or agreed to in writing, software
#  distributed under the License is distributed on an "AS IS" BASIS,
#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#  See the License for the specific language governing permissions and
#  limitations under the License.
 
 
 
from __future__ import absolute_import
 
from datetime import datetime, timedelta
import time
import re
 
from robotide.lib.robot.version import get_version
from robotide.lib.robot.utils import (elapsed_time_to_string, is_falsy, is_number,
                         is_string, roundup, secs_to_timestr, timestr_to_secs,
                         type_name, IRONPYTHON)
 
__version__ = get_version()
__all__ = ['convert_time', 'convert_date', 'subtract_date_from_date',
           'subtract_time_from_date', 'subtract_time_from_time',
           'add_time_to_time', 'add_time_to_date', 'get_current_date']
 
 
 
def get_current_date(time_zone='local', increment=0,
                     result_format='timestamp', exclude_millis=False):
    if time_zone.upper() == 'LOCAL':
        dt = datetime.now()
    elif time_zone.upper() == 'UTC':
        dt = datetime.utcnow()
    else:
        raise ValueError("Unsupported timezone '%s'." % time_zone)
    date = Date(dt) + Time(increment)
    return date.convert(result_format, millis=is_falsy(exclude_millis))
 
 
 
def convert_date(date, result_format='timestamp', exclude_millis=False,
                 date_format=None):
    return Date(date, date_format).convert(result_format,
                                           millis=is_falsy(exclude_millis))
 
 
 
def convert_time(time, result_format='number', exclude_millis=False):
    return Time(time).convert(result_format, millis=is_falsy(exclude_millis))
 
 
 
def subtract_date_from_date(date1, date2, result_format='number',
                            exclude_millis=False, date1_format=None,
                            date2_format=None):
    time = Date(date1, date1_format) - Date(date2, date2_format)
    return time.convert(result_format, millis=is_falsy(exclude_millis))
 
 
 
def add_time_to_date(date, time, result_format='timestamp',
                     exclude_millis=False, date_format=None):
    date = Date(date, date_format) + Time(time)
    return date.convert(result_format, millis=is_falsy(exclude_millis))
 
 
 
def subtract_time_from_date(date, time, result_format='timestamp',
                            exclude_millis=False, date_format=None):
    date = Date(date, date_format) - Time(time)
    return date.convert(result_format, millis=is_falsy(exclude_millis))
 
 
 
def add_time_to_time(time1, time2, result_format='number',
                     exclude_millis=False):
    time = Time(time1) + Time(time2)
    return time.convert(result_format, millis=is_falsy(exclude_millis))
 
 
 
def subtract_time_from_time(time1, time2, result_format='number',
                            exclude_millis=False):
    time = Time(time1) - Time(time2)
    return time.convert(result_format, millis=is_falsy(exclude_millis))
 
 
class Date():
 
    def __init__(self, date, input_format=None):
        self.datetimedatetime = self._convert_to_datetime_convert_to_datetime(date, input_format)
 
    @property
    seconds = property
    
    def seconds(self):
        # Mainly for backwards compatibility with RF 2.9.1 and earlier.
        return self._convert_to_epoch_convert_to_epoch(self.datetimedatetime)
 
    def _convert_to_datetime(self, date, input_format):
        if isinstance(date, datetime):
            return date
        if is_number(date):
            return self._seconds_to_datetime_seconds_to_datetime(date)
        if is_string(date):
            return self._string_to_datetime_string_to_datetime(date, input_format)
        raise ValueError("Unsupported input '%s'." % date)
 
    def _seconds_to_datetime(self, secs):
        # Workaround microsecond rounding errors with IronPython:
        # https://github.com/IronLanguages/main/issues/1170
        # Also Jython had similar problems, but they seem to be fixed in 2.7.
        dt = datetime.fromtimestamp(secs)
        return dt.replace(microsecond=roundup(secs % 1 * 1e6))
 
    def _string_to_datetime(self, ts, input_format):
        if not input_format:
            ts = self._normalize_timestamp_normalize_timestamp(ts)
            input_format = '%Y-%m-%d %H:%M:%S.%f'
        if self._need_to_handle_f_directive_need_to_handle_f_directive(input_format):
            return self._handle_un_supported_f_directive_handle_un_supported_f_directive(ts, input_format)
        return datetime.strptime(ts, input_format)
 
    def _normalize_timestamp(self, date):
        ts = ''.join(d for d in date if d.isdigit())
        if not (8 <= len(ts) <= 20):
            raise ValueError("Invalid timestamp '%s'." % date)
        ts = ts.ljust(20, '0')
        return '%s-%s-%s %s:%s:%s.%s' % (ts[:4], ts[4:6], ts[6:8], ts[8:10],
                                         ts[10:12], ts[12:14], ts[14:])
 
    def _need_to_handle_f_directive(self, format):
        # https://github.com/IronLanguages/main/issues/1169
        return IRONPYTHON and '%f' in format
 
    def _handle_un_supported_f_directive(self, ts, input_format):
        input_format = self._remove_f_from_format_remove_f_from_format(input_format)
        match = re.search('\d+$', ts)
        if not match:
            raise ValueError("time data '%s' does not match format '%s%%f'."
                             % (ts, input_format))
        end_digits = match.group(0)
        micro = int(end_digits.ljust(6, '0'))
        dt = datetime.strptime(ts[:-len(end_digits)], input_format)
        return dt.replace(microsecond=micro)
 
    def _remove_f_from_format(self, format):
        if not format.endswith('%f'):
            raise ValueError('%f directive is supported only at the end of '
                             'the format string on this Python interpreter.')
        return format[:-2]
 
    def convert(self, format, millis=True):
        dt = self.datetimedatetime
        if not millis:
            secs = 1 if dt.microsecond >= 5e5 else 0
            dt = dt.replace(microsecond=0) + timedelta(seconds=secs)
        if '%' in format:
            return self._convert_to_custom_timestamp_convert_to_custom_timestamp(dt, format)
        format = format.lower()
        if format == 'timestamp':
            return self._convert_to_timestamp_convert_to_timestamp(dt, millis)
        if format == 'datetime':
            return dt
        if format == 'epoch':
            return self._convert_to_epoch_convert_to_epoch(dt)
        raise ValueError("Unknown format '%s'." % format)
 
    def _convert_to_custom_timestamp(self, dt, format):
        if not self._need_to_handle_f_directive_need_to_handle_f_directive(format):
            return dt.strftime(format)
        format = self._remove_f_from_format_remove_f_from_format(format)
        return dt.strftime(format) + '%06d' % dt.microsecond
 
    def _convert_to_timestamp(self, dt, millis=True):
        if not millis:
            return dt.strftime('%Y-%m-%d %H:%M:%S')
        ms = roundup(dt.microsecond / 1000.0)
        if ms == 1000:
            dt += timedelta(seconds=1)
            ms = 0
        return dt.strftime('%Y-%m-%d %H:%M:%S') + '.%03d' % ms
 
    def _convert_to_epoch(self, dt):
        return time.mktime(dt.timetuple()) + dt.microsecond / 1e6
 
    def __add__(self, other):
        if isinstance(other, Time):
            return Date(self.datetimedatetime + other.timedelta)
        raise TypeError('Can only add Time to Date, got %s.' % type_name(other))
 
    def __sub__(self, other):
        if isinstance(other, Date):
            return Time(self.datetimedatetime - other.datetime)
        if isinstance(other, Time):
            return Date(self.datetimedatetime - other.timedelta)
        raise TypeError('Can only subtract Date or Time from Date, got %s.'
                        % type_name(other))
 
 
class Time():
 
    def __init__(self, time):
        self.secondsseconds = float(self._convert_time_to_seconds_convert_time_to_seconds(time))
 
    def _convert_time_to_seconds(self, time):
        if isinstance(time, timedelta):
            return time.total_seconds()
        return timestr_to_secs(time, round_to=None)
 
    @property
    timedelta = property
    
    def timedelta(self):
        return timedelta(seconds=self.secondsseconds)
 
    def convert(self, format, millis=True):
        try:
            result_converter = getattr(self, '_convert_to_%s' % format.lower())
        except AttributeError:
            raise ValueError("Unknown format '%s'." % format)
        seconds = self.secondsseconds if millis else float(roundup(self.secondsseconds))
        return result_converter(seconds, millis)
 
    def _convert_to_number(self, seconds, millis=True):
        return seconds
 
    def _convert_to_verbose(self, seconds, millis=True):
        return secs_to_timestr(seconds)
 
    def _convert_to_compact(self, seconds, millis=True):
        return secs_to_timestr(seconds, compact=True)
 
    def _convert_to_timer(self, seconds, millis=True):
        return elapsed_time_to_string(seconds * 1000, include_millis=millis)
 
    def _convert_to_timedelta(self, seconds, millis=True):
        return timedelta(seconds=seconds)
 
    def __add__(self, other):
        if isinstance(other, Time):
            return Time(self.secondsseconds + other.seconds)
        raise TypeError('Can only add Time to Time, got %s.' % type_name(other))
 
    def __sub__(self, other):
        if isinstance(other, Time):
            return Time(self.secondsseconds - other.seconds)
        raise TypeError('Can only subtract Time from Time, got %s.'
                        % type_name(other))