U
|
«ý°dõ ã @ s d Z ddlZddlZddlZddlZddlZddlZddlZddlm Z ddl
|
Z
|
ddl
|
m Z ddl m Z ddlmZmZ ddlmZmZ dd lmZ dd
|
lmZmZ dd lmZ zdd lmZmZ W n ek
|
rà d ZZY nX dd l m Z e d¡Z ej d¡Z!e! "¡ Z#e
|
$e¡G dd dej%Z&e& Z'e
|
$e¡G dd dej%Z(G dd deZ)G dd de*Z+G dd de*Z,G dd deZ-G dd deZ.e
|
$e¡G d d d e.Z/G d d d e*Z0G d d! d!eZ1G d"d# d#e*Z2ej3d$krd%d&gZ4d'd(d)d*gZ5ng Z4g Z5d+d, Z6e6 Z7[6d<d-d.Z8d=d/d0Z9d1d2 Z:d3d4 Z;ej<d5krXd6d7 Z=nd8d7 Z=zdd9l>m?Z@ W n& ek
|
r G d:d; d;e*Z@Y nX dS )>a
|
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)Ú tzrangebaseÚenfold)Ú_validate_fromutc_inputs)Ú _TzSingletonÚ_TzOffsetFactory)Ú _TzStrFactory)ÚtzwinÚ
|
tzwinlocal)Úwarnc @ sb e Zd ZdZdd Zdd Zedd Zdd Ze d
|
d Z
|
d d Z dZ dd Z dd ZejZdS )Ú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 C s t S ©N©ÚZERO©ÚselfÚdt© r úEd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\dateutil/tz/tz.pyÚ utcoffsetJ s ztzutc.utcoffsetc C s t S r r r r r r ÚdstM s z tzutc.dstc C s dS )NÚUTCr r r r r ÚtznameP s z tzutc.tznamec C s 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 r r r Ú is_ambiguousT s ztzutc.is_ambiguousc C s |S )z
|
Fast track version of fromutc() returns the original ``dt`` object for
|
any valid :py:class:`datetime.datetime` object.
|
r r r r r Úfromutcd s z tzutc.fromutcc C s0 t |ttfstS t |tp.t |to.|jtkS r )Ú
|
isinstancer ÚtzoffsetÚNotImplementedÚ_offsetr ©r Úotherr r r Ú__eq__l s
|
|
ÿz tzutc.__eq__Nc C s
|
| |k S r r r% r r r Ú__ne__u s z tzutc.__ne__c C s d| j j S ©Nz%s()©Ú __class__Ú__name__©r r r r Ú__repr__x s ztzutc.__repr__)r, Ú
|
__module__Ú __qualname__Ú__doc__r r r r r r
|
r r' Ú__hash__r( r. ÚobjectÚ
|
__reduce__r r r r r ) s
|
|
r c @ sj e Zd ZdZdd Zdd Zdd Zedd Ze d
|
d Z
|
d d Z dd Z dZ dd Zdd ZejZdS )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 C sB || _ z | ¡ }W n ttfk
|
r* Y nX tjt|d| _d S ©N©Úseconds)Ú_nameÚ total_secondsÚ TypeErrorÚAttributeErrorÚdatetimeÚ timedeltaÚ_get_supported_offsetr$ )r ÚnameÚoffsetr r r Ú__init__ s ztzoffset.__init__c C s | j S r ©r$ r r r r r s ztzoffset.utcoffsetc C s t S r r r r r r r s z tzoffset.dstc C s | j S r )r8 r r r r r s ztzoffset.tznamec C s
|
|| j S r rB r r r r r ¤ s ztzoffset.fromutcc C s 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 r r r r ¨ s ztzoffset.is_ambiguousc C s t |tstS | j|jkS r )r! r" r# r$ r% r r r r' ¶ s
|
ztzoffset.__eq__Nc C s
|
| |k S r r r% r r r r( ¾ s ztzoffset.__ne__c C s" d| j jt| jt| j ¡ f S )Nz
|
%s(%s, %s))r+ r, Úreprr8 Úintr$ r9 r- r r r r. Á s þztzoffset.__repr__)r, r/ r0 r1 rA r r r r r
|
r r r' r2 r( r. r3 r4 r r r r r" s
|
|
r" c sx e Zd ZdZ fddZdd Zdd Zedd Zd
|
d Z d d Z
|
dddZ dd Z dZ dd Zdd ZejZ ZS )ÚtzlocalzR
|
A :class:`tzinfo` subclass built around the ``time`` timezone functions.
|
c sl t t| ¡ tjtj d| _tjr:tjtj d| _
|
n| j| _
|
| j
|
| j | _ t | j | _ ttj| _d S r5 )ÚsuperrE rA r< r= ÚtimeÚtimezoneÚ _std_offsetÚdaylightÚaltzoneÚ _dst_offsetÚ
|
_dst_savedÚboolÚ_hasdstÚtupler Ú_tznamesr- ©r+ r r rA Í s ztzlocal.__init__c C s, |d kr| j rd S | |¡r"| jS | jS d S r )rO Ú_isdstrL rI r r r r r Ú s
|
|
ztzlocal.utcoffsetc C s0 |d kr| j rd S | |¡r(| j| j S tS d S r )rO rS rL rI r r r r r r ã s
|
|
z tzlocal.dstc C s | j | |¡ S r )rQ rS r r r r r ì s ztzlocal.tznamec C s$ | |¡}| o"|| || j ¡kS )r )Ú _naive_is_dstrM )r r Z naive_dstr r r r ð s
|
ÿztzlocal.is_ambiguousc C s t |}t |tj ¡jS r )Ú_datetime_to_timestamprG Ú localtimerH Útm_isdst)r r Ú timestampr r r rT s ztzlocal._naive_is_dstTc C sF | j s
|
dS | |¡}t|dd }| |¡rB|d k r>| |¡ S dS |S )NFÚfoldT)rO rT Úgetattrr Ú_fold)r r Z
|
fold_naiveZdstvalrY r r r rS s
|
|
ztzlocal._isdstc C s t |tr"| j|jko | j|jkS t |trL| j oJ| jd dkoJ| jtkS t |trz| j ox| jd |j kox| j|j
|
kS t S d S )Nr > r ÚGMT) r! rE rI rL r rO rQ r r" r8 r$ r# r% r r r r' . s"
|
|
ÿ
|
ÿþ
|
ÿ
|
þztzlocal.__eq__Nc C s
|
| |k S r r r% r r r r( ? s ztzlocal.__ne__c C s d| j j S r) r* r- r r r r. B s ztzlocal.__repr__)T)r, r/ r0 r1 rA r r r r r rT rS r' r2 r( r. r3 r4 Ú __classcell__r r rR r rE É s
|
|
(rE c @ sR e Zd ZdddddddgZdd Zd
|
d Zd d ZdZdd Zdd Z dd Z
|
dS )Ú_ttinfor@ ÚdeltaÚisdstÚabbrÚisstdÚisgmtÚ dstoffsetc C s | j D ]}t| |d qd S r ©Ú __slots__Úsetattr)r Úattrr r r rA L s
|
z_ttinfo.__init__c C sN g }| j D ],}t| |}|d k r
|
| d|t|f ¡ q
|
d| jjd |¡f S )Nz%s=%sú%s(%s)z, )rf rZ ÚappendrC r+ r, Újoin)r Úlrh Úvaluer r r r. P s
|
|
z_ttinfo.__repr__c C sb t |tstS | j|jko`| j|jko`| j|jko`| j|jko`| j|jko`| j|jko`| j |j kS r )
|
r! r^ r# r@ r_ r` ra rb rc rd r% r r r r' X s
|
|
ÿ
|
þ
|
ý
|
ü
|
û
|
úz_ttinfo.__eq__Nc C s
|
| |k S r r r% r r r r( f s z_ttinfo.__ne__c C s$ i }| j D ]}t| |d ||< q
|
|S r )rf rZ ©r Ústater? r r r Ú __getstate__i s
|
z_ttinfo.__getstate__c C s( | j D ] }||krt| ||| qd S r re rn r r r Ú __setstate__o s
|
z_ttinfo.__setstate__) r, r/ r0 rf rA r. r' r2 r( rp rq r r r r r^ H s ÿ r^ c @ s, e Zd ZdZdddddddd gZd
|
d Zd S ) Ú_tzfilezw
|
Lightweight class for holding the relevant transition and time zone
|
information read from binary tzfiles.
|
Ú
|
trans_listÚtrans_list_utcÚ trans_idxÚ ttinfo_listÚ
|
ttinfo_stdÚ
|
ttinfo_dstÚ ttinfo_beforeÚ ttinfo_firstc K s$ | j D ]}t| || |d ¡ qd S r )Úattrsrg Úget)r Úkwargsrh r r r rA } s
|
z_tzfile.__init__N)r, r/ r0 r1 r{ rA r r r r rr u s ÿrr c s® e Zd ZdZd& fdd Zdd Zdd Zd'd
|
d Zd d Zdd Z dd Z
|
d(ddZ dd Z dd Z dd Zedd Zd d ZdZd d Zd d! Zd"d# Zd$d% Z ZS ))Ú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 s t t| ¡ d}t|tr2|| _t|d}d}n.|d k rB|| _n t|drV|j| _n
|
t || _|d k r|stt
|
|}|}| |¡}W 5 Q R X | |¡ d S )NFÚrbTr? ) rF r~ rA r! r Ú _filenameÚopenÚhasattrr? rC Ú _nullcontextÚ _read_tzfileÚ _set_tzdata)r ÚfileobjÚfilenameZfile_opened_hereZ file_streamÚtzobjrR r r rA Ê s"
|
|
|
|
|
ztzfile.__init__c C s& t jD ]}t| d| t|| qdS )z= Set the time zone data of this object from a _tzfile object Ú_N)rr r{ rg rZ )r r rh r r r r
â s
|
ztzfile._set_tzdatac s´ t | d¡ ¡ dkr td| d¡ t d| d¡¡\}}}}}}|rntt d| | |d ¡¡ _ng _|rt d| | |¡¡ _ng _g }t |D ] } |
|
t d | d
|
¡¡¡ q¤| |¡ ¡ }
|
|ræ| |d t j ¡ |rt d | | |¡¡} |r t d | | |¡¡} g _t |D ]} || \} }}t| } t }| |_t d ¡|_tj| d|_||_|
|
||
|
d|¡
|_|| ko| | d k|_|| ko´| | d k|_ j
|
|¡ q, fdd jD _d _d _ d _ jrÀ js jd _ _ n¬t |d ddD ]T} j| } jsJ|jsJ| _n j s`|jr`| _ jr$ j r$ qq$ j r js j _ jD ]}|js| _ qÀq jd _ d }d }d }d }g _ t jD ]ª\} }|j}d }|d k r4|jr4|s|| }|s"|r"|}tj|d|_|}|| }|}|d k rd||krd|j|krd|}|j}|}|} j
|
j| | ¡ qàt! j _t! j _ t! j _ S )Né ZTZifzmagic not foundé z>6lé z>%dlz>%dBz>lbbé é z>%dbr r6 ú c s g | ]} j | qS r )rv )Ú.0Úidx©Úoutr r Ú
|
<listcomp>s s z'tzfile._read_tzfile.<locals>.<listcomp>r éÿÿÿÿ)"rr ÚreadÚdecodeÚ
|
ValueErrorÚstructÚunpackÚlistrt ru Úrangerj ÚseekÚosÚSEEK_CURrv r> r^ r@ r< r= rd r_ r` Úfindra rb rc rw rx ry rz rs Ú enumeraterP )r r Z
|
ttisgmtcntZ
|
ttisstdcntZleapcntZtimecntZtypecntZcharcntZttinfoÚira rb rc Úgmtoffr` ZabbrindÚttiZlastdstZ
|
lastoffsetZ lastdstoffsetZlastbaseoffsetr@ rd Z
|
baseoffsetZ
|
adjustmentr r r r è sÊ
|
é ÿ
|
|
ÿ
|
|
ÿ
|
ÿ
|
|
|
|
|
ÿ ztzfile._read_tzfileFc C s6 | j s
|
d S t|}|r | jn| j }t ||¡}|d S )Nr )Ú _trans_listrU Z_trans_list_utcÚbisectÚ bisect_right)r r Úin_utcrX rs r r r r Ú_find_last_transitionÈ s z tzfile._find_last_transitionc C s8 |d ks|d t | jkr | jS |dk r.| jS | j| S )Nr r )Úlenr¥ Ú _ttinfo_stdZ_ttinfo_beforeÚ
|
_trans_idx)r r r r r Ú _get_ttinfo× s
|
ztzfile._get_ttinfoc C s | |¡}| |¡S r )Ú_resolve_ambiguous_timer )r r r r r r Ú _find_ttinfoâ s
|
ztzfile._find_ttinfoc C sn t |tjstd|j| k r&td| j|dd}| |¡}|tj|jd }| j ||d}t
|
|t |dS )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¨ r6 )r ©rY ) r! r< r: Útzinfor r© r r= r@ r r rD )r r r r¤ Zdt_outrY r r r r ç s
|
|
ztzfile.fromutcc C sd |dkr| |¡}t|}| |¡}|dks4|dkr8dS | |d ¡j|j }| j| }||| k S )r Nr Fr )r© rU r r@ r¥ )r r r rX r¤ ZodÚttr r r r s
|
|
|
ztzfile.is_ambiguousc C sF | |¡}| |¡}|d ks$|dkr(|S t| o:| ||¡}|| S )Nr )r© r[ rD r )r r r r[ Z
|
idx_offsetr r r r® ( s
|
|
z tzfile._resolve_ambiguous_timec C s" |d kr d S | j stS | |¡jS r )r« r r¯ r_ r r r r r 5 s
|
ztzfile.utcoffsetc C s0 |d kr d S | j stS | |¡}|js*tS |jS r )Z _ttinfo_dstr r¯ r` rd )r r r¤ r r r r > s
|
z
|
tzfile.dstc C s | j r|d krd S | |¡jS r )r« r¯ ra r r r r r N s z tzfile.tznamec C s2 t |tstS | j|jko0| j|jko0| j|jkS r )r! r~ r# r¥ r¬ Z _ttinfo_listr% r r r r' T s
|
|
ÿ
|
þz tzfile.__eq__c C s
|
| |k S r r r% r r r r( ] s z tzfile.__ne__c C s d| j jt| jf S ©Nri )r+ r, rC r r- r r r r. ` s ztzfile.__repr__c C s
|
| d ¡S r )Ú __reduce_ex__r- r r r r4 c s ztzfile.__reduce__c C s | j d | jf| jfS r )r+ r Ú__dict__)r Úprotocolr r r r´ f s ztzfile.__reduce_ex__)N)F)N)r, r/ r0 r1 rA r
r r© r r¯ r r r® r r r r r' r2 r( r. r4 r´ r] r r rR r r~ s* G a
|
$
|
|
r~ c @ s6 e Zd ZdZd ddZdd Zdd Zed d
|
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 C s@ ddl ma || _|| _z | ¡ }W n ttfk
|
r< Y nX z | ¡ }W n ttfk
|
rb Y nX |d k r|tj|d| _ nt
|
| _ |d k rtj|d| _ n(|r¼|d k r¼| j tjdd | _ nt
|
| _ |rê|d krêtjdddt d¡d| _ n|| _ |r |d kr tjdd d
|
t d ¡d| _n|| _| j | j | _t| j | _d S ) Nr ©Ú relativedeltar6 r ©Úhoursé r )r» ÚmonthÚdayÚweekdayé
|
é r )Údateutilr¹ Ú _std_abbrÚ _dst_abbrr9 r: r; r< r= rI r rL ÚSUÚ _start_deltaÚ
|
_end_deltaÚ_dst_base_offset_rN Úhasdst)r ÚstdabbrÚ stdoffsetÚdstabbrrd ÚstartÚendr r r rA µ sJ ÿ
|
ÿ
|
ztzrange.__init__c C s4 | j s
|
dS t |dd¡}|| j }|| j }||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É r< rÆ rÇ )r ÚyearZ base_yearrÍ rÎ r r r Ú transitionsä s
|
|
ztzrange.transitionsc C sV t |tstS | j|jkoT| j|jkoT| j|jkoT| j|jkoT| j|jkoT| j|jkS r ) r! r· r# rà rÄ rI rL rÆ rÇ r% r r r r' ü s
|
|
ÿ
|
þ
|
ý
|
ü
|
ûztzrange.__eq__c C s | j S r )rÈ r- r r r Ú_dst_base_offset s ztzrange._dst_base_offset)NNNNN) r, r/ r0 r1 rA rÐ r' ÚpropertyrÑ r r r r r· j s J þ
|
/ r· c @ s, e Zd ZdZd ddZd ddZdd Zd
|
S ) Ú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 C s¸ ddl ma || _t |¡}|d ks*|jr2td|jdkrN|sN| jd9 _t j
|
| |j|j|j |j ddd |j sd | _ d | _n&| |j¡| _ | j r¨| j|jdd | _t| j | _d S )
|
Nr )Ú_parserzunknown string format©r\ r r F)rÍ rÎ r )Úisend)Zdateutil.parserrÔ ÚparserÚ_sZ_parsetzZany_unused_tokensr rÊ rË r· rA rÌ rd rÆ rÇ Ú_deltarÍ rÎ rN rÉ )r ÚsZ posix_offsetÚresr r r rA 7 s(
|
þztzstr.__init__r c C s: ddl m} i }|jd k rr|j|d< |jd k r`| |j|j¡|d< |jdkrVd|d< qpd|d< q|jr|j|d< n*|jd k r|j|d< n|jd k r|j|d < |sâ|sÄd
|
|d< d|d< | d¡|d< n d |d< d|d< | d ¡|d< |j d k rø|j |d < nd|d < |r.| j
|
| j }|d |j |j d 8 < |jf |S )Nr r¸ r½ r¿ r r¾ rÁ ZyeardayZ nlyeardayr rÀ r r7 i iQ )r r¹ r½ r¿ Úweekr¾ ZydayZjydayrÅ rG rL rI r7 Údays)r ÚxrÖ r¹ r} r_ r r r rÙ W s<
|
|
|
|
|
|
|
|
|
|
z tzstr._deltac C s d| j jt| jf S r³ ©r+ r, rC rØ r- r r r r. s ztzstr.__repr__N)F)r )r, r/ r0 r1 rA rÙ r. r r r r rÓ s )
|
|
)rÓ c @ s e Zd ZdddZdS )Ú_tzicalvtzcompNc C s@ t j|d| _t j|d| _| j| j | _|| _|| _|| _d S r5 )r< r= Ú tzoffsetfromÚ
|
tzoffsettoÚ tzoffsetdiffr` r Úrrule)r rá râ r` r rä r r r rA
s z_tzicalvtzcomp.__init__)NN)r, r/ r0 rA r r r r rà s ÿrà c sZ e Zd Zg f fdd Zdd Zdd Zdd Zd d
|
Zed d Z d d Z
|
e j Z Z S )Ú
|
_tzicalvtzc s4 t t| ¡ || _|| _g | _g | _t ¡ | _ d S r )
|
rF rå rA Ú_tzidÚ_compsÚ
|
_cachedateÚ
|
_cachecompr Ú allocate_lockÚ _cache_lock)r ÚtzidÚcompsrR r r rA s z_tzicalvtz.__init__c
|
C s4 t | jdkr| jd S |jd d}z<| j, | j| j || |¡f¡ W 5 Q R £ W S Q R X W n tk
|
rt Y nX d }d }| jD ](}| ||¡}|r|r¤||k r|}|}q|sÔ| jD ]}|j
|
s¸|} qÔq¸|d }| jP | j d|| |¡f¡ | j d|¡ t | jdkr&| j ¡ | j ¡ W 5 Q R X |S )Nr r ©r± rÀ ) rª rç Úreplacerë ré rè Úindexr[ r Ú _find_compdtr` ÚinsertÚpop)r r Z
|
lastcompdtZlastcompÚcompÚcompdtr r r Ú
|
_find_comp s<
|
|
ÿ
|
|
|
z_tzicalvtz._find_compc C s2 |j tk r | |¡r ||j 8 }|jj|dd}|S )NT)Úinc)rã r r[ rä Zbefore)r rô r rõ r r r rñ Æ s
|
z_tzicalvtz._find_compdtc C s |d kr d S | |¡jS r )rö râ r r r r r Î s z_tzicalvtz.utcoffsetc C s | |¡}|jr|jS tS d S r )rö r` rã r )r r rô r r r r Ô s
|
z_tzicalvtz.dstc C s | |¡jS r )rö r r r r r r Û s z_tzicalvtz.tznamec C s dt | j S )Nz<tzicalvtz %s>)rC ræ r- r r r r. ß s z_tzicalvtz.__repr__)r, r/ r0 rA rö rñ r r r r r. r3 r4 r] r r rR r rå s -
|
rå c @ sB e Zd ZdZdd Zdd ZdddZd d
|
Zd d Zd d 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 C sj ddl ma t|tr(|| _t|d}nt|dt|| _t|}i | _ |}|
|
| ¡ ¡ W 5 Q R X d S )Nr )rä Úrr? ) r rä r! r rØ r rZ rC r Ú_vtzÚ
|
_parse_rfcr )r r Zfobjr r r rA ð s
|
ztzical.__init__c C s t | j ¡ S )z?
|
Retrieves the available time zones as a list.
|
)r rú Úkeysr- r r r rü s z tzical.keysNc C sP |dkrDt | jdkr tdnt | jdkr6tdtt| 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ª rú r ÚnextÚiterr| )r rì r r r r| s
|
z
|
tzical.getc C sÒ | ¡ }|std|d dkr>d|d dk }|dd
}nd}t|dkrzt|d d
d t|dd
d
|
| S t|d krÂt|d d
d t|dd
d
|
t|dd
| S td | d S ) Nz empty offsetr )ú+ú-)r r rÿ r r r¼ i é< r zinvalid offset: )Ústripr rª rD )r rÚ Úsignalr r r Ú _parse_offset" s , <ztzical._parse_offsetc C sb | ¡ }|stdd}|t|k r~|| ¡ }|s<||= q|dkrt|d dkrt||d |dd
7 < ||= q|d7 }qd }g }d}d }|D ]È}|sq| dd¡\} }
|
| d¡} | sÄtd| d ¡ } | dd
} |r@| d kr |
|
d
|
krön td |
|
|
|
}d} d } d }g }d }q\| d kr|
|
d krv|rDtd| |sRtd|s`tdt||| j|< d}n|
|
|krø| std| d kr td|d kr²tdd }|rÔtj d
|
|¡dddd}t | ||dk||}| |¡ d }n td|
|
q\|r | dkrN| D ] }|dkr d| }t|q | |¡ d} n°| dkrd| |¡ n| d kr| rtd | | d f | |
|
¡} nj| d krÀ| r´td | d | |
|
¡}n>| d kræ| ràtd!| d |
|
}n| d"kròn td#| n>| d$kr&| r td%| d |
|
}n| d&kr2n td#| q| d kr|
|
d krd }g }d}qd S )'Nz empty stringr ú r Fú:ú;zempty property nameZBEGIN)ZSTANDARDÚDAYLIGHTzunknown component: ZENDZ VTIMEZONEzcomponent not closed: zmandatory TZID not foundz at least one component is neededzmandatory DTSTART not foundz mandatory TZOFFSETFROM not foundÚ
|
T)Ú
|
compatibleZignoretzÚcacher zinvalid component end: ZDTSTARTzVALUE=DATE-TIMEz(Unsupported DTSTART param in VTIMEZONE: )ZRRULEZRDATEZEXRULEZEXDATEZ TZOFFSETFROMzunsupported %s parm: %s Z
|
TZOFFSETTOz unsupported TZOFFSETTO parm: ZTZNAMEzunsupported TZNAME parm: ÚCOMMENTzunsupported property: ZTZIDzunsupported TZID parm: )ZTZURLz LAST-MODIFIEDr )Ú
|
splitlinesr rª ÚrstripÚsplitÚupperrå rú rä Zrrulestrrk rà rj r )r rÚ Úlinesr¢ Úlinerì rí ZinvtzÚcomptyper? rm ZparmsZ founddtstartrá râ Z
|
rrulelinesr Úrrrô ZparmÚmsgr r r rû 2 sð
|
|
|
|
|
|
ÿ
|
|
ÿ
|
ÿ ý þ
|
|
|
ÿ
|
|
|
ÿ
|
|
ÿ
|
|
ÿ
|
|
|
ÿ
|
ztzical._parse_rfcc C s d| j jt| jf S r³ rß r- r r r r. ¯ s ztzical.__repr__)N)
|
r, r/ r0 r1 rA rü r| r rû r. r r r r rø å s
|
|
}rø Úwin32z/etc/localtimerV z/usr/share/zoneinfoz/usr/lib/zoneinfoz/usr/share/lib/zoneinfoz /etc/zoneinfoc s2 t f td k r tf7 G fdddt} | S )Nc sD e Zd ZdZdd Zd fdd Zdd Zd d
|
Zedd d Z dS )z __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 S s& t ¡ | _d| _t | _t ¡ | _d S )Nr ) ÚweakrefÚWeakValueDictionaryÚ_GettzFunc__instancesÚ _GettzFunc__strong_cache_sizer Ú_GettzFunc__strong_cacher rê rë r- r r r rA s
|
z'__get_gettz.<locals>.GettzFunc.__init__Nc
|
s | j | j |d ¡}|d kr`| j|d}|d ksPt| sP|d ksP|| j|< n|W 5 Q R £ S | j ||¡| j|< t| j| jkr| jj dd W 5 Q R X |S )N)r? F©Úlast)
|
rë r r| Únocacher! r ró rª r Úpopitem)r r? Úrv©Ztzlocal_classesr r Ú__call__ s ÿþ z'__get_gettz.<locals>.GettzFunc.__call__c S s: | j * || _t| j|kr,| jjdd qW 5 Q R X d S )NFr )rë r rª r r )r Úsizer r r Úset_cache_size+ s z-__get_gettz.<locals>.GettzFunc.set_cache_sizec S s* | j t ¡ | _| j ¡ W 5 Q R X d S r )rë r r r r Úclearr- r r r Ú cache_clear1 s
|
z*__get_gettz.<locals>.GettzFunc.cache_clearc S s d}| s,zt jd } W n tk
|
r* Y nX | dks<| dkrÄtD ]x}t j |¡s~|}tD ]"}t j ||¡}t j |¡rX q~qXq@t j |¡r@zt |}W qÀW q@ t
|
t t fk
|
r¶ Y q@X q@t }nÊz| d¡rÜ| dd
} W nH tk
|
r& } z(t| trd}t t||¡ n W 5 d}~X Y nX t j | ¡rVt j | ¡rNt | }nd}n8tD ]r}t j || ¡}t j |¡s| dd¡}t j |¡sqZzt |}W qW n t
|
t t fk
|
rÈ Y nX qZd}tdk rz t| }W n ttfk
|
r d}Y nX |s&d d
|
lm} | | ¡}|s| D ]:}|d kr0z t| }W n t k
|
r` Y nX qq0| d kr|t }n| t j krt }|S ) z A non-cached version of gettzNZTZ)Ú r r r z'gettz argument should be str, not bytesr r r )Úget_zonefile_instanceÚ
|
0123456789rÕ ) r ÚenvironÚKeyErrorÚTZFILESÚpathÚisabsÚTZPATHSrk Úisfiler~ ÚIOErrorÚOSErrorr rE Ú
|
startswithr: r! ÚbytesÚsixÚ
|
raise_fromrï r Ú WindowsErrorÚUnicodeEncodeErrorZdateutil.zoneinfor( r| rÓ r rG r ) r? ÚtzÚfilepathr r- ÚeZnew_msgr( Úcr r r r 6 s
|
|
|
|
|
|
|
|
|
|
z&__get_gettz.<locals>.GettzFunc.nocache)N)N)
|
r, r/ r0 r1 rA r" r$ r& Ú staticmethodr r r! r r Ú GettzFuncà s Er> )rE r r3 )r> r r! r Ú __get_gettz¾ s
|
Jr? c C sX |dkr | j dkrtd| j }| jdd} | j|d t¡ |¡}|jdd}| |kS )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.rî )r± r rï Ú
|
astimezoner )r r9 Zdt_rtr r r Údatetime_exists s
|
rB c C s¤ |dkr | j dkrtd| j }t|dd}|dk rVz | | ¡W S tk
|
rT Y nX | j|d} t| dd}t| dd}| ¡ | ¡ 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 rî r r° r ) r± r rZ r Ú Exceptionrï r r r )r r9 Zis_ambiguous_fnZwall_0Zwall_1Z same_offsetZsame_dstr r r Údatetime_ambiguousµ s
|
rD c C sJ | j dk rFt| sF| tjdd ¡ }| tjdd ¡ }| || 7 } | 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± rB r< r= r )r Z curr_offsetÚ
|
old_offsetr r r Úresolve_imaginaryã s
|
$ rF c C s | j ddt ¡ S )z
|
Convert a :class:`datetime.datetime` object to an epoch timestamp in
|
seconds since January 1, 1970, ignoring the time zone.
|
Nrî )rï ÚEPOCHr9 )r r r r rU s rU )é r c C s | S r r )Ú second_offsetr r r r> s r> c C s | }d| d d }|S )Nr é r )rI rE Zcalculated_offsetr r r r> s )Ú nullcontextc @ s( e Zd ZdZdd Zdd Zdd ZdS ) r zj
|
Class for wrapping contexts so that they are passed through in a
|
with statement.
|
c C s
|
|| _ d S r ©Úcontext)r rM r r r rA 0 s z_nullcontext.__init__c C s | j S r rL r- r r r Ú __enter__3 s z_nullcontext.__enter__c O s d S r r )Úargsr} r r r Ú__exit__6 s z_nullcontext.__exit__N)r, r/ r0 r1 rA rN rP r r r r r + s r )N)N)Ar1 r< r rG Úsysr r¦ r Ú collectionsr r5 r Z six.movesr Z_commonr r r r r
|
Z
|
_factoriesr r r Úwinr r Ú ImportErrorÚwarningsr r= r ÚutcfromtimestamprG Ú toordinalZ EPOCHORDINALÚ add_metaclassr± r r r" rE r3 r^ rr r~ r· rÓ rà rå rø Úplatformr, r/ r? ZgettzrB rD rF rU Ú version_infor> Ú
|
contextlibrK r r r r r Ú<module> s
|
WD- k #w V O ý R
|
"
|
..
|
|
|
