File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/pytz.tar
Back
reference.py 0000644 00000007302 15030534450 0007055 0 ustar 00 ''' Reference tzinfo implementations from the Python docs. Used for testing against as they are only correct for the years 1987 to 2006. Do not use these for real code. ''' from datetime import tzinfo, timedelta, datetime from pytz import HOUR, ZERO, UTC __all__ = [ 'FixedOffset', 'LocalTimezone', 'USTimeZone', 'Eastern', 'Central', 'Mountain', 'Pacific', 'UTC' ] # A class building tzinfo objects for fixed-offset time zones. # Note that FixedOffset(0, "UTC") is a different way to build a # UTC tzinfo object. class FixedOffset(tzinfo): """Fixed offset in minutes east from UTC.""" def __init__(self, offset, name): self.__offset = timedelta(minutes=offset) self.__name = name def utcoffset(self, dt): return self.__offset def tzname(self, dt): return self.__name def dst(self, dt): return ZERO import time as _time STDOFFSET = timedelta(seconds=-_time.timezone) if _time.daylight: DSTOFFSET = timedelta(seconds=-_time.altzone) else: DSTOFFSET = STDOFFSET DSTDIFF = DSTOFFSET - STDOFFSET # A class capturing the platform's idea of local time. class LocalTimezone(tzinfo): def utcoffset(self, dt): if self._isdst(dt): return DSTOFFSET else: return STDOFFSET def dst(self, dt): if self._isdst(dt): return DSTDIFF else: return ZERO def tzname(self, dt): return _time.tzname[self._isdst(dt)] def _isdst(self, dt): tt = (dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second, dt.weekday(), 0, -1) stamp = _time.mktime(tt) tt = _time.localtime(stamp) return tt.tm_isdst > 0 Local = LocalTimezone() def first_sunday_on_or_after(dt): days_to_go = 6 - dt.weekday() if days_to_go: dt += timedelta(days_to_go) return dt # In the US, DST starts at 2am (standard time) on the first Sunday in April. DSTSTART = datetime(1, 4, 1, 2) # and ends at 2am (DST time; 1am standard time) on the last Sunday of Oct. # which is the first Sunday on or after Oct 25. DSTEND = datetime(1, 10, 25, 1) # A complete implementation of current DST rules for major US time zones. class USTimeZone(tzinfo): def __init__(self, hours, reprname, stdname, dstname): self.stdoffset = timedelta(hours=hours) self.reprname = reprname self.stdname = stdname self.dstname = dstname def __repr__(self): return self.reprname def tzname(self, dt): if self.dst(dt): return self.dstname else: return self.stdname def utcoffset(self, dt): return self.stdoffset + self.dst(dt) def dst(self, dt): if dt is None or dt.tzinfo is None: # An exception may be sensible here, in one or both cases. # It depends on how you want to treat them. The default # fromutc() implementation (called by the default astimezone() # implementation) passes a datetime with dt.tzinfo is self. return ZERO assert dt.tzinfo is self # Find first Sunday in April & the last in October. start = first_sunday_on_or_after(DSTSTART.replace(year=dt.year)) end = first_sunday_on_or_after(DSTEND.replace(year=dt.year)) # Can't compare naive to aware objects, so strip the timezone from # dt first. if start <= dt.replace(tzinfo=None) < end: return HOUR else: return ZERO Eastern = USTimeZone(-5, "Eastern", "EST", "EDT") Central = USTimeZone(-6, "Central", "CST", "CDT") Mountain = USTimeZone(-7, "Mountain", "MST", "MDT") Pacific = USTimeZone(-8, "Pacific", "PST", "PDT") lazy.py 0000644 00000012434 15030534450 0006100 0 ustar 00 from threading import RLock try: from collections.abc import Mapping as DictMixin except ImportError: # Python < 3.3 try: from UserDict import DictMixin # Python 2 except ImportError: # Python 3.0-3.3 from collections import Mapping as DictMixin # With lazy loading, we might end up with multiple threads triggering # it at the same time. We need a lock. _fill_lock = RLock() class LazyDict(DictMixin): """Dictionary populated on first use.""" data = None def __getitem__(self, key): if self.data is None: _fill_lock.acquire() try: if self.data is None: self._fill() finally: _fill_lock.release() return self.data[key.upper()] def __contains__(self, key): if self.data is None: _fill_lock.acquire() try: if self.data is None: self._fill() finally: _fill_lock.release() return key in self.data def __iter__(self): if self.data is None: _fill_lock.acquire() try: if self.data is None: self._fill() finally: _fill_lock.release() return iter(self.data) def __len__(self): if self.data is None: _fill_lock.acquire() try: if self.data is None: self._fill() finally: _fill_lock.release() return len(self.data) def keys(self): if self.data is None: _fill_lock.acquire() try: if self.data is None: self._fill() finally: _fill_lock.release() return self.data.keys() class LazyList(list): """List populated on first use.""" _props = [ '__str__', '__repr__', '__unicode__', '__hash__', '__sizeof__', '__cmp__', '__lt__', '__le__', '__eq__', '__ne__', '__gt__', '__ge__', 'append', 'count', 'index', 'extend', 'insert', 'pop', 'remove', 'reverse', 'sort', '__add__', '__radd__', '__iadd__', '__mul__', '__rmul__', '__imul__', '__contains__', '__len__', '__nonzero__', '__getitem__', '__setitem__', '__delitem__', '__iter__', '__reversed__', '__getslice__', '__setslice__', '__delslice__'] def __new__(cls, fill_iter=None): if fill_iter is None: return list() # We need a new class as we will be dynamically messing with its # methods. class LazyList(list): pass fill_iter = [fill_iter] def lazy(name): def _lazy(self, *args, **kw): _fill_lock.acquire() try: if len(fill_iter) > 0: list.extend(self, fill_iter.pop()) for method_name in cls._props: delattr(LazyList, method_name) finally: _fill_lock.release() return getattr(list, name)(self, *args, **kw) return _lazy for name in cls._props: setattr(LazyList, name, lazy(name)) new_list = LazyList() return new_list # Not all versions of Python declare the same magic methods. # Filter out properties that don't exist in this version of Python # from the list. LazyList._props = [prop for prop in LazyList._props if hasattr(list, prop)] class LazySet(set): """Set populated on first use.""" _props = ( '__str__', '__repr__', '__unicode__', '__hash__', '__sizeof__', '__cmp__', '__lt__', '__le__', '__eq__', '__ne__', '__gt__', '__ge__', '__contains__', '__len__', '__nonzero__', '__getitem__', '__setitem__', '__delitem__', '__iter__', '__sub__', '__and__', '__xor__', '__or__', '__rsub__', '__rand__', '__rxor__', '__ror__', '__isub__', '__iand__', '__ixor__', '__ior__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update') def __new__(cls, fill_iter=None): if fill_iter is None: return set() class LazySet(set): pass fill_iter = [fill_iter] def lazy(name): def _lazy(self, *args, **kw): _fill_lock.acquire() try: if len(fill_iter) > 0: for i in fill_iter.pop(): set.add(self, i) for method_name in cls._props: delattr(LazySet, method_name) finally: _fill_lock.release() return getattr(set, name)(self, *args, **kw) return _lazy for name in cls._props: setattr(LazySet, name, lazy(name)) new_set = LazySet() return new_set # Not all versions of Python declare the same magic methods. # Filter out properties that don't exist in this version of Python # from the list. LazySet._props = [prop for prop in LazySet._props if hasattr(set, prop)] __pycache__/reference.cpython-310.pyc 0000644 00000007356 15030534450 0013425 0 ustar 00 o �<<b� � @ s d Z ddlmZmZmZ ddlmZmZmZ g d�ZG dd� de�Z ddl Z ee j d�Z e jr8ee j d�Zne Zee ZG d d � d e�Ze� Zd d � Zed dd d�Zed ddd �ZG dd� de�Zedddd�Zedddd�Zed d d d �Zed d!d"d#�ZdS )$z� Reference tzinfo implementations from the Python docs. Used for testing against as they are only correct for the years 1987 to 2006. Do not use these for real code. � )�tzinfo� timedelta�datetime)�HOUR�ZERO�UTC)� FixedOffset� LocalTimezone� USTimeZone�Eastern�Central�Mountain�Pacificr c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) r z&Fixed offset in minutes east from UTC.c C s t |d�| _|| _d S )N)�minutes)r �_FixedOffset__offset�_FixedOffset__name)�self�offset�name� r �0/usr/lib/python3/dist-packages/pytz/reference.py�__init__ s zFixedOffset.__init__c C � | j S �N)r �r �dtr r r � utcoffset � zFixedOffset.utcoffsetc C r r )r r r r r �tzname# r zFixedOffset.tznamec C s t S r )r r r r r �dst& s zFixedOffset.dstN)�__name__� __module__� __qualname__�__doc__r r r r r r r r r s r N)�secondsc @ s, e Zd Zdd� Zdd� Zdd� Zdd� Zd S ) r c C � | � |�rtS tS r )�_isdst� DSTOFFSET� STDOFFSETr r r r r 8 � zLocalTimezone.utcoffsetc C r% r )r& �DSTDIFFr r r r r r > r) zLocalTimezone.dstc C s t j| �|� S r )�_timer r& r r r r r D � zLocalTimezone.tznamec C sD |j |j|j|j|j|j|�� ddf }t�|�}t� |�}|j dkS )Nr ���) �year�month�day�hour�minute�second�weekdayr+ �mktime� localtime�tm_isdst)r r �tt�stampr r r r& G s � zLocalTimezone._isdstN)r r! r" r r r r& r r r r r 6 s r c C s d| � � }|r| t|�7 } | S )N� )r4 r )r � days_to_gor r r �first_sunday_on_or_afterR s r< � � � � � c @ s4 e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd S ) r c C s" t |d�| _|| _|| _|| _d S )N)�hours)r � stdoffset�reprname�stdname�dstname)r rB rD rE rF r r r r c s zUSTimeZone.__init__c C r r )rD )r r r r �__repr__i r zUSTimeZone.__repr__c C s | � |�r| jS | jS r )r rF rE r r r r r l s zUSTimeZone.tznamec C s | j | �|� S r )rC r r r r r r r r, zUSTimeZone.utcoffsetc C sp |d u s |j d u r tS |j | u sJ �ttj|jd��}ttj|jd��}||jd d� kr3|k r6tS tS tS )N)r. )r )r r r< �DSTSTART�replacer. �DSTENDr )r r �start�endr r r r u s �zUSTimeZone.dstN)r r! r" r rG r r r r r r r r a s r ���r �EST�EDTi����r �CST�CDTi����r �MST�MDTi����r �PST�PDT) r# r r r �pytzr r r �__all__r �timer+ �timezoner( �daylight�altzoner' r* r �Localr< rH rJ r r r r r r r r r �<module> s* ( __pycache__/exceptions.cpython-310.pyc 0000644 00000004032 15030534450 0013634 0 ustar 00 o �<<b# � @ sb d Z g d�ZG dd� de�ZG dd� dee�ZG dd� de�ZG dd � d e�ZG d d � d e�Zd S ) z# Custom exceptions raised by pytz. )�UnknownTimeZoneError�InvalidTimeError�AmbiguousTimeError�NonExistentTimeErrorc @ � e Zd ZdZdS )�Errorz8Base class for all exceptions raised by the pytz libraryN��__name__� __module__� __qualname__�__doc__� r r �1/usr/lib/python3/dist-packages/pytz/exceptions.pyr � r c @ r )r a� Exception raised when pytz is passed an unknown timezone. >>> isinstance(UnknownTimeZoneError(), LookupError) True This class is actually a subclass of KeyError to provide backwards compatibility with code relying on the undocumented behavior of earlier pytz releases. >>> isinstance(UnknownTimeZoneError(), KeyError) True And also a subclass of pytz.exceptions.Error, as are other pytz exceptions. >>> isinstance(UnknownTimeZoneError(), Error) True Nr r r r r r s r c @ r )r z'Base class for invalid time exceptions.Nr r r r r r & r r c @ r )r aX Exception raised when attempting to create an ambiguous wallclock time. At the end of a DST transition period, a particular wallclock time will occur twice (once before the clocks are set back, once after). Both possibilities may be correct, unless further information is supplied. See DstTzInfo.normalize() for more info Nr r r r r r * r r c @ r )r z�Exception raised when attempting to create a wallclock time that cannot exist. At the start of a DST transition period, the wallclock time jumps forward. The instants jumped over never occur. Nr r r r r r 5 r r N) r �__all__� Exceptionr �KeyErrorr r r r r r r r �<module> s __pycache__/tzinfo.cpython-310.pyc 0000644 00000034630 15030534450 0012773 0 ustar 00 o �<<bHK � @ s� d Z ddlmZmZmZ ddlmZ ze W n ey% ddlm Z Y nw ddl Z ddl m Z m Z g Zi Zdd� Ze�d�ZdeiZd d � Zi Zd d � Zed�Zd d� ZG dd� de�ZG dd� de�ZG dd� de�Zddd�Z dS )zBBase classes and helpers for building zone specific tzinfo classes� )�datetime� timedelta�tzinfo)� bisect_right)�SetN)�AmbiguousTimeError�NonExistentTimeErrorc C s4 zt | W S ty t| d�}|t | < | Y S w )z3Create only one instance of each distinct timedelta��seconds)�_timedelta_cache�KeyErrorr )r �delta� r �-/usr/lib/python3/dist-packages/pytz/tzinfo.py�memorized_timedelta s �r c C s8 zt | W S ty tt| d� }|t | < | Y S w )z2Create only one instance of each distinct datetimer )�_datetime_cacher �_epochr )r �dtr r r �memorized_datetime s �r c G sH zt | W S ty# t| d �t| d �| d f}|t | < | Y S w )z/Create only one instance of each distinct tupler � � )� _ttinfo_cacher r )�args�ttinfor 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 � | 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� Zddd�Zddd�Zdd d �Zdd d �Zddd�Z 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 dur|j | urtd��|| j j| d�S )�See datetime.tzinfo.fromutcN� fromutc: dt.tzinfo is not self�r )r � ValueErrorr+ �replace)r& r r r r �fromutcR s zStaticTzInfo.fromutcNc C r! )z�See 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 � zStaticTzInfo.utcoffsetc C s t S )z�See datetime.tzinfo.dst is_dst is ignored for StaticTzInfo, and exists only to retain compatibility with DstTzInfo. )�_notimer4 r r r �dst` s zStaticTzInfo.dstc C r! )z�See datetime.tzinfo.tzname is_dst is ignored for StaticTzInfo, and exists only to retain compatibility with DstTzInfo. )r, r4 r r r �tznameh r7 zStaticTzInfo.tznameFc C s |j dur td��|j| d�S )z Convert naive time to local timeN�*Not naive datetime (tzinfo is already set)r0 )r r1 r2 r4 r r r �localizep s zStaticTzInfo.localizec C s* |j | u r|S |j du rtd��|�| �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 r1 � astimezoner4 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__r" �F) r( r) r* �__doc__r3 r6 r9 r: r< r? r@ rC r r r r r- L s r- c @ sv e Zd ZdZdZdZdZdZdZddd�Z dd� Z dd� Z dd d �Z dd d �Z ddd�Zddd�Zdd� 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 s| |r|| _ |\| _| _| _d S i }|| _ | jd \| _| _| _| || jd < | jdd � D ]}||vr;| �||�||< q-d S )Nr r )�_tzinfosr+ �_dstr, �_transition_info� __class__)r& �_infrG �infr r r �__init__� s ���zDstTzInfo.__init__c C sl |j durt|j dd�| jurtd��|jdd�}tdt| j|�d �}| j| }||d j| j| d�S )r. NrG r/ r0 r r ) r �getattrrG r1 r2 �maxr �_utc_transition_timesrI )r& r �idxrL r r r r3 � s zDstTzInfo.fromutcc C s8 |j du r td��|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= r0 )r r1 r+ r2 r3 )r& r �offsetr r r r? � s - zDstTzInfo.normalizeFc s� |j dur td��t� }tdd�tdd�fD ]1}|| }tdt| j|�d �}| j| }| j| }|� |j |d��}|j dd�|krG|� |� qt |�dkrR|� � S t |�dkr�� du r`t|��� rs| j|tdd � d d �tdd � S | j|tdd � d d �tdd � S � du r�t|��� fd d�|D �} t | �dkr�| d S t | �dkr�t|�} i } | D ]} | j dd�| j j } | | vs�J �| | | < q�| 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 Nr; ���)r r r r0 � )�hoursT�r5 Fc s g | ] }t |jj�� kr|�qS r )�boolr rH )�.0�prV r r � <listcomp>o s z&DstTzInfo.localize.<locals>.<listcomp>)r r1 �setr rO r rP rI rG r? r2 �add�len�popr r< r �listr+ �min) r& r r5 �possible_loc_dtr �loc_dtrQ rL r �filtered_possible_loc_dt�dates�local_dt�utc_timer rV r r< sb ;�� � �� �� � � zDstTzInfo.localizec C �0 |du rdS |j | ur| �||�}|j jS | jS )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 r< r+ r4 r r r r6 � s zDstTzInfo.utcoffsetc C rg )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 r< rH r4 r r r r9 � s z DstTzInfo.dstc C s2 |du r| j S |j| ur| �||�}|jjS | jS )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 r< r, r4 r r r r: � s zDstTzInfo.tznamec C sF | j rd}nd}| jtkrd| j| j| j|f S d| j| j| j|f S )N�DST�STDz<DstTzInfo %r %s+%s %s>z<DstTzInfo %r %s%s %s>)rH r+ r8 r$ r, )r& r9 r r r r@ � s ��zDstTzInfo.__repr__c C s" t j| jt| j�t| j�| jffS r" )rA rB r$ r r+ rH r, r% r r r rC s �zDstTzInfo.__reduce__)NNrD r" )r( r) r* rE rP rI r$ rG rH rM r3 r? r< r6 r9 r: r@ rC r r r r rF � s" 7 '& rF c C s� t �| �}|du r |S t|�}t|�}z |j|||f W S ty% Y nw |j�� D ]}|j|kr;|j|kr;| S q+|||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) rA �timezoner rG r �valuesr+ rH rJ )r$ r6 � dstoffsetr: �tz� localized_tzrL r r r � unpickler s$ � � ro )NNN) rE r r r �bisectr r[ � NameError�setsr rA �pytz.exceptionsr r �__all__r r �utcfromtimestampr r r r r r8 r r r- rF ro r r r r �<module> s4 � P w __pycache__/__init__.cpython-310.pyc 0000644 00000041071 15030534450 0013216 0 ustar 00 o �d�E � @ s d Z ddlZddlZddlZddlZddlZddlZddlm Z ddlm Z ddlm Z ddlm Z ddl mZmZmZ ddlmZmZ dd lmZ d efd d �Ze� Zd ZeZeZg d�Z ej d dkrleZ dd� Z ndd� Z dd� Z dd� Z!i Z"dd� Z#dd� Z$da%dd � Z&e�'d�Z(ej'd d �Z)G d d � d e�Z*e*� Z*Z+d!d"� Z,d#e,_-d$d%� Z.d#e._-G d&d'� d'e�Z/e/� Z0G d(d)� d)e�Z1e1� Z2G d*d+� d+ej3�Z4i fd,d-�Z5d#e5_-d.d/� Z6d e7e fd0d1�Z8e9d2kr�e6� h d3�Z:e�;� d4d5h Z<e8� e:B e<@ Z=e>e<�Z?e>e=�Z@dS )6z� datetime.tzinfo timezone definitions generated from the Olson timezone database: ftp://elsie.nci.nih.gov/pub/tz*.tar.gz See the datetime section of the Python Library Reference for information on how to use these modules. � N)�AmbiguousTimeError)�InvalidTimeError)�NonExistentTimeError)�UnknownTimeZoneError)�LazyDict�LazyList�LazySet)� unpickler� BaseTzInfo)� build_tzinfo�returnc C s\ t �d�} | jdd�� }|�� }W d � n1 sw Y t�d|�}|r,|�d�S dS )Nz /usr/share/zoneinfo/tzdata.zi�utf-8��encodingz ^#\s*version\s*([0-9a-z]*)\s*$� �unknown)�pathlib�Path�open�readline�re�match�group)� tzdata_zi�tzdata_zi_file�liner � r �//usr/lib/python3/dist-packages/pytz/__init__.py�_read_olson_version s � r z2022.1)�timezone�utc�country_timezones� country_namesr r r r � all_timezones�all_timezones_set�common_timezones�common_timezones_setr � FixedOffset� c C s( t | �tkr | �d�} | S | �d� | S )z� >>> ascii('Hello') 'Hello' >>> ascii('\N{TRADE MARK SIGN}') #doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... UnicodeEncodeError: ... �ASCII)�type�bytes�decode�encode��sr r r �ascii< s �r0 c C s | � d�S )a >>> ascii('Hello') 'Hello' >>> ascii(u'Hello') 'Hello' >>> ascii(u'\N{TRADE MARK SIGN}') #doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... UnicodeEncodeError: ... r) )r- r. r r r r0 M s c C s� | � d��d�}|D ]}|tjjkstjj|v r td| ��q tj�dd�}|dur5tjj |g|�R � }n1tjj dddg|�R � }tj� |�sfzdd l m } W n t yZ d}Y nw |durf|td | �S t|d �S ) a! Open a resource from the zoneinfo subdir for reading. Uses the pkg_resources module if available and no standard file found at the calculated location. It is possible to specify different location for zoneinfo subdir by using the PYTZ_TZDATADIR environment variable. �/zBad path segment: %r�PYTZ_TZDATADIRNz/usr�share�zoneinfor )�resource_streamz zoneinfo/�rb)�lstrip�split�os�path�pardir�sep� ValueError�environ�get�join�exists� pkg_resourcesr5 � ImportError�__name__r )�name� name_parts�part� zoneinfo_dir�filenamer5 r r r � open_resource[ s, � �� � rJ c C s< zt j�dd�r W dS t| ��� W dS ty Y dS w )z(Return true if the given resource exists�PYTZ_SKIPEXISTSCHECK� TF)r9 r> r? rJ �close�IOError)rE r r r �resource_exists| s �rO c C s� | du rt d��| �� dkrtS zt| �} W n ty! t | ��w tt| ��} | tvrN| tv rJt | �}zt | |�t| < W |� � t| S |� � w t | ��t| S )ao Return a datetime.tzinfo implementation for the given timezone >>> from datetime import datetime, timedelta >>> utc = timezone('UTC') >>> eastern = timezone('US/Eastern') >>> eastern.zone 'US/Eastern' >>> timezone(unicode('US/Eastern')) is eastern True >>> utc_dt = datetime(2002, 10, 27, 6, 0, 0, tzinfo=utc) >>> loc_dt = utc_dt.astimezone(eastern) >>> fmt = '%Y-%m-%d %H:%M:%S %Z (%z)' >>> loc_dt.strftime(fmt) '2002-10-27 01:00:00 EST (-0500)' >>> (loc_dt - timedelta(minutes=10)).strftime(fmt) '2002-10-27 00:50:00 EST (-0500)' >>> eastern.normalize(loc_dt - timedelta(minutes=10)).strftime(fmt) '2002-10-27 01:50:00 EDT (-0400)' >>> (loc_dt + timedelta(minutes=10)).strftime(fmt) '2002-10-27 01:10:00 EST (-0500)' Raises UnknownTimeZoneError if passed an unknown zone. >>> try: ... timezone('Asia/Shangri-La') ... except UnknownTimeZoneError: ... print('Unknown') Unknown >>> try: ... timezone(unicode('\N{TRADE MARK SIGN}')) ... except UnknownTimeZoneError: ... print('Unknown') Unknown N�UTC) r �upperr r0 �UnicodeEncodeError� _case_insensitive_zone_lookup� _unmunge_zone� _tzinfo_cacher$ rJ r rM )�zone�fpr r r r � s( % � �r c C s | � dd�� dd�S )z?Undo the time zone name munging done by older versions of pytz.�_plus_�+�_minus_�-)�replace�rV r r r rT � s rT c C s, t du r tdd� tD ��a t �| �� �p| S )z@case-insensitively matching timezone, else return zone unchangedNc s s � | ] }|� � |fV qd S �N)�lower)�.0�tzr r r � <genexpr>� s � z0_case_insensitive_zone_lookup.<locals>.<genexpr>)� _all_timezones_lower_to_standard�dictr# r? r_ r] r r r rS � s rS r )�hoursc st e Zd ZdZd ZeZeZeZ� fdd�Z dd� Z dd� Z dd � Z d d � Z dd d�Zddd�Zdd� Zdd� Z� ZS )rP z�UTC Optimized UTC implementation. It unpickles using the single module global instance defined beneath this class declaration. c s& |j d u r | �|�S ttj| ��|�S r^ )�tzinfo�localize�superr � __class__�fromutc��self�dt�ri r r rj � s z UTC.fromutcc C � t S r^ ��ZEROrk r r r � utcoffset� � z UTC.utcoffsetc C � dS �NrP r rk r r r �tzname� rs z UTC.tznamec C ro r^ rp rk r r r �dst� rs zUTC.dstc C s t dfS )Nr )�_UTC�rl r r r � __reduce__� s zUTC.__reduce__Fc C � |j dur td��|j| d�S �z Convert naive time to local timeNz*Not naive datetime (tzinfo is already set))rf �rf r= r\ �rl rm �is_dstr r r rg � � z UTC.localizec C �* |j | u r|S |j du rtd��|�| �S �z6Correct the timezone information on the given datetimeNzNaive time - no tzinfo set�rf r= � astimezoner~ r r r � normalize � z UTC.normalizec C rt )Nz<UTC>r ry r r r �__repr__ rs z UTC.__repr__c C rt ru r ry r r r �__str__ rs z UTC.__str__�F)rD � __module__� __qualname__�__doc__rV rq � _utcoffset�_dst�_tznamerj rr rv rw rz rg r� r� r� � __classcell__r r rn r rP � s rP c C ro )a* Factory function for utc unpickling. Makes sure that unpickling a utc instance always returns the same module global. These examples belong in the UTC class above, but it is obscured; or in the README.rst, but we are not depending on Python 2.4 so integrating the README.rst examples with the unit tests is not trivial. >>> import datetime, pickle >>> dt = datetime.datetime(2005, 3, 1, 14, 13, 21, tzinfo=utc) >>> naive = dt.replace(tzinfo=None) >>> p = pickle.dumps(dt, 1) >>> naive_p = pickle.dumps(naive, 1) >>> len(p) - len(naive_p) 17 >>> new = pickle.loads(p) >>> new == dt True >>> new is dt False >>> new.tzinfo is dt.tzinfo True >>> utc is UTC is timezone('UTC') True >>> utc is timezone('GMT') False )r r r r r rx s rx Tc G s t | � S )z�Factory function for unpickling pytz tzinfo instances. Just a wrapper around tzinfo.unpickler to save a few bytes in each pickle by shortening the path. )r )�argsr r r �_p: s r� c @ s e Zd ZdZdd� Zdd� ZdS )�_CountryTimezoneDicta� Map ISO 3166 country code to a list of timezone names commonly used in that country. iso3166_code is the two letter code used to identify the country. >>> def print_list(list_of_strings): ... 'We use a helper so doctests work under Python 2.3 -> 3.x' ... for s in list_of_strings: ... print(s) >>> print_list(country_timezones['nz']) Pacific/Auckland Pacific/Chatham >>> print_list(country_timezones['ch']) Europe/Zurich >>> print_list(country_timezones['CH']) Europe/Zurich >>> print_list(country_timezones[unicode('ch')]) Europe/Zurich >>> print_list(country_timezones['XXX']) Traceback (most recent call last): ... KeyError: 'XXX' Previously, this information was exposed as a function rather than a dictionary. This is still supported:: >>> print_list(country_timezones('nz')) Pacific/Auckland Pacific/Chatham c C s | | S )zBackwards compatibility.r )rl � iso3166_coder r r �__call__f s z _CountryTimezoneDict.__call__c C s� i }t d�}zC|D ]6}|�d�}|�d�rq |�d d�d d� \}}}|tvr(q z || �|� W q ty? |g||< Y q w || _W |�� d S |�� w )Nzzone.tab�UTF-8�#� � ) rJ r, � startswithr8 r$ �append�KeyError�datarM )rl r� �zone_tabr �code� coordinatesrV r r r �_fillj s" �z_CountryTimezoneDict._fillN)rD r� r� r� r� r� r r r r r� F s r� c @ s e Zd ZdZdd� ZdS )�_CountryNameDictzgDictionary proving ISO3166 code -> English name. >>> print(country_names['au']) Australia c C sl i }t d�}z*|�� D ]}|�d�}|�d�rq |�d d�\}}|�� ||< q || _W |�� d S |�� w )Nz iso3166.tabr� r� r )rJ � readlinesr, r� r8 �stripr� rM )rl r� r� r r� rE r r r r� � s z_CountryNameDict._fillN)rD r� r� r� r� r r r r r� � s r� c @ sT e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z ddd�Z ddd�Z dS )� _FixedOffsetNc C s. t |�dkr td|��|| _tj|d�| _d S )Ni� z absolute offset is too large)�minutes)�absr= �_minutes�datetime� timedelta�_offset)rl r� r r r �__init__� s z_FixedOffset.__init__c C s | j S r^ )r� rk r r r rr � s z_FixedOffset.utcoffsetc C s t | jffS r^ )r' r� ry r r r rz � s z_FixedOffset.__reduce__c C ro r^ rp rk r r r rw � rs z_FixedOffset.dstc C s d S r^ r rk r r r rv � rs z_FixedOffset.tznamec C s d| j S )Nzpytz.FixedOffset(%d))r� ry r r r r� � s z_FixedOffset.__repr__Fc C r{ r| r} r~ r r r rg � r� z_FixedOffset.localizec C r� r� r� r~ r r r r� � r� z_FixedOffset.normalizer� ) rD r� r� rV r� rr rz rw rv r� rg r� r r r r r� � s r� c C s2 | dkrt S |�| �}|du r|�| t| ��}|S )a� return a fixed-offset timezone based off a number of minutes. >>> one = FixedOffset(-330) >>> one pytz.FixedOffset(-330) >>> str(one.utcoffset(datetime.datetime.now())) '-1 day, 18:30:00' >>> str(one.dst(datetime.datetime.now())) '0:00:00' >>> two = FixedOffset(1380) >>> two pytz.FixedOffset(1380) >>> str(two.utcoffset(datetime.datetime.now())) '23:00:00' >>> str(two.dst(datetime.datetime.now())) '0:00:00' The datetime.timedelta must be between the range of -1 and 1 day, non-inclusive. >>> FixedOffset(1440) Traceback (most recent call last): ... ValueError: ('absolute offset is too large', 1440) >>> FixedOffset(-1440) Traceback (most recent call last): ... ValueError: ('absolute offset is too large', -1440) An offset of 0 is special-cased to return UTC. >>> FixedOffset(0) is UTC True There should always be only one instance of a FixedOffset per timedelta. This should be true for multiple creation calls. >>> FixedOffset(-330) is one True >>> FixedOffset(1380) is two True It should also be true for pickling. >>> import pickle >>> pickle.loads(pickle.dumps(one)) is one True >>> pickle.loads(pickle.dumps(two)) is two True r N)rP r? � setdefaultr� )�offset�_tzinfos�infor r r r' � s 5 r' c C s* dd l } tj�dtj� dd l}| �|�S )Nr )�doctest�sysr: �insertr9 r; �pytz�testmod)r� r� r r r �_test s r� c C sJ t � } t�d�}|jdd��� D ]}|�d�rq| �|�d�d � q| S )Nz /usr/share/zoneinfo/zone1970.tabr r r� � r( )�setr r � read_text� splitlinesr� �addr8 )� timezonesr� r r r r � _read_timezones_from_zone_tab s r� �__main__>z � Asia/Aden� US/Alaska� US/Hawaii� US/Arizona� US/Central� US/Eastern� US/Pacific� Africa/Lome� Asia/Brunei� Asia/Kuwait� Asia/Muscat� Europe/Oslo� Indian/Mahe� US/Mountain� Africa/Accra� Africa/Dakar� Asia/Bahrain� Europe/Vaduz� Indian/Cocos� Pacific/Wake� Africa/Asmara� Africa/Bamako� Africa/Bangui� Africa/Banjul� Africa/Douala� Africa/Harare� Africa/Kigali� Africa/Luanda� Africa/Lusaka� Africa/Malabo� Africa/Maseru� Africa/Niamey� America/Aruba� Europe/Jersey� Europe/Monaco� Europe/Skopje� Europe/Zagreb� Indian/Comoro� Pacific/Chuuk�Africa/Conakry�Africa/Kampala�Africa/Mbabane�America/Cayman�America/Nassau�Asia/Vientiane�Canada/Central�Canada/Eastern�Canada/Pacific�Europe/Vatican�Indian/Mayotte�Indian/Reunion�Pacific/Majuro�Pacific/Midway�Pacific/Saipan�Pacific/Wallis�Africa/Blantyre�Africa/Djibouti�Africa/Freetown�Africa/Gaborone�Africa/Kinshasa�America/Antigua�America/Creston�America/Curacao�America/Grenada�America/Marigot�America/Tortola�Asia/Phnom_Penh�Canada/Atlantic�Canada/Mountain�Europe/Busingen�Europe/Guernsey�Europe/Sarajevo�Pacific/Pohnpei�Africa/Bujumbura�Africa/Mogadishu�America/Anguilla�America/Atikokan�America/Dominica�America/St_Kitts�America/St_Lucia�Antarctica/Syowa�Europe/Amsterdam�Europe/Ljubljana�Europe/Mariehamn�Europe/Podgorica�Europe/Stockholm�Indian/Christmas�Indian/Kerguelen�Pacific/Funafuti�Africa/Libreville�Africa/Lubumbashi�Africa/Nouakchott�Africa/Porto-Novo�America/St_Thomas�Antarctica/Vostok�Asia/Kuala_Lumpur�Europe/Bratislava�Europe/Copenhagen�Europe/Luxembourg�Europe/San_Marino�Africa/Addis_Ababa�Africa/Brazzaville�Africa/Ouagadougou�America/Guadeloupe�America/Kralendijk�America/Montserrat�America/St_Vincent�Antarctica/McMurdo�Atlantic/Reykjavik�Atlantic/St_Helena�Europe/Isle_of_Man�Arctic/Longyearbyen�Canada/Newfoundland�Indian/Antananarivo�Africa/Dar_es_Salaam�America/Blanc-Sablon�America/Lower_Princes�America/Port_of_Spain�America/St_Barthelemy�Antarctica/DumontDUrville�GMTrP �Factory� localtime)Ar� r� r� �os.pathr9 r r r4 �pytz.exceptionsr r r r � pytz.lazyr r r � pytz.tzinfor r � pytz.tzfiler �strr � OLSON_VERSION�VERSION� __version__� OLSEN_VERSION�__all__� version_info�unicoder0 rJ rO rU r rT rc rS r� rq �HOURrP r rx �__safe_for_unpickling__r� r� r! r� r" rf r� r' r� r� r� rD �_extra_common_timezones_set�available_timezonesr$ r& �sortedr# r% r r r r �<module> sn !? 2 8 (C | __pycache__/tzfile.cpython-310.pyc 0000644 00000006011 15030534450 0012747 0 ustar 00 o �d� � @ s� d Z ddlmZ ddlmZmZ ddlmZmZmZ ddlm Z m Z dd� Z e d�Z d d � Z d d � Zed kreddlZddlmZ dZedeej�edd�d��Zedeej�edd�d��Zeej� dS dS )z7 $Id: tzfile.py,v 1.8 2004/06/03 00:15:24 zenzen Exp $ � )�datetime)�unpack�calcsize)� StaticTzInfo� DstTzInfo�memorized_ttinfo)�memorized_datetime�memorized_timedeltac C s | � d�S )z5Cast a string or byte string to an ASCII byte string.�ASCII)�encode��s� r �-/usr/lib/python3/dist-packages/pytz/tzfile.py� _byte_string s r � c C s t | �d��S )z0Cast a string or byte string to an ASCII string.r )�str�decoder r r r � _std_string s r c ! C sp d}t |�}t||�|��\}}}}}} } } |td�ks$J dt|� ��dt| d| | d� } t | �} t| |�| ��}t|�d| d| d ksKJ �d d � |d | � D �}t|| d| � �}|d| d � }|d }~g }i }d }|t|�k r�||d }||vr�|�t |�}|d k r�t|�}t |||� �||< |� || t ||d �|| f� |d7 }|t|�k syt|�d ks�t|�d kr�|d d |d d f t | tft| t|d d �|d d d��}|� S d }|| d r�|d 7 }|| d s�|| ||d k�r tj|d < n |�d tj� |�d |� g }tt|��D ]�}||| }|d }|d �s4d } nRt|d d d �D ]} ||| } | d �sK n�q<|d | d } | d k�s_| dk�r�t|d t|��D ] } ||| } | d �s�|d | d } | d k�r� n�qh|d } t|d d �d }t| d d �d } |� t|| | �� �q t | tft| ||d��}|� S )Nz >4s c 15x 6l�TZifz Got magic %sz2>%(timecnt)dl %(timecnt)dB %(ttinfo)s %(charcnt)ds�lBB)�timecnt�ttinfo�charcnt� � � c S s g | ]}t |��qS r )r )�.0�transr r r � <listcomp>) s �z build_tzinfo.<locals>.<listcomp>���r )�zone� _utcoffset�_tznamei0* � �< )r! �_utc_transition_times�_transition_info)r r �readr �repr�dict�len�list�find�_NULLr �append�bool�typer r r �min�insert�range�intr r )!r! �fp�head_fmt� head_size�magic�format� ttisgmtcnt� ttisstdcnt�leapcntr �typecntr �data_fmt� data_size�data� transitions�lindexes� ttinfo_raw� tznames_rawr �tznames�i� tzname_offset�nul�cls�transition_info�inf� utcoffset�dst�j�prev_inf�stdinf�tznamer r r � build_tzinfo s� � � � � � � �6� � � � �rS �__main__N)�pprintz/usr/share/zoneinfozAustralia/Melbourne� Australia� Melbourne�rbz US/Eastern�US�Eastern)�__doc__r �structr r � pytz.tzinfor r r r r r r. r rS �__name__�os.path�osrU �base�open�path�join�tzr& r r r r �<module> s* e ��� __pycache__/lazy.cpython-310.pyc 0000644 00000011121 15030534450 0012427 0 ustar 00 o �<<b � @ s� d dl mZ zd dlmZ W n! ey/ zd dlmZ W n ey, d dlmZ Y nw Y nw e� ZG dd� de�Z G dd� de �Z dd � e j D �e _ G d d � d e �Zd d � ej D �e_ d S )� )�RLock)�Mapping)� DictMixinc @ s< e Zd ZdZdZdd� Zdd� Zdd� Zd d � Zd d � Z dS ) �LazyDictz"Dictionary populated on first use.Nc C sJ | j d u r t�� z| j d u r| �� W t�� nt�� w | j |�� S �N)�data� _fill_lock�acquire�_fill�release�upper��self�key� r �+/usr/lib/python3/dist-packages/pytz/lazy.py� __getitem__ s �zLazyDict.__getitem__c C sF | j d u r t�� z| j d u r| �� W t�� nt�� w || j v S r )r r r r r r r r r � __contains__ � � zLazyDict.__contains__c C �F | j d u r t�� z| j d u r| �� W t�� nt�� w t| j �S r )r r r r r �iter�r r r r �__iter__( r zLazyDict.__iter__c C r r )r r r r r �lenr r r r �__len__2 r zLazyDict.__len__c C sF | j d u r t�� z| j d u r| �� W t�� nt�� w | j �� S r )r r r r r �keysr r r r r < r z LazyDict.keys) �__name__� __module__� __qualname__�__doc__r r r r r r r r r r r s r c @ s" e Zd ZdZg d�Zddd�ZdS )�LazyListz List populated on first use.)&�__str__�__repr__� __unicode__�__hash__� __sizeof__�__cmp__�__lt__�__le__�__eq__�__ne__�__gt__�__ge__�append�count�index�extend�insert�pop�remove�reverse�sort�__add__�__radd__�__iadd__�__mul__�__rmul__�__imul__r r � __nonzero__r � __setitem__� __delitem__r � __reversed__� __getslice__� __setslice__� __delslice__Nc �Z �d u rt � S G dd� dt �� �g�� ��fdd�}�jD ] }t� |||�� q � � }|S )Nc @ � e Zd ZdS )z"LazyList.__new__.<locals>.LazyListN�r r r r r r r r [ � r c � ���� fdd�}|S )Nc sn t �� z t��dkr t�| ��� � �jD ]}t� |� qW t �� nt �� w t t��| g|�R i |��S �Nr ) r r r �listr0 r2 �_props�delattrr �getattr)r �args�kw� method_name)r �cls� fill_iter�namer r �_lazya s � z-LazyList.__new__.<locals>.lazy.<locals>._lazyr �rR rS �r rP rQ �rR r �lazy` s z LazyList.__new__.<locals>.lazy)rI rJ �setattr)rP rQ rW rR �new_listr rU r �__new__T s zLazyList.__new__r �r r r r rJ rZ r r r r r G s r c C � g | ] }t t|�r|�qS r )�hasattrrI ��.0�propr r r � <listcomp>v � ra c @ s e Zd ZdZdZddd�ZdS )�LazySetzSet populated on first use.)0r! r" r# r$ r% r& r' r( r) r* r+ r, r r r< r r= r> r �__sub__�__and__�__xor__�__or__�__rsub__�__rand__�__rxor__�__ror__�__isub__�__iand__�__ixor__�__ior__�add�clear�copy� difference�difference_update�discard� intersection�intersection_update� isdisjoint�issubset� issupersetr2 r3 �symmetric_difference�symmetric_difference_update�union�updateNc rC )Nc @ rD )z LazySet.__new__.<locals>.LazySetNrE r r r r rc � rF rc c rG )Nc sx t �� z$t��dkr#��� D ]}t�| |� q�jD ]}t� |� qW t �� nt �� w t t��| g|�R i |��S rH ) r r r r2 �setrp rJ rK r rL )r rM rN �irO )rc rP rQ rR r r rS � s � z,LazySet.__new__.<locals>.lazy.<locals>._lazyr rT �rc rP rQ rV r rW � s z LazySet.__new__.<locals>.lazy)r rJ rX )rP rQ rW rR �new_setr r� r rZ � s zLazySet.__new__r r[ r r r r rc y s rc c C r\ r )r] r r^ r r r ra � rb N)� threadingr �collections.abcr r � ImportError�UserDict� collectionsr r rI r rJ r rc r r r r �<module> s" ��� 7/3 tzinfo.py 0000644 00000045510 15030534450 0006433 0 ustar 00 '''Base classes and helpers for building zone specific tzinfo classes''' from datetime import datetime, timedelta, tzinfo from bisect import bisect_right try: set except NameError: from sets import Set as set import pytz from pytz.exceptions import AmbiguousTimeError, NonExistentTimeError __all__ = [] _timedelta_cache = {} def memorized_timedelta(seconds): '''Create only one instance of each distinct timedelta''' try: return _timedelta_cache[seconds] except KeyError: delta = timedelta(seconds=seconds) _timedelta_cache[seconds] = delta return delta _epoch = datetime.utcfromtimestamp(0) _datetime_cache = {0: _epoch} def memorized_datetime(seconds): '''Create only one instance of each distinct datetime''' try: return _datetime_cache[seconds] except KeyError: # NB. We can't just do datetime.utcfromtimestamp(seconds) as this # fails with negative values under Windows (Bug #90096) dt = _epoch + timedelta(seconds=seconds) _datetime_cache[seconds] = dt return dt _ttinfo_cache = {} def memorized_ttinfo(*args): '''Create only one instance of each distinct tuple''' try: return _ttinfo_cache[args] except KeyError: ttinfo = ( memorized_timedelta(args[0]), memorized_timedelta(args[1]), args[2] ) _ttinfo_cache[args] = ttinfo return ttinfo _notime = memorized_timedelta(0) def _to_seconds(td): '''Convert a timedelta to seconds''' return td.seconds + td.days * 24 * 60 * 60 class BaseTzInfo(tzinfo): # Overridden in subclass _utcoffset = None _tzname = None zone = None def __str__(self): return self.zone class StaticTzInfo(BaseTzInfo): '''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 ''' def fromutc(self, dt): '''See datetime.tzinfo.fromutc''' if dt.tzinfo is not None and dt.tzinfo is not self: raise ValueError('fromutc: dt.tzinfo is not self') return (dt + self._utcoffset).replace(tzinfo=self) def utcoffset(self, dt, is_dst=None): '''See datetime.tzinfo.utcoffset is_dst is ignored for StaticTzInfo, and exists only to retain compatibility with DstTzInfo. ''' return self._utcoffset def dst(self, dt, is_dst=None): '''See datetime.tzinfo.dst is_dst is ignored for StaticTzInfo, and exists only to retain compatibility with DstTzInfo. ''' return _notime def tzname(self, dt, is_dst=None): '''See datetime.tzinfo.tzname is_dst is ignored for StaticTzInfo, and exists only to retain compatibility with DstTzInfo. ''' return self._tzname def localize(self, dt, is_dst=False): '''Convert naive time to local time''' if dt.tzinfo is not None: raise ValueError('Not naive datetime (tzinfo is already set)') return dt.replace(tzinfo=self) def normalize(self, dt, is_dst=False): '''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)' ''' if dt.tzinfo is self: return dt if dt.tzinfo is None: raise ValueError('Naive time - no tzinfo set') return dt.astimezone(self) def __repr__(self): return '<StaticTzInfo %r>' % (self.zone,) def __reduce__(self): # Special pickle to zone remains a singleton and to cope with # database changes. return pytz._p, (self.zone,) class DstTzInfo(BaseTzInfo): '''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. ''' # Overridden in subclass # Sorted list of DST transition times, UTC _utc_transition_times = None # [(utcoffset, dstoffset, tzname)] corresponding to # _utc_transition_times entries _transition_info = None zone = None # Set in __init__ _tzinfos = None _dst = None # DST offset def __init__(self, _inf=None, _tzinfos=None): if _inf: self._tzinfos = _tzinfos self._utcoffset, self._dst, self._tzname = _inf else: _tzinfos = {} self._tzinfos = _tzinfos self._utcoffset, self._dst, self._tzname = ( self._transition_info[0]) _tzinfos[self._transition_info[0]] = self for inf in self._transition_info[1:]: if inf not in _tzinfos: _tzinfos[inf] = self.__class__(inf, _tzinfos) def fromutc(self, dt): '''See datetime.tzinfo.fromutc''' if (dt.tzinfo is not None and getattr(dt.tzinfo, '_tzinfos', None) is not self._tzinfos): raise ValueError('fromutc: dt.tzinfo is not self') dt = dt.replace(tzinfo=None) idx = max(0, bisect_right(self._utc_transition_times, dt) - 1) inf = self._transition_info[idx] return (dt + inf[0]).replace(tzinfo=self._tzinfos[inf]) def normalize(self, dt): '''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)' ''' if dt.tzinfo is None: raise ValueError('Naive time - no tzinfo set') # Convert dt in localtime to UTC offset = dt.tzinfo._utcoffset dt = dt.replace(tzinfo=None) dt = dt - offset # convert it back, and return it return self.fromutc(dt) def localize(self, dt, is_dst=False): '''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 ''' if dt.tzinfo is not None: raise ValueError('Not naive datetime (tzinfo is already set)') # Find the two best possibilities. possible_loc_dt = set() for delta in [timedelta(days=-1), timedelta(days=1)]: loc_dt = dt + delta idx = max(0, bisect_right( self._utc_transition_times, loc_dt) - 1) inf = self._transition_info[idx] tzinfo = self._tzinfos[inf] loc_dt = tzinfo.normalize(dt.replace(tzinfo=tzinfo)) if loc_dt.replace(tzinfo=None) == dt: possible_loc_dt.add(loc_dt) if len(possible_loc_dt) == 1: return possible_loc_dt.pop() # If there are no possibly correct timezones, we are attempting # to convert a time that never happened - the time period jumped # during the start-of-DST transition period. if len(possible_loc_dt) == 0: # If we refuse to guess, raise an exception. if is_dst is None: raise NonExistentTimeError(dt) # If we are forcing the pre-DST side of the DST transition, we # obtain the correct timezone by winding the clock forward a few # hours. elif is_dst: return self.localize( dt + timedelta(hours=6), is_dst=True) - timedelta(hours=6) # If we are forcing the post-DST side of the DST transition, we # obtain the correct timezone by winding the clock back. else: return self.localize( dt - timedelta(hours=6), is_dst=False) + timedelta(hours=6) # If we get this far, we have multiple possible timezones - this # is an ambiguous case occuring during the end-of-DST transition. # If told to be strict, raise an exception since we have an # ambiguous case if is_dst is None: raise AmbiguousTimeError(dt) # Filter out the possiblilities that don't match the requested # is_dst filtered_possible_loc_dt = [ p for p in possible_loc_dt if bool(p.tzinfo._dst) == is_dst ] # Hopefully we only have one possibility left. Return it. if len(filtered_possible_loc_dt) == 1: return filtered_possible_loc_dt[0] if len(filtered_possible_loc_dt) == 0: filtered_possible_loc_dt = list(possible_loc_dt) # If we get this far, we have in a wierd timezone transition # where the clocks have been wound back but is_dst is the same # in both (eg. Europe/Warsaw 1915 when they switched to CET). # At this point, we just have to guess unless we allow more # hints to be passed in (such as the UTC offset or abbreviation), # but that is just getting silly. # # Choose the earliest (by UTC) applicable timezone if is_dst=True # Choose the latest (by UTC) applicable timezone if is_dst=False # i.e., behave like end-of-DST transition dates = {} # utc -> local for local_dt in filtered_possible_loc_dt: utc_time = ( local_dt.replace(tzinfo=None) - local_dt.tzinfo._utcoffset) assert utc_time not in dates dates[utc_time] = local_dt return dates[[min, max][not is_dst](dates)] def utcoffset(self, dt, is_dst=None): '''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 ''' if dt is None: return None elif dt.tzinfo is not self: dt = self.localize(dt, is_dst) return dt.tzinfo._utcoffset else: return self._utcoffset def dst(self, dt, is_dst=None): '''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 ''' if dt is None: return None elif dt.tzinfo is not self: dt = self.localize(dt, is_dst) return dt.tzinfo._dst else: return self._dst def tzname(self, dt, is_dst=None): '''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 ''' if dt is None: return self.zone elif dt.tzinfo is not self: dt = self.localize(dt, is_dst) return dt.tzinfo._tzname else: return self._tzname def __repr__(self): if self._dst: dst = 'DST' else: dst = 'STD' if self._utcoffset > _notime: return '<DstTzInfo %r %s+%s %s>' % ( self.zone, self._tzname, self._utcoffset, dst ) else: return '<DstTzInfo %r %s%s %s>' % ( self.zone, self._tzname, self._utcoffset, dst ) def __reduce__(self): # Special pickle to zone remains a singleton and to cope with # database changes. return pytz._p, ( self.zone, _to_seconds(self._utcoffset), _to_seconds(self._dst), self._tzname ) def unpickler(zone, utcoffset=None, dstoffset=None, tzname=None): """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. """ # Raises a KeyError if zone no longer exists, which should never happen # and would be a bug. tz = pytz.timezone(zone) # A StaticTzInfo - just return it if utcoffset is None: return tz # This pickle was created from a DstTzInfo. We need to # determine which of the list of tzinfo instances for this zone # to use in order to restore the state of any datetime instances using # it correctly. utcoffset = memorized_timedelta(utcoffset) dstoffset = memorized_timedelta(dstoffset) try: return tz._tzinfos[(utcoffset, dstoffset, tzname)] except KeyError: # The particular state requested in this timezone no longer exists. # This indicates a corrupt pickle, or the timezone database has been # corrected violently enough to make this particular # (utcoffset,dstoffset) no longer exist in the zone, or the # abbreviation has been changed. pass # See if we can find an entry differing only by tzname. Abbreviations # get changed from the initial guess by the database maintainers to # match reality when this information is discovered. for localized_tz in tz._tzinfos.values(): if (localized_tz._utcoffset == utcoffset and localized_tz._dst == dstoffset): return localized_tz # This (utcoffset, dstoffset) information has been removed from the # zone. Add it back. This might occur when the database maintainers have # corrected incorrect information. datetime instances using this # incorrect information will continue to do so, exactly as they were # before being pickled. This is purely an overly paranoid safety net - I # doubt this will ever been needed in real life. inf = (utcoffset, dstoffset, tzname) tz._tzinfos[inf] = tz.__class__(inf, tz._tzinfos) return tz._tzinfos[inf] tzfile.py 0000644 00000011235 15030534450 0006414 0 ustar 00 ''' $Id: tzfile.py,v 1.8 2004/06/03 00:15:24 zenzen Exp $ ''' from datetime import datetime from struct import unpack, calcsize from pytz.tzinfo import StaticTzInfo, DstTzInfo, memorized_ttinfo from pytz.tzinfo import memorized_datetime, memorized_timedelta def _byte_string(s): """Cast a string or byte string to an ASCII byte string.""" return s.encode('ASCII') _NULL = _byte_string('\0') def _std_string(s): """Cast a string or byte string to an ASCII string.""" return str(s.decode('ASCII')) def build_tzinfo(zone, fp): head_fmt = '>4s c 15x 6l' head_size = calcsize(head_fmt) (magic, format, ttisgmtcnt, ttisstdcnt, leapcnt, timecnt, typecnt, charcnt) = unpack(head_fmt, fp.read(head_size)) # Make sure it is a tzfile(5) file assert magic == _byte_string('TZif'), 'Got magic %s' % repr(magic) # Read out the transition times, localtime indices and ttinfo structures. data_fmt = '>%(timecnt)dl %(timecnt)dB %(ttinfo)s %(charcnt)ds' % dict( timecnt=timecnt, ttinfo='lBB' * typecnt, charcnt=charcnt) data_size = calcsize(data_fmt) data = unpack(data_fmt, fp.read(data_size)) # make sure we unpacked the right number of values assert len(data) == 2 * timecnt + 3 * typecnt + 1 transitions = [memorized_datetime(trans) for trans in data[:timecnt]] lindexes = list(data[timecnt:2 * timecnt]) ttinfo_raw = data[2 * timecnt:-1] tznames_raw = data[-1] del data # Process ttinfo into separate structs ttinfo = [] tznames = {} i = 0 while i < len(ttinfo_raw): # have we looked up this timezone name yet? tzname_offset = ttinfo_raw[i + 2] if tzname_offset not in tznames: nul = tznames_raw.find(_NULL, tzname_offset) if nul < 0: nul = len(tznames_raw) tznames[tzname_offset] = _std_string( tznames_raw[tzname_offset:nul]) ttinfo.append((ttinfo_raw[i], bool(ttinfo_raw[i + 1]), tznames[tzname_offset])) i += 3 # Now build the timezone object if len(ttinfo) == 1 or len(transitions) == 0: ttinfo[0][0], ttinfo[0][2] cls = type(zone, (StaticTzInfo,), dict( zone=zone, _utcoffset=memorized_timedelta(ttinfo[0][0]), _tzname=ttinfo[0][2])) else: # Early dates use the first standard time ttinfo i = 0 while ttinfo[i][1]: i += 1 if ttinfo[i] == ttinfo[lindexes[0]]: transitions[0] = datetime.min else: transitions.insert(0, datetime.min) lindexes.insert(0, i) # calculate transition info transition_info = [] for i in range(len(transitions)): inf = ttinfo[lindexes[i]] utcoffset = inf[0] if not inf[1]: dst = 0 else: for j in range(i - 1, -1, -1): prev_inf = ttinfo[lindexes[j]] if not prev_inf[1]: break dst = inf[0] - prev_inf[0] # dst offset # Bad dst? Look further. DST > 24 hours happens when # a timzone has moved across the international dateline. if dst <= 0 or dst > 3600 * 3: for j in range(i + 1, len(transitions)): stdinf = ttinfo[lindexes[j]] if not stdinf[1]: dst = inf[0] - stdinf[0] if dst > 0: break # Found a useful std time. tzname = inf[2] # Round utcoffset and dst to the nearest minute or the # datetime library will complain. Conversions to these timezones # might be up to plus or minus 30 seconds out, but it is # the best we can do. utcoffset = int((utcoffset + 30) // 60) * 60 dst = int((dst + 30) // 60) * 60 transition_info.append(memorized_ttinfo(utcoffset, dst, tzname)) cls = type(zone, (DstTzInfo,), dict( zone=zone, _utc_transition_times=transitions, _transition_info=transition_info)) return cls() if __name__ == '__main__': import os.path from pprint import pprint # Patched in Debian, use the system zoninfo from the tzdata package base = '/usr/share/zoneinfo' tz = build_tzinfo('Australia/Melbourne', open(os.path.join(base, 'Australia', 'Melbourne'), 'rb')) tz = build_tzinfo('US/Eastern', open(os.path.join(base, 'US', 'Eastern'), 'rb')) pprint(tz._utc_transition_times) exceptions.py 0000644 00000003043 15030534450 0007276 0 ustar 00 ''' Custom exceptions raised by pytz. ''' __all__ = [ 'UnknownTimeZoneError', 'InvalidTimeError', 'AmbiguousTimeError', 'NonExistentTimeError', ] class Error(Exception): '''Base class for all exceptions raised by the pytz library''' class UnknownTimeZoneError(KeyError, Error): '''Exception raised when pytz is passed an unknown timezone. >>> isinstance(UnknownTimeZoneError(), LookupError) True This class is actually a subclass of KeyError to provide backwards compatibility with code relying on the undocumented behavior of earlier pytz releases. >>> isinstance(UnknownTimeZoneError(), KeyError) True And also a subclass of pytz.exceptions.Error, as are other pytz exceptions. >>> isinstance(UnknownTimeZoneError(), Error) True ''' pass class InvalidTimeError(Error): '''Base class for invalid time exceptions.''' class AmbiguousTimeError(InvalidTimeError): '''Exception raised when attempting to create an ambiguous wallclock time. At the end of a DST transition period, a particular wallclock time will occur twice (once before the clocks are set back, once after). Both possibilities may be correct, unless further information is supplied. See DstTzInfo.normalize() for more info ''' class NonExistentTimeError(InvalidTimeError): '''Exception raised when attempting to create a wallclock time that cannot exist. At the start of a DST transition period, the wallclock time jumps forward. The instants jumped over never occur. ''' __init__.py 0000644 00000042737 15030534450 0006671 0 ustar 00 ''' datetime.tzinfo timezone definitions generated from the Olson timezone database: ftp://elsie.nci.nih.gov/pub/tz*.tar.gz See the datetime section of the Python Library Reference for information on how to use these modules. ''' import sys import datetime import os.path import pathlib import re import zoneinfo from pytz.exceptions import AmbiguousTimeError from pytz.exceptions import InvalidTimeError from pytz.exceptions import NonExistentTimeError from pytz.exceptions import UnknownTimeZoneError from pytz.lazy import LazyDict, LazyList, LazySet # noqa from pytz.tzinfo import unpickler, BaseTzInfo from pytz.tzfile import build_tzinfo def _read_olson_version() -> str: tzdata_zi = pathlib.Path("/usr/share/zoneinfo/tzdata.zi") with tzdata_zi.open(encoding="utf-8") as tzdata_zi_file: line = tzdata_zi_file.readline() match = re.match("^#\s*version\s*([0-9a-z]*)\s*$", line) if match: return match.group(1) return "unknown" # The IANA (nee Olson) database is updated several times a year. OLSON_VERSION = _read_olson_version() VERSION = '2022.1' # pip compatible version number. __version__ = VERSION OLSEN_VERSION = OLSON_VERSION # Old releases had this misspelling __all__ = [ 'timezone', 'utc', 'country_timezones', 'country_names', 'AmbiguousTimeError', 'InvalidTimeError', 'NonExistentTimeError', 'UnknownTimeZoneError', 'all_timezones', 'all_timezones_set', 'common_timezones', 'common_timezones_set', 'BaseTzInfo', 'FixedOffset', ] if sys.version_info[0] > 2: # Python 3.x # Python 3.x doesn't have unicode(), making writing code # for Python 2.3 and Python 3.x a pain. unicode = str def ascii(s): r""" >>> ascii('Hello') 'Hello' >>> ascii('\N{TRADE MARK SIGN}') #doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... UnicodeEncodeError: ... """ if type(s) == bytes: s = s.decode('ASCII') else: s.encode('ASCII') # Raise an exception if not ASCII return s # But the string - not a byte string. else: # Python 2.x def ascii(s): r""" >>> ascii('Hello') 'Hello' >>> ascii(u'Hello') 'Hello' >>> ascii(u'\N{TRADE MARK SIGN}') #doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... UnicodeEncodeError: ... """ return s.encode('ASCII') def open_resource(name): """Open a resource from the zoneinfo subdir for reading. Uses the pkg_resources module if available and no standard file found at the calculated location. It is possible to specify different location for zoneinfo subdir by using the PYTZ_TZDATADIR environment variable. """ name_parts = name.lstrip('/').split('/') for part in name_parts: if part == os.path.pardir or os.path.sep in part: raise ValueError('Bad path segment: %r' % part) zoneinfo_dir = os.environ.get('PYTZ_TZDATADIR', None) if zoneinfo_dir is not None: filename = os.path.join(zoneinfo_dir, *name_parts) else: filename = os.path.join('/usr','share', 'zoneinfo', *name_parts) if not os.path.exists(filename): # http://bugs.launchpad.net/bugs/383171 - we avoid using this # unless absolutely necessary to help when a broken version of # pkg_resources is installed. try: from pkg_resources import resource_stream except ImportError: resource_stream = None if resource_stream is not None: return resource_stream(__name__, 'zoneinfo/' + name) return open(filename, 'rb') def resource_exists(name): """Return true if the given resource exists""" try: if os.environ.get('PYTZ_SKIPEXISTSCHECK', ''): # In "standard" distributions, we can assume that # all the listed timezones are present. As an # import-speed optimization, you can set the # PYTZ_SKIPEXISTSCHECK flag to skip checking # for the presence of the resource file on disk. return True open_resource(name).close() return True except IOError: return False _tzinfo_cache = {} def timezone(zone): r''' Return a datetime.tzinfo implementation for the given timezone >>> from datetime import datetime, timedelta >>> utc = timezone('UTC') >>> eastern = timezone('US/Eastern') >>> eastern.zone 'US/Eastern' >>> timezone(unicode('US/Eastern')) is eastern True >>> utc_dt = datetime(2002, 10, 27, 6, 0, 0, tzinfo=utc) >>> loc_dt = utc_dt.astimezone(eastern) >>> fmt = '%Y-%m-%d %H:%M:%S %Z (%z)' >>> loc_dt.strftime(fmt) '2002-10-27 01:00:00 EST (-0500)' >>> (loc_dt - timedelta(minutes=10)).strftime(fmt) '2002-10-27 00:50:00 EST (-0500)' >>> eastern.normalize(loc_dt - timedelta(minutes=10)).strftime(fmt) '2002-10-27 01:50:00 EDT (-0400)' >>> (loc_dt + timedelta(minutes=10)).strftime(fmt) '2002-10-27 01:10:00 EST (-0500)' Raises UnknownTimeZoneError if passed an unknown zone. >>> try: ... timezone('Asia/Shangri-La') ... except UnknownTimeZoneError: ... print('Unknown') Unknown >>> try: ... timezone(unicode('\N{TRADE MARK SIGN}')) ... except UnknownTimeZoneError: ... print('Unknown') Unknown ''' if zone is None: raise UnknownTimeZoneError(None) if zone.upper() == 'UTC': return utc try: zone = ascii(zone) except UnicodeEncodeError: # All valid timezones are ASCII raise UnknownTimeZoneError(zone) zone = _case_insensitive_zone_lookup(_unmunge_zone(zone)) if zone not in _tzinfo_cache: if zone in all_timezones_set: # noqa fp = open_resource(zone) try: _tzinfo_cache[zone] = build_tzinfo(zone, fp) finally: fp.close() else: raise UnknownTimeZoneError(zone) return _tzinfo_cache[zone] def _unmunge_zone(zone): """Undo the time zone name munging done by older versions of pytz.""" return zone.replace('_plus_', '+').replace('_minus_', '-') _all_timezones_lower_to_standard = None def _case_insensitive_zone_lookup(zone): """case-insensitively matching timezone, else return zone unchanged""" global _all_timezones_lower_to_standard if _all_timezones_lower_to_standard is None: _all_timezones_lower_to_standard = dict((tz.lower(), tz) for tz in all_timezones) # noqa return _all_timezones_lower_to_standard.get(zone.lower()) or zone # noqa ZERO = datetime.timedelta(0) HOUR = datetime.timedelta(hours=1) class UTC(BaseTzInfo): """UTC Optimized UTC implementation. It unpickles using the single module global instance defined beneath this class declaration. """ zone = "UTC" _utcoffset = ZERO _dst = ZERO _tzname = zone def fromutc(self, dt): if dt.tzinfo is None: return self.localize(dt) return super(utc.__class__, self).fromutc(dt) def utcoffset(self, dt): return ZERO def tzname(self, dt): return "UTC" def dst(self, dt): return ZERO def __reduce__(self): return _UTC, () def localize(self, dt, is_dst=False): '''Convert naive time to local time''' if dt.tzinfo is not None: raise ValueError('Not naive datetime (tzinfo is already set)') return dt.replace(tzinfo=self) def normalize(self, dt, is_dst=False): '''Correct the timezone information on the given datetime''' if dt.tzinfo is self: return dt if dt.tzinfo is None: raise ValueError('Naive time - no tzinfo set') return dt.astimezone(self) def __repr__(self): return "<UTC>" def __str__(self): return "UTC" UTC = utc = UTC() # UTC is a singleton def _UTC(): """Factory function for utc unpickling. Makes sure that unpickling a utc instance always returns the same module global. These examples belong in the UTC class above, but it is obscured; or in the README.rst, but we are not depending on Python 2.4 so integrating the README.rst examples with the unit tests is not trivial. >>> import datetime, pickle >>> dt = datetime.datetime(2005, 3, 1, 14, 13, 21, tzinfo=utc) >>> naive = dt.replace(tzinfo=None) >>> p = pickle.dumps(dt, 1) >>> naive_p = pickle.dumps(naive, 1) >>> len(p) - len(naive_p) 17 >>> new = pickle.loads(p) >>> new == dt True >>> new is dt False >>> new.tzinfo is dt.tzinfo True >>> utc is UTC is timezone('UTC') True >>> utc is timezone('GMT') False """ return utc _UTC.__safe_for_unpickling__ = True def _p(*args): """Factory function for unpickling pytz tzinfo instances. Just a wrapper around tzinfo.unpickler to save a few bytes in each pickle by shortening the path. """ return unpickler(*args) _p.__safe_for_unpickling__ = True class _CountryTimezoneDict(LazyDict): """Map ISO 3166 country code to a list of timezone names commonly used in that country. iso3166_code is the two letter code used to identify the country. >>> def print_list(list_of_strings): ... 'We use a helper so doctests work under Python 2.3 -> 3.x' ... for s in list_of_strings: ... print(s) >>> print_list(country_timezones['nz']) Pacific/Auckland Pacific/Chatham >>> print_list(country_timezones['ch']) Europe/Zurich >>> print_list(country_timezones['CH']) Europe/Zurich >>> print_list(country_timezones[unicode('ch')]) Europe/Zurich >>> print_list(country_timezones['XXX']) Traceback (most recent call last): ... KeyError: 'XXX' Previously, this information was exposed as a function rather than a dictionary. This is still supported:: >>> print_list(country_timezones('nz')) Pacific/Auckland Pacific/Chatham """ def __call__(self, iso3166_code): """Backwards compatibility.""" return self[iso3166_code] def _fill(self): data = {} zone_tab = open_resource('zone.tab') try: for line in zone_tab: line = line.decode('UTF-8') if line.startswith('#'): continue code, coordinates, zone = line.split(None, 4)[:3] if zone not in all_timezones_set: # noqa continue try: data[code].append(zone) except KeyError: data[code] = [zone] self.data = data finally: zone_tab.close() country_timezones = _CountryTimezoneDict() class _CountryNameDict(LazyDict): '''Dictionary proving ISO3166 code -> English name. >>> print(country_names['au']) Australia ''' def _fill(self): data = {} zone_tab = open_resource('iso3166.tab') try: for line in zone_tab.readlines(): line = line.decode('UTF-8') if line.startswith('#'): continue code, name = line.split(None, 1) data[code] = name.strip() self.data = data finally: zone_tab.close() country_names = _CountryNameDict() # Time-zone info based solely on fixed offsets class _FixedOffset(datetime.tzinfo): zone = None # to match the standard pytz API def __init__(self, minutes): if abs(minutes) >= 1440: raise ValueError("absolute offset is too large", minutes) self._minutes = minutes self._offset = datetime.timedelta(minutes=minutes) def utcoffset(self, dt): return self._offset def __reduce__(self): return FixedOffset, (self._minutes, ) def dst(self, dt): return ZERO def tzname(self, dt): return None def __repr__(self): return 'pytz.FixedOffset(%d)' % self._minutes def localize(self, dt, is_dst=False): '''Convert naive time to local time''' if dt.tzinfo is not None: raise ValueError('Not naive datetime (tzinfo is already set)') return dt.replace(tzinfo=self) def normalize(self, dt, is_dst=False): '''Correct the timezone information on the given datetime''' if dt.tzinfo is self: return dt if dt.tzinfo is None: raise ValueError('Naive time - no tzinfo set') return dt.astimezone(self) def FixedOffset(offset, _tzinfos={}): """return a fixed-offset timezone based off a number of minutes. >>> one = FixedOffset(-330) >>> one pytz.FixedOffset(-330) >>> str(one.utcoffset(datetime.datetime.now())) '-1 day, 18:30:00' >>> str(one.dst(datetime.datetime.now())) '0:00:00' >>> two = FixedOffset(1380) >>> two pytz.FixedOffset(1380) >>> str(two.utcoffset(datetime.datetime.now())) '23:00:00' >>> str(two.dst(datetime.datetime.now())) '0:00:00' The datetime.timedelta must be between the range of -1 and 1 day, non-inclusive. >>> FixedOffset(1440) Traceback (most recent call last): ... ValueError: ('absolute offset is too large', 1440) >>> FixedOffset(-1440) Traceback (most recent call last): ... ValueError: ('absolute offset is too large', -1440) An offset of 0 is special-cased to return UTC. >>> FixedOffset(0) is UTC True There should always be only one instance of a FixedOffset per timedelta. This should be true for multiple creation calls. >>> FixedOffset(-330) is one True >>> FixedOffset(1380) is two True It should also be true for pickling. >>> import pickle >>> pickle.loads(pickle.dumps(one)) is one True >>> pickle.loads(pickle.dumps(two)) is two True """ if offset == 0: return UTC info = _tzinfos.get(offset) if info is None: # We haven't seen this one before. we need to save it. # Use setdefault to avoid a race condition and make sure we have # only one info = _tzinfos.setdefault(offset, _FixedOffset(offset)) return info FixedOffset.__safe_for_unpickling__ = True def _test(): import doctest sys.path.insert(0, os.pardir) import pytz return doctest.testmod(pytz) def _read_timezones_from_zone_tab() -> set[str]: timezones = set() zone_tab = pathlib.Path("/usr/share/zoneinfo/zone1970.tab") for line in zone_tab.read_text(encoding="utf-8").splitlines(): if line.startswith("#"): continue timezones.add(line.split("\t")[2]) return timezones if __name__ == '__main__': _test() _extra_common_timezones_set = { 'Africa/Accra', 'Africa/Addis_Ababa', 'Africa/Asmara', 'Africa/Bamako', 'Africa/Bangui', 'Africa/Banjul', 'Africa/Blantyre', 'Africa/Brazzaville', 'Africa/Bujumbura', 'Africa/Conakry', 'Africa/Dakar', 'Africa/Dar_es_Salaam', 'Africa/Djibouti', 'Africa/Douala', 'Africa/Freetown', 'Africa/Gaborone', 'Africa/Harare', 'Africa/Kampala', 'Africa/Kigali', 'Africa/Kinshasa', 'Africa/Libreville', 'Africa/Lome', 'Africa/Luanda', 'Africa/Lubumbashi', 'Africa/Lusaka', 'Africa/Malabo', 'Africa/Maseru', 'Africa/Mbabane', 'Africa/Mogadishu', 'Africa/Niamey', 'Africa/Nouakchott', 'Africa/Ouagadougou', 'Africa/Porto-Novo', 'America/Anguilla', 'America/Antigua', 'America/Aruba', 'America/Atikokan', 'America/Blanc-Sablon', 'America/Cayman', 'America/Creston', 'America/Curacao', 'America/Dominica', 'America/Grenada', 'America/Guadeloupe', 'America/Kralendijk', 'America/Lower_Princes', 'America/Marigot', 'America/Montserrat', 'America/Nassau', 'America/Port_of_Spain', 'America/St_Barthelemy', 'America/St_Kitts', 'America/St_Lucia', 'America/St_Thomas', 'America/St_Vincent', 'America/Tortola', 'Antarctica/DumontDUrville', 'Antarctica/McMurdo', 'Antarctica/Syowa', 'Antarctica/Vostok', 'Arctic/Longyearbyen', 'Asia/Aden', 'Asia/Bahrain', 'Asia/Brunei', 'Asia/Kuala_Lumpur', 'Asia/Kuwait', 'Asia/Muscat', 'Asia/Phnom_Penh', 'Asia/Vientiane', 'Atlantic/Reykjavik', 'Atlantic/St_Helena', 'Canada/Atlantic', 'Canada/Central', 'Canada/Eastern', 'Canada/Mountain', 'Canada/Newfoundland', 'Canada/Pacific', 'Europe/Amsterdam', 'Europe/Bratislava', 'Europe/Busingen', 'Europe/Copenhagen', 'Europe/Guernsey', 'Europe/Isle_of_Man', 'Europe/Jersey', 'Europe/Ljubljana', 'Europe/Luxembourg', 'Europe/Mariehamn', 'Europe/Monaco', 'Europe/Oslo', 'Europe/Podgorica', 'Europe/San_Marino', 'Europe/Sarajevo', 'Europe/Skopje', 'Europe/Stockholm', 'Europe/Vaduz', 'Europe/Vatican', 'Europe/Zagreb', 'GMT', 'Indian/Antananarivo', 'Indian/Christmas', 'Indian/Cocos', 'Indian/Comoro', 'Indian/Kerguelen', 'Indian/Mahe', 'Indian/Mayotte', 'Indian/Reunion', 'Pacific/Chuuk', 'Pacific/Funafuti', 'Pacific/Majuro', 'Pacific/Midway', 'Pacific/Pohnpei', 'Pacific/Saipan', 'Pacific/Wake', 'Pacific/Wallis', 'US/Alaska', 'US/Arizona', 'US/Central', 'US/Eastern', 'US/Hawaii', 'US/Mountain', 'US/Pacific', 'UTC'} all_timezones_set = zoneinfo.available_timezones() - {"Factory", "localtime"} common_timezones_set = (_read_timezones_from_zone_tab() | _extra_common_timezones_set) & all_timezones_set all_timezones = sorted(all_timezones_set) common_timezones = sorted(common_timezones_set)
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.02 |
proxy
|
phpinfo
|
Settings