a
&i2 @ s d dl mZ d dlmZ d dlmZmZmZ ed ZddgZdd Z e
edrZdd dZ nG d
d d eZ dd dZ d
d Z
G dd deZG dd deZdS ) )PY2wraps)datetime timedeltatzinfotzname_in_python2enfoldc s$ t r t fdd}|S S dS )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
c s" | i |}|d ur | }|S N)encode)argskwargsnamenamefunc 7/usr/lib/python3.9/site-packages/dateutil/tz/_common.pyadjust_encoding s z*tzname_in_python2..adjust_encodingN)r r )r r r r r r
s
fold c C s | j |dS )
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)dtr r r r r % s c @ s( e Zd ZdZdZdd Zedd ZdS )_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
r c O sz d}t ||D ]&\}}||v r,td||||< q|D ]}||vr:t| |||< q:|ddrh| jnt}|f i |S )a
Return a datetime with the same attributes, except for those
attributes given new values by whichever keyword arguments are
specified. Note that tzinfo=None can be specified to create a naive
datetime from an aware datetime with no conversion of date and time
data.
This is reimplemented in ``_DatetimeWithFold`` because pypy3 will
return a ``datetime.datetime`` even if ``fold`` is unchanged.
)yearZmonthZdayZhourZminutesecond microsecondr zDuplicate argument: {}r r )zip TypeErrorformatgetattrget __class__r )selfr r
ZargnamesargargnameZdt_classr r r r D s
z_DatetimeWithFold.replacec C s dS )Nr r r% r r r r b s z_DatetimeWithFold.foldN)__name__
__module__ __qualname____doc__ __slots__r propertyr r r r r r : s
r c C sL t | dd|kr| S | dd }|| j| jf7 }|r@t| S t| S dS )r r r N )r" Z timetupler r r r )r r r r r r r f s c s t fdd}|S )z
The CPython version of ``fromutc`` checks that the input is a ``datetime``
object and that ``self`` is attached as its ``tzinfo``.
c s. t |tstd|j| ur$td | |S )N&fromutc() requires a datetime argumentdt.tzinfo is not self)
isinstancer r r
ValueErrorr% r fr r fromutc s
z)_validate_fromutc_inputs..fromutcr )r6 r7 r r5 r _validate_fromutc_inputs s r8 c @ s< e Zd ZdZdd Zdd Zdd Zdd Zed
d Z d S )
_tzinfoz=
Base class for all ``dateutil`` ``tzinfo`` objects.
c C sV |j | d}t|dd}t|dd}| | k}|j dd|j ddk}|oT| S )6
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
r r r r N)r r utcoffset)r% r Zwall_0Zwall_1Z same_offsetZsame_dtr r r is_ambiguous s z_tzinfo.is_ambiguousc C s4 | |r,|| }t|| | k}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)r% dt_utcdt_wallZ
delta_wall_foldr r r _fold_status s
z_tzinfo._fold_statusc C s t |ddS )Nr r )r" r4 r r r rB s z
_tzinfo._foldc C sh | }|du rtd| }|du r0td|| }||7 }t|dd }|du r`td|| S )
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
occurrence, 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 r z;fromutc(): dt.dst gave inconsistent results; cannot convert)r< r3 r? r )r% r ZdtoffZdtdstZdeltar r r _fromutc s z_tzinfo._fromutcc C s" | |}| ||}t||dS )rD r )rE rC r )r% r rA rB r r r r7 s
z_tzinfo.fromutcN)
r) r* r+ r, r= rC rB rE r8 r7 r r r r r9 s %r9 c @ sz e Zd ZdZdd Zdd Zdd Zedd Zd
d Z d d
Z
dd Z dd Z e
dd ZdZdd Zdd ZejZdS ) 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
c C s t dd S )Nz%tzrangebase is an abstract base class)NotImplementedErrorr( r r r __init__! s ztzrangebase.__init__c C s* | |}|d u rd S |r | jS | jS d S r
)_isdst _dst_offset _std_offsetr% r isdstr r r r< $ s
ztzrangebase.utcoffsetc C s( | |}|d u rd S |r | jS tS d S r
)rI _dst_base_offsetZEROrL r r r r? . s
ztzrangebase.dstc C s | |r| jS | jS d S r
)rI Z _dst_abbrZ _std_abbrr4 r r r tzname8 s
ztzrangebase.tznamec
C s t |tstd|j| ur$td| |j}|du rF|| | S |\}}|| j8 }|| j8 }||f}|j dd}|
||}|r|| j }n
|| j }t | o|
|} t|| dS )z, Given a datetime in UTC, return local time r0 r1 Nr; r )r2 r r r r3 transitionsr r< rK r _naive_isdstrJ r> r= r )
r% r rQ dstondstoffZutc_transitionsr@ rM rA rB r r r r7 ? s$
ztzrangebase.fromutcc C sD | j s
dS | |j\}}|jdd}|| ko>|| j k S S )r: FNr; )hasdstrQ r r rN )r% r startendr r r r= ` s
ztzrangebase.is_ambiguousc C sh | j s
dS |d u rd S | |j}|d u r.dS |jd d}| ||}|s`| |r`| | S |S d S )NFr; )rU rQ r r rR r= rB )r% r rQ rM r r r rI v s ztzrangebase._isdstc C sT |\}}|j d d}||k r6|| ko.|k n }n|| koH|k n }|S )Nr; r )r% r rQ rS rT rM r r r rR s ztzrangebase._naive_isdstc C s | j | j S r
)rJ rK r( r r r rN s z tzrangebase._dst_base_offsetNc C s
| |k S r
r )r% otherr r r __ne__ s ztzrangebase.__ne__c C s d| j j S )Nz%s(...))r$ r) r( r r r __repr__ s ztzrangebase.__repr__)r) r* r+ r, rH r< r? r rP r7 r= rI rR r. rN __hash__rY rZ object
__reduce__r r r r rF s
!
rF N)r )r )Zsixr functoolsr r r r rO __all__r hasattrr r r8 r9 rF r r r r s
,
v