jsons._datetime_impl

Complexity

Total Complexity

20

Size/Duplication

Total Lines	141
Duplicated Lines	0 %

Importance

Changes

0

8 Functions

Rating	Name	Duplication	Size	Complexity
A	get_offset_str()	0	15	3
A	to_str()	0	9	3
A	get_datetime_inst()	0	14	3
A	_datetime_utc_inst()	0	10	1
A	_timedelta_offset_str()	0	13	2
A	_new_datetime()	0	13	1
A	_datetime_offset_inst()	0	17	2
A	_datetime_offset_str()	0	21	5

"""
PRIVATE MODULE: do not import (from) it directly.

This module contains functionality for ``datetime`` related stuff.
"""
from datetime import datetime, timezone, timedelta, time, date
from typing import Union

RFC3339_DATE_PATTERN = '%Y-%m-%d'
RFC3339_TIME_PATTERN = '%H:%M:%S'
RFC3339_DATETIME_PATTERN = '{}T{}'.format(
    RFC3339_DATE_PATTERN, RFC3339_TIME_PATTERN)


def to_str(
        dt: Union[datetime, date],
        strip_microseconds: bool,
        fork_inst: type,
        pattern: str = RFC3339_DATETIME_PATTERN) -> str:
    offset = get_offset_str(dt, fork_inst)
    if not strip_microseconds and getattr(dt, 'microsecond', None):
        pattern += '.%f'
    return dt.strftime("{}{}".format(pattern, offset))


def get_offset_str(
        obj: Union[datetime, date, timedelta],
        fork_inst: type) -> str:
    """
    Return the textual offset of the given ``obj``.
    :param obj: a datetime or timedelta instance.
    :param fork_inst: the state holder that is used.
    :return: the offset following RFC3339.
    """
    result = ''
    if isinstance(obj, datetime):
        result = _datetime_offset_str(obj, fork_inst)
    elif isinstance(obj, timedelta):
        result = _timedelta_offset_str(obj)
    return result


def get_datetime_inst(obj: str, pattern: str) -> datetime:
    """
    Return a datetime instance with timezone info from the given ``obj``.
    :param obj: the ``obj`` in RFC3339 format.
    :param pattern: the datetime pattern.
    :return: a datetime instance with timezone info.
    """
    if obj[-1] == 'Z':
        result = _datetime_utc_inst(obj, pattern)
    elif 'T' in pattern:
        result = _datetime_offset_inst(obj, pattern)
    else:
        result = datetime.strptime(obj, pattern)
    return result


def _datetime_offset_str(obj: datetime, fork_inst: type) -> str:
    """
    Return a textual offset (e.g. +01:00 or Z) for the given datetime.
    :param obj: the datetime instance.
    :return: the offset for ``obj``.
    """
    tzone = obj.tzinfo
    if not tzone:
        # datetimes without tzinfo are treated as local times.
        fork_inst._warn('The use of datetimes without timezone is dangerous '
                        'and can lead to undesired results.',
                        'datetime-without-tz')
        tzone = datetime.now(timezone.utc).astimezone().tzinfo
        if tzone is timezone.utc or tzone.utc is timezone.utc:
            return '+00:00'
    offset = 'Z'
    if tzone.tzname(None) not in ('UTC', 'UTC+00:00'):
        tdelta = tzone.utcoffset(None) or \
                 getattr(tzone, 'adjusted_offset', tzone.utcoffset(obj))
        offset = _timedelta_offset_str(tdelta)
    return offset


def _timedelta_offset_str(tdelta: timedelta) -> str:
    """
    Return a textual offset (e.g. +01:00 or Z) for the given timedelta.
    :param tdelta: the timedelta instance.
    :return: the offset for ``tdelta``.
    """
    offset_s = tdelta.total_seconds()
    offset_h = int(offset_s / 3600)
    offset_m = int((offset_s / 60) % 60)
    offset_t = time(abs(offset_h), abs(offset_m))
    operator = '+' if offset_s > 0 else '-'
    offset = offset_t.strftime('{}%H:%M'.format(operator))
    return offset


def _datetime_utc_inst(obj: str, pattern: str) -> datetime:
    """
    Return a datetime instance with UTC timezone info.
    :param obj: a datetime in RFC3339 format.
    :param pattern: the datetime pattern that is used.
    :return: a datetime instance with timezone info.
    """
    dattim_str = obj[0:-1]
    dattim_obj = datetime.strptime(dattim_str, pattern)
    return _new_datetime(dattim_obj.date(), dattim_obj.time(), timezone.utc)


def _datetime_offset_inst(obj: str, pattern: str) -> datetime:
    """
    Return a datetime instance with timezone info.
    :param obj: a datetime in RFC3339 format.
    :param pattern: the datetime pattern that is used.
    :return: a datetime instance with timezone info.
    """
    dat_str, tim_str = obj.split('T')
    splitter, factor = ('+', 1) if '+' in tim_str else ('-', -1)
    naive_tim_str, offset = tim_str.split(splitter)
    naive_dattim_str = '{}T{}'.format(dat_str, naive_tim_str)
    dattim_obj = datetime.strptime(naive_dattim_str, pattern)
    hrs_str, mins_str = offset.split(':')
    hrs = int(hrs_str) * factor
    mins = int(mins_str) * factor
    tz = timezone(offset=timedelta(hours=hrs, minutes=mins))
    return _new_datetime(dattim_obj.date(), dattim_obj.time(), tz)


def _new_datetime(date_inst: date, time_inst: time, tzinfo: timezone) \
        -> datetime:
    """
    Return a datetime instance from a date, time and timezone.

    This function was required due to the missing argument for tzinfo under the
    Linux Python distribution.
    :param date_inst: the date.
    :param time_inst: the time.
    :param tzinfo: the Timezone.
    :return: a combined datetime instance.
    """
    return datetime.combine(date_inst, time_inst).replace(tzinfo=tzinfo)