jR\.@sddlmZddlmZddlmZmZmZedZddgZddZ e edrdd dZ n%Gd 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 cs5||}|dk r1t r1|j}n|S)N)rencode)argskwargsname)namefuncB/var/www/dbchiro/venv/build/python-dateutil/dateutil/tz/_common.pyadjust_encodingsz*tzname_in_python2..adjust_encodingr)r rr)r rr sfoldcCs|jd|S)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__propertyrrrrrr6s rcCsft|dd|kr|S|jdd}||j|jf7}|rXt|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 rrrrDs cs"tfdd}|S)z The CPython version of ``fromutc`` checks that the input is a ``datetime`` object and that ``self`` is attached as its ``tzinfo``. csIt|tstdn|j|k r<tdn||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@sXeZdZdZddZddZddZdd Zed d Z d S) _tzinfoz= Base class for all ``dateutil`` ``tzinfo`` objects. cCs}|jd|}t|dd}t|dd}|j|jk}|jdd|jddk}|o|| 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 rrrrN)rr utcoffset)rrZwall_0Zwall_1Z same_offsetZsame_dtrrr is_ambiguousxs $z_tzinfo.is_ambiguouscCsH|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_statuscCst|ddS)Nrr)r)rrrrrr.sz _tzinfo._foldcCs|j}|dkr'tdn|j}|dkrNtdn||}||7}t|ddj}|dkrtdn||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() resultrrz;fromutc(): dt.dst gave inconsistent results; cannot convert)r(r#r+r)rrdtoffdtdstdeltarrr_fromutcs       z_tzinfo._fromutccCs1|j|}|j||}t|d|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 occurance, chronologically, of the ambiguous datetime). :param dt: A timezone-aware :class:`datetime.datetime` object. r)r3r/r)rrr-r.rrrr%sz_tzinfo.fromutcN) rrrrr)r/r.r3r&r%rrrrr'ss     %r'c@seZdZdZddZddZddZedd 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 cCstddS)Nz%tzrangebase is an abstract base class)NotImplementedError)rrrr__init__sztzrangebase.__init__cCs7|j|}|dkrdS|r,|jS|jSdS)N)_isdst _dst_offset _std_offset)rrisdstrrrr(s  ztzrangebase.utcoffsetcCs4|j|}|dkrdS|r,|jStSdS)N)r7_dst_base_offsetZERO)rrr:rrrr+ s  ztzrangebase.dstcCs!|j|r|jS|jSdS)N)r7Z _dst_abbrZ _std_abbr)rrrrrtznamesztzrangebase.tznamec Cst|tstdn|j|k r<tdn|j|j}|dkrk||j|S|\}}||j8}||j8}||f}|j dd}|j ||}|r||j }n ||j}t | o|j |} t|d| S)z, Given a datetime in UTC, return local time z&fromutc() requires a datetime argumentzdt.tzinfo is not selfNrr)r!rr"rr# transitionsyearr(r9r _naive_isdstr8r*r)r) rrr>dstondstoffZutc_transitionsr,r:r-r.rrrr%s$      ztzrangebase.fromutccCsV|js dS|j|j\}}|jdd}||koS||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 FrN)hasdstr>r?rr;)rrstartendrrrr)>s  ztzrangebase.is_ambiguouscCs|js dS|dkrdS|j|j}|dkr?dS|jdd}|j||}| r|j|r|j| S|SdS)NFr)rCr>r?rr@r)r.)rrr>r:rrrr7Ts   ztzrangebase._isdstcCsj|\}}|jdd}||krI||koA|kn}n||ko`|kn }|S)Nr)r)rrr>rArBr:rrrr@is   ztzrangebase._naive_isdstcCs|j|jS)N)r8r9)rrrrr;usztzrangebase._dst_base_offsetNcCs ||k S)Nr)rotherrrr__ne__{sztzrangebase.__ne__cCsd|jjS)Nz%s(...)) __class__r)rrrr__repr__~sztzrangebase.__repr__)rrrrr6r(r+rr=r%r)r7r@rr;__hash__rGrIobject __reduce__rrrrr4s    !     r4cCs!|j|jdd|jdS)NiQi@B)secondsdays microseconds)tdrrr_total_secondssrQ total_secondsN)sixr functoolsrrrrr<__all__rhasattrrrr&r'r4rQrrrrrs    v