3 fY.@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)namefuncD/Users/olari/OneDrive/sandbox/awsBlog2/lambda/dateutil/tz/_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)getattr timetuple 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)rrwall_0wall_1 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)rrrrrr1sz _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)rrZdtoffZdtdstdeltarrr_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)r4r2r)rrr0r1rrrr%s  z_tzinfo.fromutcN) rrrrr,r2r1r4r&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)r8_dst_base_offsetZERO)rrr;rrrr. s  ztzrangebase.dstcCs|j|r|jS|jSdS)N)r8 _dst_abbr _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)r!rr"rr# transitionsyearr(r:r _naive_isdstr9r-r,r) rrrAdstondstoffZutc_transitionsr/r;r0r1rrrr%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)hasdstrArBrr<)rrstartendrrrr,>s  ztzrangebase.is_ambiguouscCsj|js dS|dkrdS|j|j}|dkr.dS|jdd}|j||}| rb|j|rb|j| S|SdS)NF)r)rFrArBrrCr,r1)rrrAr;rrrr8Ts    ztzrangebase._isdstcCsT|\}}|jdd}||kr6||ko.|kn}n||koH|kn }|S)N)r)r)rrrArDrEr;rrrrCis  ztzrangebase._naive_isdstcCs |j|jS)N)r9r:)rrrrr<usztzrangebase._dst_base_offsetNcCs ||k S)Nr)rotherrrr__ne__{sztzrangebase.__ne__cCs d|jjS)Nz%s(...)) __class__r)rrrr__repr__~sztzrangebase.__repr__)rrrrr7r(r.rr@r%r,r8rCrr<__hash__rJrLobject __reduce__rrrrr5s  ! r5cCs|j|jdd|jdS)NiQi@B)secondsdays microseconds)tdrrr_total_secondssrT total_secondsN)r)r)sixr functoolsrrrrr=__all__rhasattrrrr&r'r5rTrrrrrs     v