U
|
¥ý°dHK ã @ sê d Z ddlmZmZmZ ddlmZ ze W n ek
|
rL ddlm Z Y nX ddl
|
Z
|
ddl m Z m Z g Zi Zdd Ze d¡ZdeiZd d
|
Zi Zd d ZedZd d ZG dd deZG dd deZG dd deZdddZ dS )zBBase classes and helpers for building zone specific tzinfo classesé )ÚdatetimeÚ timedeltaÚtzinfo)Ú bisect_right)ÚSetN)ÚAmbiguousTimeErrorÚNonExistentTimeErrorc C s: z
|
t | W S tk
|
r4 t| d}|t | < | Y S X dS )z3Create only one instance of each distinct timedelta©ÚsecondsN)Ú_timedelta_cacheÚKeyErrorr )r
|
Údelta© r úBd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\pytz/tzinfo.pyÚmemorized_timedelta s
|
|
r c C s> z
|
t | W S tk
|
r8 tt| d }|t | < | Y S X dS )z2Create only one instance of each distinct datetimer N)Ú_datetime_cacher Ú_epochr )r
|
Údtr r r Úmemorized_datetime s
|
r c G sN z
|
t | W S tk
|
rH t| d t| d | d f}|t | < | Y S X dS )z/Create only one instance of each distinct tupler é é N)Ú _ttinfo_cacher r )ÚargsZttinfor r r Úmemorized_ttinfo- s
|
|
|
ýr c C s | j | jd d d S )z Convert a timedelta to secondsé é< )r
|
Údays)Útdr r r Ú _to_seconds= s r c @ s e Zd ZdZdZdZdd ZdS )Ú
|
BaseTzInfoNc C s | j S ©N©Úzone©Úselfr r r Ú__str__H s zBaseTzInfo.__str__)Ú__name__Ú
|
__module__Ú __qualname__Ú
|
_utcoffsetÚ_tznamer" r% r r r r r B s r c @ sZ e Zd ZdZdd ZdddZdddZdd d
|
Zdd d ZdddZ dd Z
|
dd Z dS )Ú StaticTzInfoz¡A timezone that has a constant offset from UTC
|
|
These timezones are rare, as most locations have changed their
|
offset at some point in their history
|
c C s. |j dk r |j | k r td|| j j| dS )úSee datetime.tzinfo.fromutcNú fromutc: dt.tzinfo is not self©r )r Ú
|
ValueErrorr) Úreplace)r$ r r r r ÚfromutcR s zStaticTzInfo.fromutcNc C s | j S )zSee datetime.tzinfo.utcoffset
|
|
is_dst is ignored for StaticTzInfo, and exists only to
|
retain compatibility with DstTzInfo.
|
)r) ©r$ r Úis_dstr r r Ú utcoffsetX s zStaticTzInfo.utcoffsetc C s t S )zSee datetime.tzinfo.dst
|
|
is_dst is ignored for StaticTzInfo, and exists only to
|
retain compatibility with DstTzInfo.
|
)Ú_notimer2 r r r Údst` s zStaticTzInfo.dstc C s | j S )zSee datetime.tzinfo.tzname
|
|
is_dst is ignored for StaticTzInfo, and exists only to
|
retain compatibility with DstTzInfo.
|
)r* r2 r r r Útznameh s zStaticTzInfo.tznameFc C s |j dk rtd|j| dS )z Convert naive time to local timeNú*Not naive datetime (tzinfo is already set)r. )r r/ r0 r2 r r r Úlocalizep s
|
zStaticTzInfo.localizec C s* |j | kr|S |j dkr td| | ¡S )a Correct the timezone information on the given datetime.
|
|
This is normally a no-op, as StaticTzInfo timezones never have
|
ambiguous cases to correct:
|
|
>>> from pytz import timezone
|
>>> gmt = timezone('GMT')
|
>>> isinstance(gmt, StaticTzInfo)
|
True
|
>>> dt = datetime(2011, 5, 8, 1, 2, 3, tzinfo=gmt)
|
>>> gmt.normalize(dt) is dt
|
True
|
|
The supported method of converting between timezones is to use
|
datetime.astimezone(). Currently normalize() also works:
|
|
>>> la = timezone('America/Los_Angeles')
|
>>> dt = la.localize(datetime(2011, 5, 7, 1, 2, 3))
|
>>> fmt = '%Y-%m-%d %H:%M:%S %Z (%z)'
|
>>> gmt.normalize(dt).strftime(fmt)
|
'2011-05-07 08:02:03 GMT (+0000)'
|
NúNaive time - no tzinfo set)r r/ Ú
|
astimezoner2 r r r Ú normalizev s
|
|
|
zStaticTzInfo.normalizec C s d| j f S )Nz<StaticTzInfo %r>r! r# r r r Ú__repr__ s zStaticTzInfo.__repr__c C s t j| jffS r )ÚpytzÚ_pr" r# r r r Ú
|
__reduce__ s zStaticTzInfo.__reduce__)N)N)N)F)F) r& r' r( Ú__doc__r1 r4 r6 r7 r9 r< r= r@ r r r r r+ L s
|
|
|
|
|
r+ c @ sv e Zd ZdZdZdZdZdZdZdddZ dd Z
|
dd Z dd
|
d Z dd d Z dddZdddZdd Zdd ZdS )Ú DstTzInfozÙA timezone that has a variable offset from UTC
|
|
The offset might change if daylight saving time comes into effect,
|
or at a point in history when the region decides to change their
|
timezone definition.
|
Nc C sz |r || _ |\| _| _| _nZi }|| _ | jd \| _| _| _| || jd < | jdd
D ] }||krX| ||¡||< qXd S )Nr r )Ú_tzinfosr) Ú_dstr* Ú_transition_infoÚ __class__)r$ Ú_infrC Úinfr r r Ú__init__³ s ÿzDstTzInfo.__init__c C sl |j dk r&t|j dd| jk r&td|jdd}tdt| j|d }| j| }||d j| j| dS )r, NrC r- r. r r ) r ÚgetattrrC r/ r0 Úmaxr Ú_utc_transition_timesrE )r$ r ÚidxrH r r r r1 Á s
|
ÿ
|
zDstTzInfo.fromutcc C s8 |j dkrtd|j j}|jdd}|| }| |¡S )aI Correct the timezone information on the given datetime
|
|
If date arithmetic crosses DST boundaries, the tzinfo
|
is not magically adjusted. This method normalizes the
|
tzinfo to the correct one.
|
|
To test, first we need to do some setup
|
|
>>> from pytz import timezone
|
>>> utc = timezone('UTC')
|
>>> eastern = timezone('US/Eastern')
|
>>> fmt = '%Y-%m-%d %H:%M:%S %Z (%z)'
|
|
We next create a datetime right on an end-of-DST transition point,
|
the instant when the wallclocks are wound back one hour.
|
|
>>> utc_dt = datetime(2002, 10, 27, 6, 0, 0, tzinfo=utc)
|
>>> loc_dt = utc_dt.astimezone(eastern)
|
>>> loc_dt.strftime(fmt)
|
'2002-10-27 01:00:00 EST (-0500)'
|
|
Now, if we subtract a few minutes from it, note that the timezone
|
information has not changed.
|
|
>>> before = loc_dt - timedelta(minutes=10)
|
>>> before.strftime(fmt)
|
'2002-10-27 00:50:00 EST (-0500)'
|
|
But we can fix that by calling the normalize method
|
|
>>> before = eastern.normalize(before)
|
>>> before.strftime(fmt)
|
'2002-10-27 01:50:00 EDT (-0400)'
|
|
The supported method of converting between timezones is to use
|
datetime.astimezone(). Currently, normalize() also works:
|
|
>>> th = timezone('Asia/Bangkok')
|
>>> am = timezone('Europe/Amsterdam')
|
>>> dt = th.localize(datetime(2011, 5, 7, 1, 2, 3))
|
>>> fmt = '%Y-%m-%d %H:%M:%S %Z (%z)'
|
>>> am.normalize(dt).strftime(fmt)
|
'2011-05-06 20:02:03 CEST (+0200)'
|
Nr: r. )r r/ r) r0 r1 )r$ r Úoffsetr r r r< Ë s -
|
zDstTzInfo.normalizeFc s¬ |j dk rtdt }tddtddfD ]b}|| }tdt| j|d }| j| }| j| }| |j
|
|d¡}|j
|
dd|kr,| |¡ q,t |dkr¤| ¡ S t |dkr dkrÄt|nH rê| j|tdd d
|
d tdd S | j|tdd d d tdd S dkr t| fd d|D } t | dkrF| d S t | dkr\t|} i }
|
| D ]0} | j
|
dd| j j } | |
|
kst| |
|
| < qd|
|
ttg |
|
S )aè Convert naive time to local time.
|
|
This method should be used to construct localtimes, rather
|
than passing a tzinfo argument to a datetime constructor.
|
|
is_dst is used to determine the correct timezone in the ambigous
|
period at the end of daylight saving time.
|
|
>>> from pytz import timezone
|
>>> fmt = '%Y-%m-%d %H:%M:%S %Z (%z)'
|
>>> amdam = timezone('Europe/Amsterdam')
|
>>> dt = datetime(2004, 10, 31, 2, 0, 0)
|
>>> loc_dt1 = amdam.localize(dt, is_dst=True)
|
>>> loc_dt2 = amdam.localize(dt, is_dst=False)
|
>>> loc_dt1.strftime(fmt)
|
'2004-10-31 02:00:00 CEST (+0200)'
|
>>> loc_dt2.strftime(fmt)
|
'2004-10-31 02:00:00 CET (+0100)'
|
>>> str(loc_dt2 - loc_dt1)
|
'1:00:00'
|
|
Use is_dst=None to raise an AmbiguousTimeError for ambiguous
|
times at the end of daylight saving time
|
|
>>> try:
|
... loc_dt1 = amdam.localize(dt, is_dst=None)
|
... except AmbiguousTimeError:
|
... print('Ambiguous')
|
Ambiguous
|
|
is_dst defaults to False
|
|
>>> amdam.localize(dt) == amdam.localize(dt, False)
|
True
|
|
is_dst is also used to determine the correct timezone in the
|
wallclock times jumped over at the start of daylight saving time.
|
|
>>> pacific = timezone('US/Pacific')
|
>>> dt = datetime(2008, 3, 9, 2, 0, 0)
|
>>> ploc_dt1 = pacific.localize(dt, is_dst=True)
|
>>> ploc_dt2 = pacific.localize(dt, is_dst=False)
|
>>> ploc_dt1.strftime(fmt)
|
'2008-03-09 02:00:00 PDT (-0700)'
|
>>> ploc_dt2.strftime(fmt)
|
'2008-03-09 02:00:00 PST (-0800)'
|
>>> str(ploc_dt2 - ploc_dt1)
|
'1:00:00'
|
|
Use is_dst=None to raise a NonExistentTimeError for these skipped
|
times.
|
|
>>> try:
|
... loc_dt1 = pacific.localize(dt, is_dst=None)
|
... except NonExistentTimeError:
|
... print('Non-existent')
|
Non-existent
|
Nr8 éÿÿÿÿ)r r r r. é )ÚhoursT©r3 Fc s g | ]}t |jj kr|qS r )Úboolr rD )Ú.0ÚprR r r Ú
|
<listcomp>o s z&DstTzInfo.localize.<locals>.<listcomp>)r r/ Úsetr rK r rL rE rC r< r0 ÚaddÚlenÚpopr r9 r Úlistr) ÚAssertionErrorÚmin) r$ r r3 Zpossible_loc_dtr Zloc_dtrM rH r Zfiltered_possible_loc_dtÚdatesZlocal_dtZutc_timer rR r r9 sd ;
|
ÿÿ
|
|
|
ÿÿ þþ
|
|
ÿ ÿ zDstTzInfo.localizec C s4 |dkr dS |j | k r*| ||¡}|j jS | jS dS )aL See datetime.tzinfo.utcoffset
|
|
The is_dst parameter may be used to remove ambiguity during DST
|
transitions.
|
|
>>> from pytz import timezone
|
>>> tz = timezone('America/St_Johns')
|
>>> ambiguous = datetime(2009, 10, 31, 23, 30)
|
|
>>> str(tz.utcoffset(ambiguous, is_dst=False))
|
'-1 day, 20:30:00'
|
|
>>> str(tz.utcoffset(ambiguous, is_dst=True))
|
'-1 day, 21:30:00'
|
|
>>> try:
|
... tz.utcoffset(ambiguous)
|
... except AmbiguousTimeError:
|
... print('Ambiguous')
|
Ambiguous
|
|
N)r r9 r) r2 r r r r4 s
|
zDstTzInfo.utcoffsetc C s4 |dkr dS |j | k r*| ||¡}|j jS | jS dS )aþ See datetime.tzinfo.dst
|
|
The is_dst parameter may be used to remove ambiguity during DST
|
transitions.
|
|
>>> from pytz import timezone
|
>>> tz = timezone('America/St_Johns')
|
|
>>> normal = datetime(2009, 9, 1)
|
|
>>> str(tz.dst(normal))
|
'1:00:00'
|
>>> str(tz.dst(normal, is_dst=False))
|
'1:00:00'
|
>>> str(tz.dst(normal, is_dst=True))
|
'1:00:00'
|
|
>>> ambiguous = datetime(2009, 10, 31, 23, 30)
|
|
>>> str(tz.dst(ambiguous, is_dst=False))
|
'0:00:00'
|
>>> str(tz.dst(ambiguous, is_dst=True))
|
'1:00:00'
|
>>> try:
|
... tz.dst(ambiguous)
|
... except AmbiguousTimeError:
|
... print('Ambiguous')
|
Ambiguous
|
|
N)r r9 rD r2 r r r r6 « s
|
z DstTzInfo.dstc C s6 |dkr| j S |j| k r,| ||¡}|jjS | jS dS )aå See datetime.tzinfo.tzname
|
|
The is_dst parameter may be used to remove ambiguity during DST
|
transitions.
|
|
>>> from pytz import timezone
|
>>> tz = timezone('America/St_Johns')
|
|
>>> normal = datetime(2009, 9, 1)
|
|
>>> tz.tzname(normal)
|
'NDT'
|
>>> tz.tzname(normal, is_dst=False)
|
'NDT'
|
>>> tz.tzname(normal, is_dst=True)
|
'NDT'
|
|
>>> ambiguous = datetime(2009, 10, 31, 23, 30)
|
|
>>> tz.tzname(ambiguous, is_dst=False)
|
'NST'
|
>>> tz.tzname(ambiguous, is_dst=True)
|
'NDT'
|
>>> try:
|
... tz.tzname(ambiguous)
|
... except AmbiguousTimeError:
|
... print('Ambiguous')
|
Ambiguous
|
N)r" r r9 r* r2 r r r r7 Ò s
|
zDstTzInfo.tznamec C sJ | j r d}nd}| jtkr0d| j| j| j|f S d| j| j| j|f S d S )NZDSTZSTDz<DstTzInfo %r %s+%s %s>z<DstTzInfo %r %s%s %s>)rD r) r5 r" r* )r$ r6 r r r r= ø s
|
ÿ ÿzDstTzInfo.__repr__c C s" t j| jt| jt| j| jffS r )r> r? r" r r) rD r* r# r r r r@ s üzDstTzInfo.__reduce__)NN)F)N)N)N)r& r' r( rA rL rE r" rC rD rI r1 r< r9 r4 r6 r7 r= r@ r r r r rB s
|
|
7
|
|
|
'
|
&rB c C s¢ t | ¡}|dkr|S t|}t|}z|j|||f W S tk
|
rL Y nX |j ¡ D ] }|j|krX|j|krX| S qX|||f}| ||j¡|j|< |j| S )a% Factory function for unpickling pytz tzinfo instances.
|
|
This is shared for both StaticTzInfo and DstTzInfo instances, because
|
database changes could cause a zones implementation to switch between
|
these two base classes and we can't break pickles on a pytz version
|
upgrade.
|
N) r> Útimezoner rC r Úvaluesr) rD rF )r" r4 Z dstoffsetr7 ÚtzZ localized_tzrH r r r Ú unpickler s"
|
|
|
ÿ
|
|
rb )NNN) rA r r r Úbisectr rW Ú NameErrorZsetsr r> Zpytz.exceptionsr r Ú__all__r r Úutcfromtimestampr r r r r r5 r r r+ rB rb r r r r Ú<module> s0
|
|
P w
|
