result_format='timestamp', exclude_millis=False):

"""Returns current local or UTC time with an optional increment.

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)

date_format=None):

"""Converts between supported `date formats`.

return Date(date, date_format).convert(result_format,

"""Converts between supported `time formats`.

exclude_millis=False, date1_format=None,

date2_format=None):

"""Subtracts date from another date and returns time between.

time = Date(date1, date1_format) - Date(date2, date2_format)

exclude_millis=False, date_format=None):

"""Adds time to date and returns the resulting date.

date = Date(date, date_format) + Time(time)

exclude_millis=False, date_format=None):

"""Subtracts time from date and returns the resulting date.

date = Date(date, date_format) - Time(time)

exclude_millis=False):

"""Adds time to another time and returns the resulting time.

time = Time(time1) + Time(time2)

exclude_millis=False):

"""Subtracts time from another time and returns the resulting time.

time = Time(time1) - Time(time2)

def __init__(self, date, input_format=None):

self.datetime = self._convert_to_datetime(date, input_format)

@property

def seconds(self):

# Mainly for backwards compatibility with RF 2.9.1 and earlier.

return self._convert_to_epoch(self.datetime)

def _convert_to_datetime(self, date, input_format):

if isinstance(date, datetime):

return date

if is_number(date):

return self._seconds_to_datetime(date)

if is_string(date):

return self._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(ts)

input_format = '%Y-%m-%d %H:%M:%S.%f'

if self._need_to_handle_f_directive(input_format):

return self._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(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.datetime

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(dt, format)

format = format.lower()

if format == 'timestamp':

return self._convert_to_timestamp(dt, millis)

if format == 'datetime':

return dt

if format == 'epoch':

return self._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(format):

return dt.strftime(format)

format = self._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.datetime + 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.datetime - other.datetime)

if isinstance(other, Time):

return Date(self.datetime - other.timedelta)

raise TypeError('Can only subtract Date or Time from Date, got %s.'

def __init__(self, time):

self.seconds = float(self._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

def timedelta(self):

return timedelta(seconds=self.seconds)

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.seconds if millis else float(roundup(self.seconds))

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.seconds + 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.seconds - other.seconds)

raise TypeError('Can only subtract Time from Time, got %s.'