o
    Šôj±2  ã                   @   s    d dl mZ d dlmZ d dlmZmZmZ ed ƒZddgZdd„ Z	e
edƒr-dd	d„ZnG d
d„ deƒZddd„Zdd„ ZG dd„ deƒZG dd„ deƒZdS )é    )ÚPY2©Úwraps)ÚdatetimeÚ	timedeltaÚtzinfoÚtzname_in_python2Úenfoldc                    s    t rtˆ ƒ‡ fdd„ƒ}|S ˆ S )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 ur|  ¡ }|S ©N)Úencode)ÚargsÚkwargsÚname©Únamefunc© úf/var/www/html/academy/tools/voices/clone/cosy-venv/lib/python3.10/site-packages/dateutil/tz/_common.pyÚadjust_encoding   s   z*tzname_in_python2.<locals>.adjust_encoding)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 Zd ZdZdZdd„ Zedd„ ƒZdS )Ú_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td |¡ƒ‚|||< q|D ]}||vr*t| |ƒ||< q| dd¡r4| jnt}|d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.
            )ÚyearÚmonthÚdayÚhourÚminuteÚsecondÚmicrosecondr   zDuplicate argument: {}r   r   Nr   )ÚzipÚ	TypeErrorÚformatÚgetattrÚgetÚ	__class__r   )Úselfr   r   ÚargnamesÚargÚargnameZdt_classr   r   r   r   D   s   
€z_DatetimeWithFold.replacec                 C   s   dS )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   sH   t | ddƒ|kr
| S |  ¡ dd… }|| j| jf7 }|r t|Ž S t|Ž S )r   r   r   Né   )r&   Ú	timetupler"   r   r   r   )r   r   r   r   r   r   r	   f   s   c                    s   t ˆ ƒ‡ fdd„ƒ}|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ƒs	tdƒ‚|j| urtdƒ‚ˆ | |ƒ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   )r<   r=   r   r;   r   Ú_validate_fromutc_inputs„   s   r>   c                   @   s<   e Zd ZdZdd„ Zdd„ Zdd„ Zdd	„ Zed
d„ ƒZ	dS )Ú_tzinfoz=
    Base class for all ``dateutil`` ``tzinfo`` objects.
    c                 C   sV   |j | d�}t|dd�}t|dd�}| ¡ | ¡ k}|j dd�|j dd�k}|o*| 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   Úwall_0Úwall_1Úsame_offsetZsame_dtr   r   r   Úis_ambiguousš   s   
z_tzinfo.is_ambiguousc                 C   s6   |   |¡r|| }t|| ¡ | ¡  kƒ}|S d}|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   )rF   ÚintrB   Údst)r)   Údt_utcÚdt_wallZ
delta_wallÚ_foldr   r   r   Ú_fold_status³   s   
þz_tzinfo._fold_statusc                 C   s   t |ddƒS )Nr   r   )r&   r:   r   r   r   rK   Ì   ó   z_tzinfo._foldc                 C   sh   |  ¡ }|du rtdƒ‚| ¡ }|du rtdƒ‚|| }||7 }t|dd� ¡ }|du r0tdƒ‚|| 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)rB   r9   rH   r	   )r)   r   ZdtoffZdtdstÚdeltar   r   r   Ú_fromutcÏ   s   z_tzinfo._fromutcc                 C   s"   |   |¡}|  ||¡}t||d�S )rN   r   )rP   rL   r	   )r)   r   rJ   rK   r   r   r   r=   ô   s   
z_tzinfo.fromutcN)
r.   r/   r0   r1   rF   rL   rK   rP   r>   r=   r   r   r   r   r?   •   s    %r?   c                   @   sz   e Zd ZdZdd„ Zdd„ Zdd„ Zedd	„ ƒZd
d„ Z	dd„ Z
dd„ Zdd„ Zedd„ ƒZdZdd„ Zdd„ ZejZdS )Ú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ƒ‚)Nz%tzrangebase is an abstract base class)ÚNotImplementedErrorr-   r   r   r   Ú__init__!  s   ztzrangebase.__init__c                 C   s&   |   |¡}|d u rd S |r| jS | jS r
   )Ú_isdstÚ_dst_offsetÚ_std_offset©r)   r   Úisdstr   r   r   rB   $  s   
ztzrangebase.utcoffsetc                 C   s$   |   |¡}|d u rd S |r| jS tS r
   )rT   Ú_dst_base_offsetÚZEROrW   r   r   r   rH   .  s   
ztzrangebase.dstc                 C   s   |   |¡r| jS | jS r
   )rT   Ú	_dst_abbrÚ	_std_abbrr:   r   r   r   Útzname8  s   
ztzrangebase.tznamec           
      C   s¼   t |tƒs	tdƒ‚|j| urtdƒ‚|  |j¡}|du r#||  |¡ S |\}}|| j8 }|| j8 }||f}|j	dd�}|  
||¡}|rI|| j }n|| j }t| oV|  |¡ƒ}	t||	d�S )z, Given a datetime in UTC, return local time r6   r7   NrA   r   )r8   r   r$   r   r9   Útransitionsr   rB   rV   r   Ú_naive_isdstrU   rG   rF   r	   )
r)   r   r^   ÚdstonÚdstoffZutc_transitionsrI   rX   rJ   rK   r   r   r   r=   ?  s$   




ztzrangebase.fromutcc                 C   sD   | j sdS |  |j¡\}}|jdd�}||  ko|| j k S   S )r@   FNrA   )Úhasdstr^   r   r   rY   )r)   r   ÚstartÚendr   r   r   rF   `  s
   ztzrangebase.is_ambiguousc                 C   sd   | j sdS |d u rd S |  |j¡}|d u rdS |jd d�}|  ||¡}|s0|  |¡r0|  |¡ S |S )NFrA   )rb   r^   r   r   r_   rF   rK   )r)   r   r^   rX   r   r   r   rT   v  s   ztzrangebase._isdstc                 C   sZ   |\}}|j d d�}||k r||  ko|k }|S   }|S ||  ko'|k n   }|S )NrA   r   )r)   r   r^   r`   ra   rX   r   r   r   r_   ‹  s   üþztzrangebase._naive_isdstc                 C   s   | j | j S r
   )rU   rV   r-   r   r   r   rY   —  s   ztzrangebase._dst_base_offsetNc                 C   s
   | |k S r
   r   )r)   Úotherr   r   r   Ú__ne__�  s   
ztzrangebase.__ne__c                 C   s   d| j j S )Nz%s(...))r(   r.   r-   r   r   r   Ú__repr__   rM   ztzrangebase.__repr__)r.   r/   r0   r1   rS   rB   rH   r   r]   r=   rF   rT   r_   r3   rY   Ú__hash__rf   rg   ÚobjectÚ
__reduce__r   r   r   r   rQ     s"    


!

rQ   N)r   )Úsixr   Ú	functoolsr   r   r   r   rZ   Ú__all__r   Úhasattrr	   r   r>   r?   rQ   r   r   r   r   Ú<module>   s    

,v