]j2 d dl mZ d dlmZ d dlmZmZmZ ed ZddgZd Z e
ed rdd Z n G d
d e Z dd Z d
Z
G d de Z G d de ZdS ) )PY2wraps)datetime timedeltatzinfotzname_in_python2enfoldc N t r t fd }|S 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
c D | i |}|| }|S N)encode)argskwargsnamenamefuncs s/builddir/build/BUILD/imunify360-venv-2.6.3/opt/imunify360/venv/lib/python3.11/site-packages/dateutil/tz/_common.pyadjust_encodingz*tzname_in_python2.<locals>.adjust_encoding s/ 8T,V,,D {{}}K )r r )r r s ` r r r
sC x
r fold c . | | S )
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 s r r
r
% s $ zztz$$$r c 2 e Zd ZdZdZd Zed 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
c d}t || D ]0\ }}||v r"t d | |||< 1|D ]}||vrt | | ||< | dd r| j nt } |di |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.
)yearmonthdayhourminutesecond microsecondr zDuplicate argument: {}r r r )zip TypeErrorformatgetattrget __class__r )selfr r argnamesargargnamedt_classs r r z_DatetimeWithFold.replaceD s H
!$D( 3 3
&
& Wf$$#$<$C$CG$L$LMMM"%w#
=
=&((&-dG&<&<F7O)/FA)>)>Lt~~HH8%%f%% %r c dS )Nr r r/ s r r z_DatetimeWithFold.foldb s 1r N)__name__
__module__ __qualname____doc__ __slots__r propertyr r r r r r : sO & & &<
r r c t | dd |k r| S | dd }|| j | j fz
}|r t | S t | S )r r r N )r, timetupler( r r r )r r r s r r
r
f sf $ 2vq ! !T ) )I||~~bqb! ++ #$d+ +T? "r c < t fd }|S )z
The CPython version of ``fromutc`` checks that the input is a ``datetime``
object and that ``self`` is attached as its ``tzinfo``.
c t |t st d |j | urt d | | S )N&fromutc() requires a datetime argumentdt.tzinfo is not self)
isinstancer r* r
ValueError)r/ r fs r fromutcz)_validate_fromutc_inputs.<locals>.fromutc sQ "h'' F DEE E
9D 455 5qr{{r r )rE rF s ` r _validate_fromutc_inputsrG s5
1XX X Nr c @ e Zd ZdZd Zd Zd Zd Zed Z dS )_tzinfoz=
Base class for all ``dateutil`` ``tzinfo`` objects.
c , | | }t |d }t |d }| | k }| d | d k }|o| 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 wall_0wall_1 same_offsetsame_dts r is_ambiguousz_tzinfo.is_ambiguous s ZZtZ
$
$###### &&((F,<,<,>,>> ...-- t 1L1LL*{?*r c | | r@||z
}t || | z
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 )rR intrM dst)r/ dt_utcdt_wall
delta_wall_folds r _fold_statusz_tzinfo._fold_status s[ " W % % 6)J
v'7'7'9'9FJJLL'HIJJEEE r c $ t |dd S )Nr r )r, r/ r s r rY z
_tzinfo._fold s r61%%%r c | }|t d | }|t d ||z
}||z
}t |d }|t d ||z 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)rM rD rU r
)r/ r dtoffdtdstdeltas r _fromutcz_tzinfo._fromutc s = & ' '
' = IJJ J
e r"""&&(( = 7 8 8
8Ezr c z | | }| || }t || S )r^ r )rb rZ r
)r/ r rW rY s r rF z_tzinfo.fromutc sA --## !!"g.. gE****r N)
r6 r7 r8 r9 rR rZ rY rb rG rF r r r rI rI sw + + +2 2& & &# # #J + + + + +r rI c e Zd ZdZd Zd Zd Zed Zd Z d Z
d Z d Z e
d
Zd Zd Zd
Zej Zd S ) 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 t d )Nz%tzrangebase is an abstract base class)NotImplementedErrorr5 s r __init__ztzrangebase.__init__! s !"IJJJr c T | | }|d S |r| j S | j S r
)_isdst _dst_offset _std_offsetr/ r isdsts r rM ztzrangebase.utcoffset$ s5 B =4
$# ## #r c T | | }|d S |r| j S t S r
)rj _dst_base_offsetZEROrm s r rU ztzrangebase.dst. s1 B =4
( (Kr c H | | r| j S | j S r
)rj _dst_abbr _std_abbrr\ s r tznameztzrangebase.tzname8 s$ ;;r?? "> !> !r c t |t st d |j | urt d | |j }||| | z S |\ }}|| j z }|| j z }||f}| d }|
|| }|r || j z }n
|| j z }t | o|
| } t || S )z, Given a datetime in UTC, return local time rA rB NrL r )rC r r* r rD transitionsr" rM rl r _naive_isdstrk rT rR r
)
r/ r rw dstondstoffutc_transitionsrV rn rW rY s
r rF ztzrangebase.fromutc? s# "h'' F DEE E
9D 455 5 &&rw// r*** * $
v
!!$"" &/4((!!&/:: ,4++GG4++GI<$"3"3G"<"<==gE****r c | j sdS | |j \ }}| d }||cxk o
|| j z k nc S )rK FNrL )hasdstrw r" r rp )r/ r startends r rR ztzrangebase.is_ambiguous` si { 5%%bg..
s
ZZtZ
$
$r7777C$"7 777778r c | j sdS |d S | |j }|dS | d }| || }|s+| | r| | S |S )NFrL )r} rw r" r rx rR rY )r/ r rw rn s r rj ztzrangebase._isdstv s { 5
Z4&&rw// 5
ZZtZ
$
$!!"k22 **2.. zz"~~% %Lr c |\ }}| d }||k r||cxk o|k nc }n||cxk o|k nc }|S )NrL r )r/ r rw ry rz rn s r rx ztzrangebase._naive_isdst ss #
v
ZZtZ
$
$ 6>>R((((&((((EE ",,,,u,,,,,E r c | j | j z
S r
)rk rl r5 s r rp z tzrangebase._dst_base_offset s $"222r Nc | |k S r
r )r/ others r __ne__ztzrangebase.__ne__ s EM""r c d| j j z S )Nz%s(...))r. r6 r5 s r __repr__ztzrangebase.__repr__ s 4>222r )r6 r7 r8 r9 rh rM rU r ru rF rR rj rx r; rp __hash__r r object
__reduce__r r r re re s *K K K$ $ $ " " " + + +B9 9 9, *
3 3 X3 H# # #3 3 3 "JJJr re N)r )sixr functoolsr r r r rq __all__r hasattrr
r rG rI re r r r <module>r s^ 0 0 0 0 0 0 0 0 0 0 y||
) , 78V ^#% % % % %** * * * *H * * *X# # # #< "s+ s+ s+ s+ s+f s+ s+ s+lX# X# X# X# X#' X# X# X# X# X#r