509318396 ­ ­ ­ ­ ­ ­ ­ ­ ­ ­ ­ ­ ­ ­ ­ ­ ­ ­ 3 6cY.@sddlmZddlmZddlmZmZmZedZddgZddZ e edrZdd dZ nGd d d eZ dd dZ d dZ GdddeZGdddeZddZeedeZdS))PY3)wraps)datetime timedeltatzinfotzname_in_python2enfoldcsfdd}|S)zChange unicode output into bytestrings in Python 2 tzname() API changed in Python 3. It used to return bytes, but was changed to unicode strings cs$||}|dk r t r |j}|S)N)rencode)argskwargsname)namefunc/usr/lib/python3.6/_common.pyadjust_encodings z*tzname_in_python2..adjust_encodingr)r rr)r rr s foldcCs |j|dS)a Provides a unified interface for assigning the ``fold`` attribute to datetimes both before and after the implementation of PEP-495. :param fold: The value for the ``fold`` attribute in the returned datetime. This should be either 0 or 1. :return: Returns an object for which ``getattr(dt, 'fold', 0)`` returns ``fold`` for all versions of Python. In versions prior to Python 3.6, this is a ``_DatetimeWithFold`` object, which is a subclass of :py:class:`datetime.datetime` with the ``fold`` attribute added, if ``fold`` is 1. .. versionadded:: 2.6.0 )r)replace)dtrrrrr!sc@s eZdZdZfZeddZdS)_DatetimeWithFoldz This is a class designed to provide a PEP 495-compliant interface for Python versions before 3.6. It is used only for dates in a fold, so the ``fold`` attribute is fixed at ``1``. .. versionadded:: 2.6.0 cCsdS)Nrr)selfrrrr@sz_DatetimeWithFold.foldN)__name__ __module__ __qualname____doc__ __slots__propertyrrrrrr6srcCsLt|dd|kr|S|jdd}||j|jf7}|r@t|St|SdS)a Provides a unified interface for assigning the ``fold`` attribute to datetimes both before and after the implementation of PEP-495. :param fold: The value for the ``fold`` attribute in the returned datetime. This should be either 0 or 1. :return: Returns an object for which ``getattr(dt, 'fold', 0)`` returns ``fold`` for all versions of Python. In versions prior to Python 3.6, this is a ``_DatetimeWithFold`` object, which is a subclass of :py:class:`datetime.datetime` with the ``fold`` attribute added, if ``fold`` is 1. .. versionadded:: 2.6.0 rrN)getattrZ timetupleZ microsecondrrr)rrr rrrrDscstfdd}|S)z The CPython version of ``fromutc`` checks that the input is a ``datetime`` object and that ``self`` is attached as its ``tzinfo``. cs.t|tstd|j|k r$td||S)Nz&fromutc() requires a datetime argumentzdt.tzinfo is not self) isinstancer TypeErrorr ValueError)rr)frrfromutcgs   z)_validate_fromutc_inputs..fromutc)r)r"r#r)r"r_validate_fromutc_inputsbs r$c@s<eZdZdZddZddZddZdd Zed d Z d S) _tzinfoz= Base class for all ``dateutil`` ``tzinfo`` objects. cCsV|j|d}t|dd}t|dd}|j|jk}|jdd|jddk}|oT| S)a6 Whether or not the "wall time" of a given datetime is ambiguous in this zone. :param dt: A :py:class:`datetime.datetime`, naive or time zone aware. :return: Returns ``True`` if ambiguous, ``False`` otherwise. .. versionadded:: 2.6.0 )rr)rrN)rr utcoffset)rrZwall_0Zwall_1Z same_offsetZsame_dtrrr is_ambiguousxs    z_tzinfo.is_ambiguouscCs4|j|r,||}t||j|jk}nd}|S)a Determine the fold status of a "wall" datetime, given a representation of the same datetime as a (naive) UTC datetime. This is calculated based on the assumption that ``dt.utcoffset() - dt.dst()`` is constant for all datetimes, and that this offset is the actual number of hours separating ``dt_utc`` and ``dt_wall``. :param dt_utc: Representation of the datetime as UTC :param dt_wall: Representation of the datetime as "wall time". This parameter must either have a `fold` attribute or have a fold-naive :class:`datetime.tzinfo` attached, otherwise the calculation may fail. r)r'intr&dst)rdt_utcdt_wallZ delta_wall_foldrrr _fold_statuss  z_tzinfo._fold_statuscCs t|ddS)Nrr)r)rrrrrr,sz _tzinfo._foldcCsh|j}|dkrtd|j}|dkr0td||}||7}t|ddj}|dkr`td||S)a Given a timezone-aware datetime in a given timezone, calculates a timezone-aware datetime in a new timezone. Since this is the one time that we *know* we have an unambiguous datetime object, we take this opportunity to determine whether the datetime is ambiguous and in a "fold" state (e.g. if it's the first occurence, chronologically, of the ambiguous datetime). :param dt: A timezone-aware :class:`datetime.datetime` object. Nz0fromutc() requires a non-None utcoffset() resultz*fromutc() requires a non-None dst() resultr)rz;fromutc(): dt.dst gave inconsistent results; cannot convert)r&r!r)r)rrZdtoffZdtdstZdeltarrr_fromutcsz_tzinfo._fromutccCs"|j|}|j||}t||dS)a Given a timezone-aware datetime in a given timezone, calculates a timezone-aware datetime in a new timezone. Since this is the one time that we *know* we have an unambiguous datetime object, we take this opportunity to determine whether the datetime is ambiguous and in a "fold" state (e.g. if it's the first occurance, chronologically, of the ambiguous datetime). :param dt: A timezone-aware :class:`datetime.datetime` object. )r)r.r-r)rrr+r,rrrr#s  z_tzinfo.fromutcN) rrrrr'r-r,r.r$r#rrrrr%ss %r%c@szeZdZdZddZddZddZedd Zd d Z d d Z ddZ ddZ e ddZdZddZddZejZdS) tzrangebasea This is an abstract base class for time zones represented by an annual transition into and out of DST. Child classes should implement the following methods: * ``__init__(self, *args, **kwargs)`` * ``transitions(self, year)`` - this is expected to return a tuple of datetimes representing the DST on and off transitions in standard time. A fully initialized ``tzrangebase`` subclass should also provide the following attributes: * ``hasdst``: Boolean whether or not the zone uses DST. * ``_dst_offset`` / ``_std_offset``: :class:`datetime.timedelta` objects representing the respective UTC offsets. * ``_dst_abbr`` / ``_std_abbr``: Strings representing the timezone short abbreviations in DST and STD, respectively. * ``_hasdst``: Whether or not the zone has DST. .. versionadded:: 2.6.0 cCs tddS)Nz%tzrangebase is an abstract base class)NotImplementedError)rrrr__init__sztzrangebase.__init__cCs*|j|}|dkrdS|r |jS|jSdS)N)_isdst _dst_offset _std_offset)rrisdstrrrr&s  ztzrangebase.utcoffsetcCs(|j|}|dkrdS|r |jStSdS)N)r2_dst_base_offsetZERO)rrr5rrrr) s  ztzrangebase.dstcCs|j|r|jS|jSdS)N)r2Z _dst_abbrZ _std_abbr)rrrrrtznames ztzrangebase.tznamec Cst|tstd|j|k r$td|j|j}|dkrF||j|S|\}}||j8}||j8}||f}|j dd}|j ||}|r||j }n ||j}t | o|j |} t|| dS)z, Given a datetime in UTC, return local time z&fromutc() requires a datetime argumentzdt.tzinfo is not selfN)r)r)rrr rr! transitionsyearr&r4r _naive_isdstr3r(r'r) rrr9dstondstoffZutc_transitionsr*r5r+r,rrrr#s$         ztzrangebase.fromutccCsD|js dS|j|j\}}|jdd}||ko>||jkSS)a6 Whether or not the "wall time" of a given datetime is ambiguous in this zone. :param dt: A :py:class:`datetime.datetime`, naive or time zone aware. :return: Returns ``True`` if ambiguous, ``False`` otherwise. .. versionadded:: 2.6.0 FN)r)hasdstr9r:rr6)rrstartendrrrr'>s  ztzrangebase.is_ambiguouscCsj|js dS|dkrdS|j|j}|dkr.dS|jdd}|j||}| rb|j|rb|j| S|SdS)NF)r)r>r9r:rr;r'r,)rrr9r5rrrr2Ts    ztzrangebase._isdstcCsT|\}}|jdd}||kr6||ko.|kn}n||koH|kn }|S)N)r)r)rrr9r<r=r5rrrr;is  ztzrangebase._naive_isdstcCs |j|jS)N)r3r4)rrrrr6usztzrangebase._dst_base_offsetNcCs ||k S)Nr)rotherrrr__ne__{sztzrangebase.__ne__cCs d|jjS)Nz%s(...)) __class__r)rrrr__repr__~sztzrangebase.__repr__)rrrrr1r&r)rr8r#r'r2r;rr6__hash__rBrDobject __reduce__rrrrr/s  ! r/cCs|j|jdd|jdS)NiQi@B)ZsecondsZdaysZ microseconds)Ztdrrr_total_secondssrHZ total_secondsN)r)r)Zsixr functoolsrrrrr7__all__rhasattrrrr$r%r/rHrrrrrs     v