Current File : //usr/lib/python3.9/site-packages/dateutil/tz/__pycache__/_common.cpython-39.pyc
a
&�i�2 � @ s� d dl mZ d dlmZ d dlmZmZmZ ed �ZddgZdd� Z e
ed�rZdd d�Z nG d
d � d e�Z dd d�Z d
d� Z
G dd� de�ZG dd� de�ZdS )� )�PY2��wraps)�datetime� timedelta�tzinfo�tzname_in_python2�enfoldc s$ t r t� �� fdd��}|S � S dS )z�Change unicode output into bytestrings in Python 2
tzname() API changed in Python 3. It used to return bytes, but was changed
to unicode strings
c s" � | i |��}|d ur |� � }|S �N)�encode)�args�kwargs�name��namefunc� �7/usr/lib/python3.9/site-packages/dateutil/tz/_common.py�adjust_encoding s z*tzname_in_python2.<locals>.adjust_encodingN)r r )r r r r r r
s
�fold� c C s | j |d�S )�
Provides a unified interface for assigning the ``fold`` attribute to
datetimes both before and after the implementation of PEP-495.
:param fold:
The value for the ``fold`` attribute in the returned datetime. This
should be either 0 or 1.
:return:
Returns an object for which ``getattr(dt, 'fold', 0)`` returns
``fold`` for all versions of Python. In versions prior to
Python 3.6, this is a ``_DatetimeWithFold`` object, which is a
subclass of :py:class:`datetime.datetime` with the ``fold``
attribute added, if ``fold`` is 1.
.. versionadded:: 2.6.0
�r ��replace)�dtr r r r r % s c @ s( e Zd ZdZdZdd� Zedd� �ZdS )�_DatetimeWithFoldz�
This is a class designed to provide a PEP 495-compliant interface for
Python versions before 3.6. It is used only for dates in a fold, so
the ``fold`` attribute is fixed at ``1``.
.. versionadded:: 2.6.0
r c O sz d}t ||�D ]&\}}||v r,td�|���|||< q|D ]}||vr:t| |�||< q:|�dd�rh| jnt}|f i |��S )a�
Return a datetime with the same attributes, except for those
attributes given new values by whichever keyword arguments are
specified. Note that tzinfo=None can be specified to create a naive
datetime from an aware datetime with no conversion of date and time
data.
This is reimplemented in ``_DatetimeWithFold`` because pypy3 will
return a ``datetime.datetime`` even if ``fold`` is unchanged.
)�yearZmonthZdayZhourZminute�second� microsecondr zDuplicate argument: {}r r )�zip� TypeError�format�getattr�get� __class__r )�selfr r
Zargnames�arg�argnameZdt_classr r r r D s
z_DatetimeWithFold.replacec C s dS )Nr r �r% r r r r b s z_DatetimeWithFold.foldN)�__name__�
__module__� __qualname__�__doc__� __slots__r �propertyr r r r r r : s
r c C sL t | dd�|kr| S | �� dd� }|| j| jf7 }|r@t|� S t|� S dS )r r r N� )r" Z timetupler r r r )r r r r r r r f s c s t � �� fdd��}|S )z�
The CPython version of ``fromutc`` checks that the input is a ``datetime``
object and that ``self`` is attached as its ``tzinfo``.
c s. t |t�std��|j| ur$td��� | |�S )N�&fromutc() requires a datetime argument�dt.tzinfo is not self)�
isinstancer r r �
ValueError�r% r ��fr r �fromutc� s
z)_validate_fromutc_inputs.<locals>.fromutcr )r6 r7 r r5 r �_validate_fromutc_inputs� s r8 c @ s< e Zd ZdZdd� Zdd� Zdd� Zdd � Zed
d � �Z d S )
�_tzinfoz=
Base class for all ``dateutil`` ``tzinfo`` objects.
c C sV |j | d�}t|dd�}t|dd�}|�� |�� k}|j dd�|j dd�k}|oT| S )�6
Whether or not the "wall time" of a given datetime is ambiguous in this
zone.
:param dt:
A :py:class:`datetime.datetime`, naive or time zone aware.
:return:
Returns ``True`` if ambiguous, ``False`` otherwise.
.. versionadded:: 2.6.0
�r r r r N)r r � utcoffset)r% r Zwall_0Zwall_1Z same_offsetZsame_dtr r r � is_ambiguous� s z_tzinfo.is_ambiguousc C s4 | � |�r,|| }t||�� |�� k�}nd}|S )a�
Determine the fold status of a "wall" datetime, given a representation
of the same datetime as a (naive) UTC datetime. This is calculated based
on the assumption that ``dt.utcoffset() - dt.dst()`` is constant for all
datetimes, and that this offset is the actual number of hours separating
``dt_utc`` and ``dt_wall``.
:param dt_utc:
Representation of the datetime as UTC
:param dt_wall:
Representation of the datetime as "wall time". This parameter must
either have a `fold` attribute or have a fold-naive
:class:`datetime.tzinfo` attached, otherwise the calculation may
fail.
r )r= �intr< �dst)r% �dt_utc�dt_wallZ
delta_wall�_foldr r r � _fold_status� s
z_tzinfo._fold_statusc C s t |dd�S )Nr r )r" r4 r r r rB � s z
_tzinfo._foldc C sh |� � }|du rtd��|�� }|du r0td��|| }||7 }t|dd��� }|du r`td��|| S )�
Given a timezone-aware datetime in a given timezone, calculates a
timezone-aware datetime in a new timezone.
Since this is the one time that we *know* we have an unambiguous
datetime object, we take this opportunity to determine whether the
datetime is ambiguous and in a "fold" state (e.g. if it's the first
occurrence, chronologically, of the ambiguous datetime).
:param dt:
A timezone-aware :class:`datetime.datetime` object.
Nz0fromutc() requires a non-None utcoffset() resultz*fromutc() requires a non-None dst() resultr r z;fromutc(): dt.dst gave inconsistent results; cannot convert)r< r3 r? r )r% r ZdtoffZdtdstZdeltar r r �_fromutc� s z_tzinfo._fromutcc C s" | � |�}| �||�}t||d�S )rD r )rE rC r )r% r rA rB r r r r7 � s
z_tzinfo.fromutcN)
r) r* r+ r, r= rC rB rE r8 r7 r r r r r9 � s %r9 c @ sz e Zd ZdZdd� Zdd� Zdd� Zedd � �Zd
d � Z d d
� Z
dd� Z dd� Z e
dd� �ZdZdd� Zdd� ZejZdS )� tzrangebasea�
This is an abstract base class for time zones represented by an annual
transition into and out of DST. Child classes should implement the following
methods:
* ``__init__(self, *args, **kwargs)``
* ``transitions(self, year)`` - this is expected to return a tuple of
datetimes representing the DST on and off transitions in standard
time.
A fully initialized ``tzrangebase`` subclass should also provide the
following attributes:
* ``hasdst``: Boolean whether or not the zone uses DST.
* ``_dst_offset`` / ``_std_offset``: :class:`datetime.timedelta` objects
representing the respective UTC offsets.
* ``_dst_abbr`` / ``_std_abbr``: Strings representing the timezone short
abbreviations in DST and STD, respectively.
* ``_hasdst``: Whether or not the zone has DST.
.. versionadded:: 2.6.0
c C s t d��d S )Nz%tzrangebase is an abstract base class)�NotImplementedErrorr( r r r �__init__! s ztzrangebase.__init__c C s* | � |�}|d u rd S |r | jS | jS d S r
)�_isdst� _dst_offset� _std_offset�r% r �isdstr r r r< $ s
ztzrangebase.utcoffsetc C s( | � |�}|d u rd S |r | jS tS d S r
)rI �_dst_base_offset�ZEROrL r r r r? . s
ztzrangebase.dstc C s | � |�r| jS | jS d S r
)rI Z _dst_abbrZ _std_abbrr4 r r r �tzname8 s
ztzrangebase.tznamec
C s� t |t�std��|j| ur$td��| �|j�}|du rF|| �|� S |\}}|| j8 }|| j8 }||f}|j dd�}| �
||�}|r�|| j }n
|| j }t | o�| �
|��} t|| d�S )z, Given a datetime in UTC, return local time r0 r1 Nr; r )r2 r r r r3 � transitionsr r< rK r � _naive_isdstrJ r> r= r )
r% r rQ �dston�dstoffZutc_transitionsr@ rM rA rB r r r r7 ? s$
ztzrangebase.fromutcc C sD | j s
dS | �|j�\}}|jdd�}|| ko>|| j k S S )r: FNr; )�hasdstrQ r r rN )r% r �start�endr r r r= ` s
ztzrangebase.is_ambiguousc C sh | j s
dS |d u rd S | �|j�}|d u r.dS |jd d�}| �||�}|s`| �|�r`| �|� S |S d S )NFr; )rU rQ r r rR r= rB )r% r rQ rM r r r rI v s ztzrangebase._isdstc C sT |\}}|j d d�}||k r6|| ko.|k n }n|| koH|k n }|S )Nr; r )r% r rQ rS rT rM r r r rR � s ztzrangebase._naive_isdstc C s | j | j S r
)rJ rK r( r r r rN � s z tzrangebase._dst_base_offsetNc C s
| |k S r
r )r% �otherr r r �__ne__� s ztzrangebase.__ne__c C s d| j j S )Nz%s(...))r$ r) r( r r r �__repr__� s ztzrangebase.__repr__)r) r* r+ r, rH r< r? r rP r7 r= rI rR r. rN �__hash__rY rZ �object�
__reduce__r r r r rF s
!
rF N)r )r )Zsixr � functoolsr r r r rO �__all__r �hasattrr r r8 r9 rF r r r r �<module> s
,
v
Mini Shell