]j d Z ddlZddlZddlZddlZddlZddlZddlZddlm Z ddl
Z
ddl
m Z ddl m
Z
ddlmZmZ ddlmZmZ dd lmZ dd
lmZmZ dd lmZ dd lmZmZ n# e$ r dxZZY nw xY wdd
l m Z ej d Z ej d Z!e!" Z# e
j$ e G d dej% Z& e& Z' e
j$ e G d dej% Z( G d de Z) G d de* Z+ G d de* Z, G d de Z- G d de Z. e
j$ e G d d e. Z/ G d d e* Z0 G d d!e Z1 G d" d#e* Z2ej3 d$k r d%d&gZ4g d'Z5ng Z4g Z5d( Z6 e6 Z7[6d3d)Z8d3d*Z9d+ Z:d, Z;ej< d-k rd. Z=nd/ Z= dd0l>m?Z@ dS # e$ r G d1 d2e* Z@Y dS w xY w)4a
This module offers timezone implementations subclassing the abstract
:py:class:`datetime.tzinfo` type. There are classes to handle tzfile format
files (usually are in :file:`/etc/localtime`, :file:`/usr/share/zoneinfo`,
etc), TZ environment string (in all known formats), given ranges (with help
from relative deltas), local machine timezone, fixed offset timezone, and UTC
timezone.
N) OrderedDict) string_types)_thread )tzname_in_python2_tzinfo) tzrangebaseenfold)_validate_fromutc_inputs) _TzSingleton_TzOffsetFactory)
_TzStrFactory)tzwin
tzwinlocal)warnc t e Zd ZdZd Zd Zed Zd Ze d Z
d Z dZ d Z
d
Zej ZdS ) tzutca
This is a tzinfo object that represents the UTC time zone.
**Examples:**
.. doctest::
>>> from datetime import *
>>> from dateutil.tz import *
>>> datetime.now()
datetime.datetime(2003, 9, 27, 9, 40, 1, 521290)
>>> datetime.now(tzutc())
datetime.datetime(2003, 9, 27, 12, 40, 12, 156379, tzinfo=tzutc())
>>> datetime.now(tzutc()).tzname()
'UTC'
.. versionchanged:: 2.7.0
``tzutc()`` is now a singleton, so the result of ``tzutc()`` will
always return the same object.
.. doctest::
>>> from dateutil.tz import tzutc, UTC
>>> tzutc() is tzutc()
True
>>> tzutc() is UTC
True
c t S NZEROselfdts n/builddir/build/BUILD/imunify360-venv-2.6.3/opt/imunify360/venv/lib/python3.11/site-packages/dateutil/tz/tz.py utcoffsetztzutc.utcoffsetJ c t S r r r s r dstz tzutc.dstM r r c dS )NUTC r s r tznamez tzutc.tznameP s ur c dS )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
Fr# r s r is_ambiguousztzutc.is_ambiguousT s ur c |S )z
Fast track version of fromutc() returns the original ``dt`` object for
any valid :py:class:`datetime.datetime` object.
r# r s r fromutcz
tzutc.fromutcd s r c t |t t f st S t |t p$t |t o|j t
k S r )
isinstancer tzoffsetNotImplemented_offsetr r others r __eq__z tzutc.__eq__l sQ %%!233 "! !5%(( HE8,,F $1F Ir Nc | |k S r r# r/ s r __ne__z tzutc.__ne__u EM""r c d| j j z S Nz%s() __class____name__r s r __repr__ztzutc.__repr__x ///r )r9
__module__ __qualname____doc__r r r r$ r' r r) r1 __hash__r3 r; object
__reduce__r# r r r r ) s > I I I H# # #0 0 0 "JJJr r c z e Zd ZdZd Zd Zd Zed Ze d Z
d Z d Z d Z
d
Zd Zej Zd S ) r, a1
A simple class for representing a fixed offset from UTC.
:param name:
The timezone name, to be returned when ``tzname()`` is called.
:param offset:
The time zone offset in seconds, or (since version 2.6.0, represented
as a :py:class:`datetime.timedelta` object).
c || _ | }n# t t f$ r Y nw xY wt j t
| | _ d S Nseconds)_name
total_seconds TypeErrorAttributeErrordatetime timedelta_get_supported_offsetr. )r nameoffsets r __init__ztzoffset.__init__ sj
))++FF>* D )2G2O2OPPP s 22c | j S r r. r s r r ztzoffset.utcoffset s
|r c t S r r r s r r z tzoffset.dst r r c | j S r )rH r s r r$ ztzoffset.tzname s
zr c || j z S r rS r s r r) ztzoffset.fromutc s DL r c dS )a4
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
Fr# r s r r' ztzoffset.is_ambiguous s ur c Z t |t st S | j |j k S r )r+ r, r- r. r/ s r r1 ztzoffset.__eq__ s) %** "! !|u},,r Nc | |k S r r# r/ s r r3 ztzoffset.__ne__ r4 r c | j j dt | j dt | j dS )N(, ))r8 r9 reprrH intr. rI r: s r r; ztzoffset.__repr__ sN #~ 6 6 6 #DJ / / / / "4<#=#=#?#? @ @ @ @B Br )r9 r= r> r? rQ r r r r$ r r) r' r1 r@ r3 r; rA rB r# r r r, r, s Q Q Q ! ! ! - - - H# # #B B B
"JJJr r, c | e Zd ZdZ fdZd Zd Zed Zd Z d Z
dd Z d
Z d Z
d Zd
Zej Z xZS )tzlocalzR
A :class:`tzinfo` subclass built around the ``time`` timezone functions.
c t t | t j t
j | _ t
j r&t j t
j | _
n | j | _
| j
| j z
| _ t | j | _
t t
j | _ d S rE )superra rQ rL rM timetimezone _std_offsetdaylightaltzone _dst_offset
_dst_savedbool_hasdsttupler$ _tznames)r r8 s r rQ ztzlocal.__init__ s
gt %%'''#-t}nEEE = 0 ' 14<- H H HD # /D *T-==DO,, dk**
r c ^ | | j rd S | | r| j S | j S r )rl _isdstri rf r s r r ztzlocal.utcoffset s6
:$,:4 ;;r?? $# ## #r c n | | j rd S | | r| j | j z
S t S r )rl rp ri rf r r s r r z tzlocal.dst s:
:$,:4 ;;r?? #d&66 6Kr c B | j | | S r )rn rp r s r r$ ztzlocal.tzname s }T[[__--r c t | | }| o || || j z
k S )r& )
_naive_is_dstrj )r r naive_dsts r r' ztzlocal.is_ambiguous sE &&r**
Hd 0 0do1E F FF Ir c l t | }t j |t j z j S r )_datetime_to_timestamprd localtimere tm_isdst)r r timestamps r rt ztzlocal._naive_is_dst s) *2.. ~i$- 788AAr Tc | j sdS | | }t |dd }| | r|| | S dS |S )NFfoldT)rl rt getattrr' _fold)r r
fold_naivedstvalr| s r rp ztzlocal._isdst sr 2 | 5 ##B''r64(( R ::b>>))t
r c x t |t r | j |j k o| j |j k S t |t r'| j o | j d dv o| j t k S t |t r.| j o%| j d |j k o| j |j
k S t S )Nr > GMTr" ) r+ ra rf ri r rl rn r r, rH r. r- r/ s r r1 ztzlocal.__eq__. s eW % % "$(99 :$(99
;
u
%
% " $ -M!$6-$,
. x
(
( " $ 6M!$ 36$
5
7 " !r Nc | |k S r r# r/ s r r3 ztzlocal.__ne__? r4 r c d| j j z S r6 r7 r: s r r; ztzlocal.__repr__B r< r )T)r9 r= r> r? rQ r r r r$ r' rt rp r1 r@ r3 r; rA rB
__classcell__r8 s @r ra ra s + + + + +$ $ $ . . .I I I$B B B& & & &P
"
"
" H# # #0 0 0 "JJJJJr ra c > e Zd Zg dZd Zd Zd ZdZd Zd Z d Z
dS ) _ttinfo)rP deltaisdstabbrisstdisgmt dstoffsetc < | j D ]}t | |d d S r __slots__setattr)r attrs r rQ z_ttinfo.__init__L s2 N & &D D$ % % % % & &r c g }| j D ];}t | | }|'| |dt | <| j j dd | dS )N=r[ r\ r] )r r} appendr^ r8 r9 join)r lr values r r; z_ttinfo.__repr__P su N 8 8DD$''E DDD$u+++6777 >222DIIaLLLLAAr c t |t st S | j |j k o_| j |j k oO| j |j k o?| j |j k o/| j |j k o | j |j k o| j |j k S r )
r+ r r- rP r r r r r r r/ s r r1 z_ttinfo.__eq__X s %)) "! ! u|+ 2
ek)2
ek)2 UZ'2
ek) 2
ek) 2 %/1
3r Nc | |k S r r# r/ s r r3 z_ttinfo.__ne__f r4 r c F i }| j D ]}t | |d ||< |S r )r r} r staterO s r __getstate__z_ttinfo.__getstate__i s4 N 4 4D!$d33E$KK r c P | j D ] }||v rt | ||| d S r r r s r __setstate__z_ttinfo.__setstate__o s= N 1 1Du}}dE$K000 1 1r ) r9 r= r> r rQ r; r1 r@ r3 r r r# r r r r H s 0 0 0I& & &B B B
3
3
3 H# # # 1 1 1 1 1r r c e Zd ZdZg dZd ZdS )_tzfilezw
Lightweight class for holding the relevant transition and time zone
information read from binary tzfiles.
)
trans_listtrans_list_utc trans_idx ttinfo_list
ttinfo_std
ttinfo_dst
ttinfo_before ttinfo_firstc d | j D ]'}t | || |d (d S r )attrsr get)r kwargsr s r rQ z_tzfile.__init__} s@ J 8 8D D$
4 6 6 7 7 7 7 8 8r N)r9 r= r> r? r rQ r# r r r r u sA
J
J
JE8 8 8 8 8r r c e Zd ZdZd fd Zd Zd ZddZd Zd Z d
Z
dd Z d Z d
Z
d Zed Zd ZdZd Zd Zd Zd Z xZS )tzfilea
This is a ``tzinfo`` subclass that allows one to use the ``tzfile(5)``
format timezone files to extract current and historical zone information.
:param fileobj:
This can be an opened file stream or a file name that the time zone
information can be read from.
:param filename:
This is an optional parameter specifying the source of the time zone
information in the event that ``fileobj`` is a file object. If omitted
and ``fileobj`` is a file stream, this parameter will be set either to
``fileobj``'s ``name`` attribute or to ``repr(fileobj)``.
See `Sources for Time Zone and Daylight Saving Time Data
<https://data.iana.org/time-zones/tz-link.html>`_ for more information.
Time zone files can be compiled from the `IANA Time Zone database files
<https://www.iana.org/time-zones>`_ with the `zic time zone compiler
<https://www.freebsd.org/cgi/man.cgi?query=zic&sektion=8>`_
.. note::
Only construct a ``tzfile`` directly if you have a specific timezone
file on disk that you want to read into a Python ``tzinfo`` object.
If you want to get a ``tzfile`` representing a specific IANA zone,
(e.g. ``'America/New_York'``), you should call
:func:`dateutil.tz.gettz` with the zone identifier.
**Examples:**
Using the US Eastern time zone as an example, we can see that a ``tzfile``
provides time zone information for the standard Daylight Saving offsets:
.. testsetup:: tzfile
from dateutil.tz import gettz
from datetime import datetime
.. doctest:: tzfile
>>> NYC = gettz('America/New_York')
>>> NYC
tzfile('/usr/share/zoneinfo/America/New_York')
>>> print(datetime(2016, 1, 3, tzinfo=NYC)) # EST
2016-01-03 00:00:00-05:00
>>> print(datetime(2016, 7, 7, tzinfo=NYC)) # EDT
2016-07-07 00:00:00-04:00
The ``tzfile`` structure contains a fully history of the time zone,
so historical dates will also have the right offsets. For example, before
the adoption of the UTC standards, New York used local solar mean time:
.. doctest:: tzfile
>>> print(datetime(1901, 4, 12, tzinfo=NYC)) # LMT
1901-04-12 00:00:00-04:56
And during World War II, New York was on "Eastern War Time", which was a
state of permanent daylight saving time:
.. doctest:: tzfile
>>> print(datetime(1944, 2, 7, tzinfo=NYC)) # EWT
1944-02-07 00:00:00-04:00
Nc t t | d}t |t r|| _ t
|d }d}n;||| _ n1t |d r
|j | _ nt | | _ |W|st | }|5 }| | }d d d n # 1 swxY w Y | | d S d S )NFrbTrO )
rc r rQ r+ r _filenameopenhasattrrO r^ _nullcontext _read_tzfile _set_tzdata)r fileobjfilenamefile_opened_here file_streamtzobjr8 s r rQ ztzfile.__init__ s9
fd$$&&& g| , , + $DN7D))G #
! %DNN
Wf
%
% + $\DNN !']]DN #
0&w//
7K ))+66
7
7
7
7
7
7
7
7
7
7
7
7
7
7
7
U # # # # # s *C CCc h t j D ]$}t | d|z t || %dS )z= Set the time zone data of this object from a _tzfile object _N)r r r r} )r r r s r r ztzfile._set_tzdata sB M < <D D#*geT&:&: ; ; ; ; < <r c t | d dk rt d | d t j d| d \ }}}}}}|rAt
t j d|z | |dz _ ng _ |r1t j d|z | | _ ng _ g }t | D ]=} |
t j d | d
>| | }
|r#| |d z t j
|r+t j d |z | | } |r+t j d |z | | } g _ t | D ]} || \ }
}}t |
}
t! }|
|_ t% j d
|_ t% j |
|_ ||_ |
||
d| |_ || k o | | d
k |_ || k o | | d
k |_ j
| ؈fdj D _ d _ d _ d _ j rƉj sj d
x_ _ nt |dz
dd D ]J} j | }j s|j s|_ nj s|j r|_ j r j r nKj rj s j _ j D ]}|j s |_ nj d
_ d }d }d }d }g _ tA j D ]\ } }|j }d
}|0|j r)|s||z
}|s|r|}t% j | |_ |}||z
}|}|||k r
|j |k r|}|j }|}|}j
j | |z tC j _ tC j _ tC j _ S )N TZifzmagic not found z>6l z>%dlz>%dBz>lbb z>%dbr rF c * g | ]}j | S r# )r ).0idxouts r
<listcomp>z'tzfile._read_tzfile.<locals>.<listcomp>s s GGG# -GGGr r )"r readdecode
ValueErrorstructunpacklistr r ranger seekosSEEK_CURr rN r rP rL rM r r r findr r r r r r r r enumeraterm )r r
ttisgmtcnt
ttisstdcntleapcnttimecnttypecntcharcntttinfoir r r gmtoffr abbrindttilastdst
lastoffset
lastdstoffsetlastbaseoffsetrP r
baseoffset
adjustmentr s @r r ztzfile._read_tzfile sf ii <<?? ! ! # #v - - .// / R2
M% b!1!1 2 2/
$!%fmFW4D4;LL4K4K'M 'M "N "NC "$C "M&7*:*1,,w*?*? A ACMM CM w B BA MM&- Q@@ A A A A||G$$++-- 3 LL1bk 2 2 2 <M&:"5"),,z":":< <E <M&:"5"),,z":":< <E w ( (A%+AY "FE7*622F))C CJ $ .q 1 1CM *6:::CI CIGDIIfg$>$> >?CH#a 9E!HMCI#a 9E!HMCI O " "3 ' ' ' ' HGGG GGG
? ;%
;47OA4FF!1!1 wqy"b11 8 8A -*C > -#) -), ^ - -),~ #. ~ 8cn 8), ? ; ;C 9 ,/) ),(:C%
.. F FFAsZFI"9 ." 8$*Z$7 $ 2 2$1 $,$6y$I$I$ICM$-M )+J#J *z^/K/K W,, +
iG J 'N N ! !#"4Q"7*"D E E E E cm,,
s~.. "3#5 6 6
r Fc | j sd S t | }|r| j n| j }t j || }|dz
S )Nr ) _trans_listrw _trans_list_utcbisect bisect_right)r r in_utcrz r r s r _find_last_transitionz tzfile._find_last_transition sS 4*2.. .4IT))9I
!*i88 Qwr c ~ ||dz t | j k r| j S |dk r| j S | j | S )Nr r )lenr _ttinfo_std_ttinfo_before
_trans_idx)r r s r _get_ttinfoztzfile._get_ttinfo sJ ;37s4+;'<'<<<# # 77& &s##r c V | | }| | S r )_resolve_ambiguous_timer )r r r s r _find_ttinfoztzfile._find_ttinfo s) **2.. $$$r c t |t j st d |j | urt d | |d }| | }|t j |j z }| || }t |t | S )a
The ``tzfile`` implementation of :py:func:`datetime.tzinfo.fromutc`.
:param dt:
A :py:class:`datetime.datetime` object.
:raises TypeError:
Raised if ``dt`` is not a :py:class:`datetime.datetime` object.
:raises ValueError:
Raised if this is called with a ``dt`` which does not have this
``tzinfo`` attached.
:return:
Returns a :py:class:`datetime.datetime` object representing the
wall time in ``self``'s time zone.
z&fromutc() requires a datetime argumentzdt.tzinfo is not selfT)r rF )r r| ) r+ rL rJ tzinfor r r rM rP r' r
r_ )r r r r dt_outr| s r r) ztzfile.fromutc s ( "h /00 F DEE E
9D 455 5 ((D(99 s##h(<<<< S 11f3t99----r c || | }t | }| | }||dk rdS | |dz
j |j z
}| j | }|||z k S )r& Nr Fr )r rw r rP r )r r r rz r odtts r r' ztzfile.is_ambiguous s ;,,R00C +2.. s## ;#((5
cAg
&
&
-
:
c
"27""r c | | }| | }||dk r|S t | o| || }||z
S )Nr )r r~ r_ r' )r r r r~
idx_offsets r r z tzfile._resolve_ambiguous_time( si ((,,
2 ;#((J UAt'8'8S'A'ABB
Z r c Z |d S | j st S | | j S r )r r r r r s r r ztzfile.utcoffset5 s3
:4 K $$**r c z |d S | j st S | | }|j st S |j S r ) _ttinfo_dstr r r r )r r r s r r z
tzfile.dst> sH
:4 K ##y K } r c L | j r|d S | | j S r )r r r r s r r$ z
tzfile.tznameN s- 2:4 $$))r c t |t st S | j |j k o | j |j k o| j |j k S r )r+ r r- r r _ttinfo_listr/ s r r1 z
tzfile.__eq__T sR %(( "! ! E$55 85#338!U%77 9r c | |k S r r# r/ s r r3 z
tzfile.__ne__] r4 r c J | j j dt | j dS Nr[ r] )r8 r9 r^ r r: s r r; ztzfile.__repr__` s( >222D 4H4H4H4HIIr c , | d S r )
__reduce_ex__r: s r rB ztzfile.__reduce__c s !!$'''r c . | j d | j f| j fS r )r8 r __dict__)r protocols r r ztzfile.__reduce_ex__f s t~ 6
FFr r F)r9 r= r> r? rQ r r r r r r) r' r r r r r$ r1 r@ r3 r; rB r r r s @r r r sg E EN$ $ $ $ $ $0< < < ^ ^ ^@
$ $ $% % %
". ". ".H# # # #: + + + * * *
9 9 9 H# # #J J J( ( (G G G G G G Gr r c B e Zd ZdZ ddZd Zd Zed ZdS )tzrangea[
The ``tzrange`` object is a time zone specified by a set of offsets and
abbreviations, equivalent to the way the ``TZ`` variable can be specified
in POSIX-like systems, but using Python delta objects to specify DST
start, end and offsets.
:param stdabbr:
The abbreviation for standard time (e.g. ``'EST'``).
:param stdoffset:
An integer or :class:`datetime.timedelta` object or equivalent
specifying the base offset from UTC.
If unspecified, +00:00 is used.
:param dstabbr:
The abbreviation for DST / "Summer" time (e.g. ``'EDT'``).
If specified, with no other DST information, DST is assumed to occur
and the default behavior or ``dstoffset``, ``start`` and ``end`` is
used. If unspecified and no other DST information is specified, it
is assumed that this zone has no DST.
If this is unspecified and other DST information is *is* specified,
DST occurs in the zone but the time zone abbreviation is left
unchanged.
:param dstoffset:
A an integer or :class:`datetime.timedelta` object or equivalent
specifying the UTC offset during DST. If unspecified and any other DST
information is specified, it is assumed to be the STD offset +1 hour.
:param start:
A :class:`relativedelta.relativedelta` object or equivalent specifying
the time and time of year that daylight savings time starts. To
specify, for example, that DST starts at 2AM on the 2nd Sunday in
March, pass:
``relativedelta(hours=2, month=3, day=1, weekday=SU(+2))``
If unspecified and any other DST information is specified, the default
value is 2 AM on the first Sunday in April.
:param end:
A :class:`relativedelta.relativedelta` object or equivalent
representing the time and time of year that daylight savings time
ends, with the same specification method as in ``start``. One note is
that this should point to the first time in the *standard* zone, so if
a transition occurs at 2AM in the DST zone and the clocks are set back
1 hour to 1AM, set the ``hours`` parameter to +1.
**Examples:**
.. testsetup:: tzrange
from dateutil.tz import tzrange, tzstr
.. doctest:: tzrange
>>> tzstr('EST5EDT') == tzrange("EST", -18000, "EDT")
True
>>> from dateutil.relativedelta import *
>>> range1 = tzrange("EST", -18000, "EDT")
>>> range2 = tzrange("EST", -18000, "EDT", -14400,
... relativedelta(hours=+2, month=4, day=1,
... weekday=SU(+1)),
... relativedelta(hours=+1, month=10, day=31,
... weekday=SU(-1)))
>>> tzstr('EST5EDT') == range1 == range2
True
Nc J ddl ma || _ || _ | }n# t
t f$ r Y nw xY w | }n# t
t f$ r Y nw xY w|t j | | _ n t | _ |t j | | _ n3|r%|#| j t j d z | _ n t | _ |r>|<t dddt d | _
n|| _
|r>|<t dd d
t d | _ n|| _ | j | j z
| _ t! | j
| _ d S ) Nr
relativedeltarF r hours r )r monthdayweekday
r )dateutilr _std_abbr _dst_abbrrI rJ rK rL rM rf r ri SU _start_delta
_end_delta_dst_base_offset_rk hasdst)r stdabbr stdoffsetdstabbrr startends r rQ ztzrange.__init__ s
+***** !//11II>* D !//11II>* D ' 1) D D DD #D ' 1) D D DD
$. # /(2D22N2N2N ND #D &u} - ; ;q-2B2B22F2F !< !H !HD !&D "s{ + 9 9M4D4DR4H4H : J JDOO "DO!%!1D4D!D 4,-- s + ??A A,+A,c p | j sdS t j |dd }|| j z }|| j z }||fS )a
For a given year, get the DST on and off transition times, expressed
always on the standard time side. For zones with no transitions, this
function returns ``None``.
:param year:
The year whose transitions you would like to query.
:return:
Returns a :class:`tuple` of :class:`datetime.datetime` objects,
``(dston, dstoff)`` for zones with an annual DST transition, or
``None`` for fixed offset zones.
Nr )r( rL r% r& )r year base_yearr, r- s r transitionsztzrange.transitions sJ { 4 %dAq11 D --$/)s|r c t |t st S | j |j k oO| j |j k o?| j |j k o/| j |j k o | j |j k o| j |j k S r ) r+ r r- r" r# rf ri r% r& r/ s r r1 ztzrange.__eq__ s %)) "! !%/1 4%/14 E$554 E$554 !U%77 4
5#33 5r c | j S r )r' r: s r _dst_base_offsetztzrange._dst_base_offset s %%r )NNNNN) r9 r= r> r? rQ r1 r1 propertyr4 r# r r r r j sz I IT +/)-!%-. -. -. -.^ 0 5 5 5 & & X& & &r r c ( e Zd ZdZddZd dZd ZdS )
tzstra
``tzstr`` objects are time zone objects specified by a time-zone string as
it would be passed to a ``TZ`` variable on POSIX-style systems (see
the `GNU C Library: TZ Variable`_ for more details).
There is one notable exception, which is that POSIX-style time zones use an
inverted offset format, so normally ``GMT+3`` would be parsed as an offset
3 hours *behind* GMT. The ``tzstr`` time zone object will parse this as an
offset 3 hours *ahead* of GMT. If you would like to maintain the POSIX
behavior, pass a ``True`` value to ``posix_offset``.
The :class:`tzrange` object provides the same functionality, but is
specified using :class:`relativedelta.relativedelta` objects. rather than
strings.
:param s:
A time zone string in ``TZ`` variable format. This can be a
:class:`bytes` (2.x: :class:`str`), :class:`str` (2.x:
:class:`unicode`) or a stream emitting unicode characters
(e.g. :class:`StringIO`).
:param posix_offset:
Optional. If set to ``True``, interpret strings such as ``GMT+3`` or
``UTC+3`` as being 3 hours *behind* UTC rather than ahead, per the
POSIX standard.
.. caution::
Prior to version 2.7.0, this function also supported time zones
in the format:
* ``EST5EDT,4,0,6,7200,10,0,26,7200,3600``
* ``EST5EDT,4,1,0,7200,10,-1,0,7200,3600``
This format is non-standard and has been deprecated; this function
will raise a :class:`DeprecatedTZFormatWarning` until
support is removed in a future version.
.. _`GNU C Library: TZ Variable`:
https://www.gnu.org/software/libc/manual/html_node/TZ-Variable.html
Fc ddl ma || _ t | }||j rt
d |j dv r|s|xj dz c_ t
| |j |j |j |j dd |j sd | _
d | _ nG| |j | _
| j
r!| |j d | _ t% | j
| _ d S )
Nr )_parserzunknown string formatr r" r F)r, r- r )isend)dateutil.parserr9 parser_s_parsetzany_unused_tokensr r) r* r rQ r+ r r% r& _deltar, r- rk r( )r s posix_offsetress r rQ ztzstr.__init__7 s 555555ooa ;#/; 455 5 ;. ( ( ( MMR MM
s{CM cm $% 1 1 1 { @ $D "DOO $ CI 6 6D
@"&++cgQ+"?"?4,-- r r c \ ddl m} i }|j ]|j |d< |j :| |j |j |d< |j dk rd|d< n;d|d< n5|j r
|j |d< n#|j |j |d< n|j
|j |d < |sG|s#d
|d< d|d< | d |d< n"d |d< d|d< | d |d< |j |j |d
< nd|d
< |r/| j
| j z
}|d
xx |j |j
dz z z cc< |j di |S )Nr r r r r r r yearday nlyeardayr r r rG i iQ r# )r! r r r weekr ydayjydayr$ rd ri rf rG days)r xr; r r r s r rA z tzstr._deltaW s ****** 7 gF7Oy$$1$9$9!)QV$L$Ly!6A::$%F5MM$&F5MM
& !u
V
!F9
W
"#'F;
9
9"#w !u
$1$4$4R$8$8y!!"$w "u
$1$4$4R$8$8y! 6 !F9 !%F9 D $t'77E 9 e1C!C C *}*44V444r c J | j j dt | j dS r
r8 r9 r^ r> r: s r r; ztzstr.__repr__ $ >222DMMMMBBr Nr )r )r9 r= r> r? rQ rA r; r# r r r7 r7 s] ( (R . . . .@'5 '5 '5 '5RC C C C Cr r7 c e Zd Z ddZdS )_tzicalvtzcompNc t j | | _ t j | | _ | j | j z
| _ || _ || _ || _ d S rE )rL rM tzoffsetfrom
tzoffsetto tzoffsetdiffr r$ rrule)r rS rT r r$ rV s r rQ z_tzicalvtzcomp.__init__ sX $ .| D D D",Z@@@ Od.? ?
r )NN)r9 r= r> rQ r# r r rQ rQ s+ $( r rQ c d e Zd Zg f fd Zd Zd Zd Zd Zed Z d Z
e j Z xZ
S )
_tzicalvtzc t t | || _ || _ g | _ g | _ t j | _ d S r )
rc rX rQ _tzid_comps
_cachedate
_cachecompr
allocate_lock _cache_lock)r tzidcompsr8 s r rQ z_tzicalvtz.__init__ sR
j$ ((***
"022r c \ t | j dk r
| j d S | d } | j 5 | j | j || | f cd d d S # 1 swxY w Y n# t $ r Y nw xY wd }d }| j D ]&}| || }|r |r||k r|}|}'|s | j D ]
}|j
s|} n |d }| j 5 | j d|| | f | j d| t | j dk r2| j | j d d d n # 1 swxY w Y |S )Nr r r r )
r r[ replacer_ r] r\ indexr~ r _find_compdtr insertpop)r r
lastcompdtlastcompcompcompdts r
_find_compz_tzicalvtz._find_comp sk t{ q ;q> !
ZZtZ
$
$ !
+
+t'<'<B ((* (* +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ D
K D&&tR00F
z
Z&-@-@ #
#
#
#z #HE 7
& & O " "1r4::b>>&: ; ; ; O " "1h / / /4?##b((##%%%##%%%
& & & & & & & & & & & & & & & sH B :B > B BB BB
B$#B$?BF!!F%(F%c |j t k r | | r
||j z }|j |d }|S )NT)inc)rU r r~ rV before)r rk r rl s r rf z_tzicalvtz._find_compdt sK t # #
2 # $# #B""24"00
r c > |d S | | j S r )rm rT r s r r z_tzicalvtz.utcoffset s!
:4r""--r c V | | }|j r|j S t S r )rm r rU r )r r rk s r r z_tzicalvtz.dst s+ r"" : $ $Kr c 6 | | j S r )rm r$ r s r r$ z_tzicalvtz.tzname s r""))r c 0 dt | j z S )Nz<tzicalvtz %s>)r^ rZ r: s r r; z_tzicalvtz.__repr__ s $tz"2"222r )r9 r= r> rQ rm rf r r r r$ r; rA rB r r s @r rX rX s #% 3 3 3 3 3 3+ + +Z . . . * * *3 3 3 "JJJJJr rX c 8 e Zd ZdZd Zd Zd dZd Zd Zd Z dS )
tzicala[
This object is designed to parse an iCalendar-style ``VTIMEZONE`` structure
as set out in `RFC 5545`_ Section 4.6.5 into one or more `tzinfo` objects.
:param `fileobj`:
A file or stream in iCalendar format, which should be UTF-8 encoded
with CRLF endings.
.. _`RFC 5545`: https://tools.ietf.org/html/rfc5545
c b ddl ma t |t r|| _ t |d }n2t
|dt | | _ t | }i | _ |5 }|
| d d d d S # 1 swxY w Y d S )Nr )rV rrO ) r! rV r+ r r> r r} r^ r _vtz
_parse_rfcr )r r fobjs r rQ ztzical.__init__ s """""" g| , , , DG7C((GG gvtG}}==DG"7++G
) OODIIKK ( ( ( ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) )s /(B$$B(+B(c N t | j S )z?
Retrieves the available time zones as a list.
)r ry keysr: s r r} z tzical.keys s DINN$$%%%r Nc |ot | j dk rt d t | j dk rt d t t | j }| j | S )a
Retrieve a :py:class:`datetime.tzinfo` object by its ``tzid``.
:param tzid:
If there is exactly one time zone available, omitting ``tzid``
or passing :py:const:`None` value returns it. Otherwise a valid
key (which can be retrieved from :func:`keys`) is required.
:raises ValueError:
Raised if ``tzid`` is not specified but there are either more
or fewer than 1 zone defined.
:returns:
Returns either a :py:class:`datetime.tzinfo` object representing
the relevant time zone or :py:const:`None` if the ``tzid`` was
not found.
Nr zno timezones definedr z more than one timezone available)r ry r nextiterr )r r` s r r z
tzical.get sv $ <49~~"" !7888TY !## !CDDDTY((Dy}}T"""r c | }|st d |d dv r d|d dk }|dd }nd}t | dk r8t |d d d z t |dd d
z z |z S t | d k rPt |d d d z t |dd d
z z t |dd z |z S t d |z )
Nz empty offsetr )+-)r r r r r r i < r zinvalid offset: )stripr r r_ )r rB signals r
_parse_offsetztzical._parse_offset" s
GGII - ^,, , Q4: adck*F!""AAF q66Q;;"1"JJ%AabbE
R76A A
VVq[["1"JJ%AacF b(883qu::EO O /! 344 4r c ` | }|st d d}|t | k ri|| }|s||= n6|dk r+|d dk r ||dz
xx |dd z
cc< ||= n|dz
}|t | k id }g }d}d }|D ]}|s| dd \ } }
| d } | st d | d } | dd } |r| d k r$|
d
v rnt d |
z |
}d} d }
d }g }d }| d k r|
d
k rQ|rt d|z |st d |st d t
|| | j |< d}|
|k r| st d |
t d |t d d }|r1t d
| ddd }t |
||dk || }| | d }t d|
z |r | dk r8| D ] }|dk rd|z }t | | | d} | dv r| | | d k r5| r t d | d | d d |
|
}
;| d k r1| rt d | d z |
|
}r| d!k r | rt d"| d z |
}| d#k rt d$| z | d%k r | rt d&| d z |
}| d'v rt d$| z | d k r |
d
k rd }g }d} d S )(Nz empty stringr r F:;zempty property nameBEGIN)STANDARDDAYLIGHTzunknown component: END VTIMEZONEzcomponent not closed: zmandatory TZID not foundz at least one component is neededzmandatory DTSTART not foundz mandatory TZOFFSETFROM not found
T)
compatibleignoretzcacher zinvalid component end: DTSTARTzVALUE=DATE-TIMEz(Unsupported DTSTART param in VTIMEZONE: )RRULERDATEEXRULEEXDATE TZOFFSETFROMz unsupported z parm:
TZOFFSETTOz unsupported TZOFFSETTO parm: TZNAMEzunsupported TZNAME parm: COMMENTzunsupported property: TZIDzunsupported TZID parm: )TZURLz
LAST-MODIFIEDr )
splitlinesr r rstripsplitupperrX ry rV rrulestrr rQ r r )r rB linesr liner` ra invtzcomptyperO r parms founddtstartrS rT
rrulelinesr$ rrrk parmmsgs r rz ztzical._parse_rfc2 s- - ^,, ,
#e**nn8??$$D
!HHQ47c>>ac
d122h&
!HHQ #e**nn f f D
**S!,,KD%JJsOOE
8 !67778>>##D!""IE ]
7?? 888 ()>u)D E EE $H#(L#'L!%J!#J !FFU]] ++# P",-Eh-N"O"O O # I",-G"H"H H $ D", B#D #D D +5T5*A*A $ % (** + L",-J"K"K K'/", B#D #D D%-", B#D #D D "% <!& *0E0E;?9=6: "0 "< "<B .lJ/7:/E.4b : : T***#' ()B5)H I II )Hy(( %* 6 6D #'8 8 8(57;(<&0oo 5 9 #))$///'+ !GGG"))$//// // O",*>BddE!HHH M#O #O O'+'9'9%'@'@ -- J", ?a H#J #J J%)%7%7%>%>
)) F", ;E!H D#F #F F!& ** ()A$)F G GGv~~ D", 9%( B#D #D D $ !FFF ()A$)F G GG Uk%9%9 Mf f r c J | j j dt | j dS r
rN r: s r r; ztzical.__repr__ rO r r )
r9 r= r> r? rQ r} r r rz r; r# r r rv rv s ) ) )"& & & # # # #65 5 5 { { { zC C C C Cr rv win32z/etc/localtimerx )z/usr/share/zoneinfoz/usr/lib/zoneinfoz/usr/share/lib/zoneinfoz
/etc/zoneinfoc v t ft t fz
G fddt } | S )Nc J e Zd ZdZd Zd fd Zd Zd Zedd Z dS ) __get_gettz.<locals>.GettzFunca
Retrieve a time zone object from a string representation
This function is intended to retrieve the :py:class:`tzinfo` subclass
that best represents the time zone that would be used if a POSIX
`TZ variable`_ were set to the same value.
If no argument or an empty string is passed to ``gettz``, local time
is returned:
.. code-block:: python3
>>> gettz()
tzfile('/etc/localtime')
This function is also the preferred way to map IANA tz database keys
to :class:`tzfile` objects:
.. code-block:: python3
>>> gettz('Pacific/Kiritimati')
tzfile('/usr/share/zoneinfo/Pacific/Kiritimati')
On Windows, the standard is extended to include the Windows-specific
zone names provided by the operating system:
.. code-block:: python3
>>> gettz('Egypt Standard Time')
tzwin('Egypt Standard Time')
Passing a GNU ``TZ`` style string time zone specification returns a
:class:`tzstr` object:
.. code-block:: python3
>>> gettz('AEST-10AEDT-11,M10.1.0/2,M4.1.0/3')
tzstr('AEST-10AEDT-11,M10.1.0/2,M4.1.0/3')
:param name:
A time zone name (IANA, or, on Windows, Windows keys), location of
a ``tzfile(5)`` zoneinfo file or ``TZ`` variable style time zone
specifier. An empty string, no argument or ``None`` is interpreted
as local time.
:return:
Returns an instance of one of ``dateutil``'s :py:class:`tzinfo`
subclasses.
.. versionchanged:: 2.7.0
After version 2.7.0, any two calls to ``gettz`` using the same
input strings will return the same object:
.. code-block:: python3
>>> tz.gettz('America/Chicago') is tz.gettz('America/Chicago')
True
In addition to improving performance, this ensures that
`"same zone" semantics`_ are used for datetimes in the same zone.
.. _`TZ variable`:
https://www.gnu.org/software/libc/manual/html_node/TZ-Variable.html
.. _`"same zone" semantics`:
https://blog.ganssle.io/articles/2018/02/aware-datetime-arithmetic.html
c t j | _ d| _ t | _ t
j | _ d S )Nr ) weakrefWeakValueDictionary_GettzFunc__instances _GettzFunc__strong_cache_sizer _GettzFunc__strong_cacher r^ r_ r: s r rQ z'__get_gettz.<locals>.GettzFunc.__init__ s> & : < <D '(D $"---D & 4 6 6D r Nc | j 5 | j |d }|C| | }| t | s
| || j |< n|cd d d S | j || | j |< t | j | j k r| j d d d d n # 1 swxY w Y |S )N)rO Flast)
r_ r r nocacher+ r rh r r popitem)r rO rvtzlocal_classess r __call__z'__get_gettz.<locals>.GettzFunc.__call__ sH !
<
<%))$55: 4 00B L )"o > > ) !z 24(.. "#
<
<
<
<
<
<
<
<& -1,?,C,CD",M,M#D)t*++d.FFF'//U/;;;-
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<0 Is AC*ACCCc | j 5 || _ t | j |k r3| j d t | j |k 3d d d d S # 1 swxY w Y d S )NFr )r_ r r r r )r sizes r set_cache_sizez-__get_gettz.<locals>.GettzFunc.set_cache_size+ s !
<
<+/($-..55'//U/;;; $-..55
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<s AA((A,/A,c | j 5 t j | _ | j d d d d S # 1 swxY w Y d S r )r_ r r r r clearr: s r cache_clearz*__get_gettz.<locals>.GettzFunc.cache_clear1 s !
,
,#*#>#@#@ #))+++
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,s 2AA A c N d}| s$ t j d } n# t $ r Y nw xY w| | dv rt D ]}t j | sN|}t D ]C}t j || }t j | r nDot j | r/ t | } n,# t t t f$ r Y w xY wt }n! | d r
| dd } nR# t $ rE}t! | t" r%d}t% j t | | n Y d}~nd}~ww xY wt j | r4t j | rt | }n_d}n[t D ]}t j || }t j | s6| dd }t j | sw t | } n# t t t f$ r Y w xY wd}t* * t+ | }n# t, t. f$ r d}Y nw xY w|s#d d
lm} | | }|sT| D ])}|d v r# t7 | }n# t $ r Y nw xY w n)*| d v rt8 }n | t: j v rt }|S )
z A non-cached version of gettzNTZ) r r r z'gettz argument should be str, not bytesr r r )get_zonefile_instance
0123456789r: ) r environKeyErrorTZFILESpathisabsTZPATHSr isfiler IOErrorOSErrorr ra
startswithrJ r+ bytessix
raise_fromrd r WindowsErrorUnicodeEncodeErrordateutil.zoneinfor r r7 r" rd r$ ) rO tzfilepathr r enew_msgr cs r r z&__get_gettz.<locals>.GettzFunc.nocache6 s B
:d+DD D|ty 0 0 ' # #H 7==22 %#+$+ % %D')w||D('C'CH !w~~h 7 7 & % & %w~~h// !!!'!1!1B !E '* = ! ! ! D! ! !B s++ ( #ABBx !$.. "Ky'9'91==== >==== 7==&& .3w~~d++ " #D\\ ! ' (3 (3#%7<<d#;#; !w~~h 7 7 )'/'7'7S'A'AH#%7>>(#;#; ) (!!'!1!1B !E '* = ! ! ! D! " , *%*4[[$02D#E * * *%) * " C O O O O O O!6!6!8!8!<!<T!B!BB ! 3%) 3 3
$% #4#4%--24[[+5 %- %- %-(,%-$)E $5 $(>#9#9),BB%)T[%8%8)0BIsl
&&CC0/C0 D% %
E4/;E//E4 II43I4J J'&J'K**
K76K7r )
r9 r= r> r? rQ r r r staticmethodr )r s r GettzFuncr s D D J 7 7 7 6 < < < , , ,
S S S
S S S r r )ra r rA )r r s @r __get_gettzr si jO J=(G G G G G G GF G G GR 9;;r c & | | j t d | j }| d } | | t | }| d }| |k S )a
Given a datetime and a time zone, determine whether or not a given datetime
would fall in a gap.
:param dt:
A :class:`datetime.datetime` (whose time zone will be ignored if ``tz``
is provided.)
:param tz:
A :class:`datetime.tzinfo` with support for the ``fold`` attribute. If
``None`` or not provided, the datetime's own time zone will be used.
:return:
Returns a boolean value whether or not the "wall time" exists in
``tz``.
.. versionadded:: 2.7.0
N,Datetime is naive and no time zone provided.rc )r r rd
astimezoner" )r r dt_rts r datetime_existsr s &
z
9 KLL L
Y 4 B
JJbJ ! ! , ,S 1 1 < <R @ @E MMM & &E
;r c | | j t d | j }t |dd }|& | | S # t $ r Y nw xY w| | } t
| d }t
| d }| | k }| | k }|o| S )a\
Given a datetime and a time zone, determine whether or not a given datetime
is ambiguous (i.e if there are two times differentiated only by their DST
status).
:param dt:
A :class:`datetime.datetime` (whose time zone will be ignored if ``tz``
is provided.)
:param tz:
A :class:`datetime.tzinfo` with support for the ``fold`` attribute. If
``None`` or not provided, the datetime's own time zone will be used.
:return:
Returns a boolean value whether or not the "wall time" is ambiguous in
``tz``.
.. versionadded:: 2.6.0
Nr r' rc r r r ) r r r} r' Exceptionrd r
r r )r r is_ambiguous_fnwall_0wall_1 same_offsetsame_dsts r datetime_ambiguousr s (
z
9 KLL L
Y b.$77O" ??2&& & D
2 B
BQ
F
BQ
F""$$(8(8(:(::Kzz||vzz||+H( ))s A
AAc | j kt | s\| t j d z }| t j d z
}| ||z
z
} | S )aZ
Given a datetime that may be imaginary, return an existing datetime.
This function assumes that an imaginary datetime represents what the
wall time would be in a zone had the offset transition not occurred, so
it will always fall forward by the transition's change in offset.
.. doctest::
>>> from dateutil import tz
>>> from datetime import datetime
>>> NYC = tz.gettz('America/New_York')
>>> print(tz.resolve_imaginary(datetime(2017, 3, 12, 2, 30, tzinfo=NYC)))
2017-03-12 03:30:00-04:00
>>> KIR = tz.gettz('Pacific/Kiritimati')
>>> print(tz.resolve_imaginary(datetime(1995, 1, 1, 12, 30, tzinfo=KIR)))
1995-01-02 12:30:00+14:00
As a note, :func:`datetime.astimezone` is guaranteed to produce a valid,
existing datetime, so a round-trip to and from UTC is sufficient to get
an extant datetime, however, this generally "falls back" to an earlier time
rather than falling forward to the STD side (though no guarantees are made
about this behavior).
:param dt:
A :class:`datetime.datetime` which may or may not exist.
:return:
Returns an existing :class:`datetime.datetime`. If ``dt`` was not
imaginary, the datetime returned is guaranteed to be the same object
passed to the function.
.. versionadded:: 2.7.0
Nr r )r r rL rM r )r curr_offset
old_offsets r resolve_imaginaryr sv H
y _R%8%8 H .R 8 8 88CCEE 8-B7777BBDD
kJ&&
Ir c b | d t z
S )z
Convert a :class:`datetime.datetime` object to an epoch timestamp in
seconds since January 1, 1970, ignoring the time zone.
Nrc )rd EPOCHrI )r s r rw rw s)
JJdJ # #e + : : < <<r ) r c | S r r# )
second_offsets r rN rN s r c | }d| dz dz z }|S )Nr r# )r r calculated_offsets r rN rN s$
#
=2#5""< = r ) nullcontextc $ e Zd ZdZd Zd Zd ZdS )r zj
Class for wrapping contexts so that they are passed through in a
with statement.
c || _ d S r context)r r s r rQ z_nullcontext.__init__0 s
"DLLLr c | j S r r r: s r __enter__z_nullcontext.__enter__3 s
< r c d S r r# )argsr s r __exit__z_nullcontext.__exit__6 s Dr N)r9 r= r> r? rQ r r r# r r r r + sK # # # r r r )Ar? rL r rd sysr r r collectionsr r r six.movesr _commonr r r r
r
_factoriesr r
r winr r ImportErrorwarningsr rM r utcfromtimestampr toordinal EPOCHORDINAL
add_metaclassr r r" r, ra rA r r r r r7 rQ rX rv platformr r r gettzr r r rw version_inforN
contextlibr r r# r r <module>r sf
# # # # # #
/ / / / / / / / ( ( ( ( ( ( ( ( - - - - - - 6 6 6 6 6 6 6 6 % % % % % % &&&&&&&&& EJJJ x! **1-- < Q# Q# Q# Q# Q#HO Q# Q# ! Q#n egg #$$A# A# A# A# A#x A# A# %$A#H|# |# |# |# |#g |# |# |#~*1 *1 *1 *1 *1f *1 *1 *1Z
8
8
8
8
8f
8
8
8eG eG eG eG eGW eG eG eGP_& _& _& _& _&k _& _& _&D =!!tC tC tC tC tCG tC tC "!tCn V S# S# S# S# S# S# S# S#lKC KC KC KC KCV KC KC KC\ <7 -G GG
GGN N Nb
D+* +* +* +*\+ + +\= = = v ! ! !66666666
v
s$ A# # A/.A/-G5 5H H