__  __    __   __  _____      _            _          _____ _          _ _ 
 |  \/  |   \ \ / / |  __ \    (_)          | |        / ____| |        | | |
 | \  / |_ __\ V /  | |__) | __ ___   ____ _| |_ ___  | (___ | |__   ___| | |
 | |\/| | '__|> <   |  ___/ '__| \ \ / / _` | __/ _ \  \___ \| '_ \ / _ \ | |
 | |  | | |_ / . \  | |   | |  | |\ V / (_| | ||  __/  ____) | | | |  __/ | |
 |_|  |_|_(_)_/ \_\ |_|   |_|  |_| \_/ \__,_|\__\___| |_____/|_| |_|\___V 2.1
 if you need WebShell for Seo everyday contact me on Telegram
 Telegram Address : @jackleet
        
        
For_More_Tools: Telegram: @jackleet | Bulk Smtp support mail sender | Business Mail Collector | Mail Bouncer All Mail | Bulk Office Mail Validator | Html Letter private



Upload:

Command:

[email protected]: ~ $
�

k��gg���H�SrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKJ	r	 SSK
r
SSKJrJ
r
 SSKJrJr SSKJr SSKJrJr SS	KJr SS
KJrJr SSKJr \R6"S5r\R"SSSSS5r\R=5r"S
S\R@\S9r!\!"5r""SS\R@\S9r#"SS\
5r$"SS\%5r&"SS\%5r'"SS\
5r("SS\5r)"SS\)\S9r*"SS\%5r+"S S!\
5r,"S"S#\%5r-\R\S$:wa	S%S&/r//S'Qr0O/r//r0S(r1\1"5r2C1S3S)jr3S3S*jr4S+r5S,r6\RnS-:�aS.r8OS/r8SS0K9J:r; g!\a S=rrGN3f=f!\a "S1S2\%5r;gf=f)4a�
This module offers timezone implementations subclassing the abstract
:py:class:`datetime.tzinfo` type. There are classes to handle tzfile format
files (usually are in :file:`/etc/localtime`, :file:`/usr/share/zoneinfo`,
etc), TZ environment string (in all known formats), given ranges (with help
from relative deltas), local machine timezone, fixed offset timezone, and UTC
timezone.
�N)�OrderedDict�)�tzname_in_python2�_tzinfo)�tzrangebase�enfold)�_validate_fromutc_inputs)�_TzSingleton�_TzOffsetFactory)�
_TzStrFactory)�tzwin�
tzwinlocal)�warni�c�x�\rSrSrSrSrSr\S5rSr	\
S5rSrS	r
S
rSr\R"rSrg	)
�tzutc�(a�
This is a tzinfo object that represents the UTC time zone.

**Examples:**

.. doctest::

    >>> from datetime import *
    >>> from dateutil.tz import *

    >>> datetime.now()
    datetime.datetime(2003, 9, 27, 9, 40, 1, 521290)

    >>> datetime.now(tzutc())
    datetime.datetime(2003, 9, 27, 12, 40, 12, 156379, tzinfo=tzutc())

    >>> datetime.now(tzutc()).tzname()
    'UTC'

.. versionchanged:: 2.7.0
    ``tzutc()`` is now a singleton, so the result of ``tzutc()`` will
    always return the same object.

    .. doctest::

        >>> from dateutil.tz import tzutc, UTC
        >>> tzutc() is tzutc()
        True
        >>> tzutc() is UTC
        True
c��[$�N��ZERO��self�dts  �0/usr/lib/python3/dist-packages/dateutil/tz/tz.py�	utcoffset�tzutc.utcoffsetH�����c��[$rrrs  r�dst�	tzutc.dstKrrc��g)N�UTC�rs  r�tzname�tzutc.tznameNs��rc��g)��
Whether or not the "wall time" of a given datetime is ambiguous in this
zone.

:param dt:
    A :py:class:`datetime.datetime`, naive or time zone aware.


:return:
    Returns ``True`` if ambiguous, ``False`` otherwise.

.. versionadded:: 2.6.0
Fr$rs  r�is_ambiguous�tzutc.is_ambiguousRs��rc��U$)zx
Fast track version of fromutc() returns the original ``dt`` object for
any valid :py:class:`datetime.datetime` object.
r$rs  r�fromutc�
tzutc.fromutcbs	���	rc���[U[[45(d[$[U[5=(d* [U[5=(a UR[
:H$r)�
isinstancer�tzoffset�NotImplemented�_offsetr�r�others  r�__eq__�tzutc.__eq__jsH���%�%��!2�3�3�!�!��5�%�(�H��E�8�,�F����$�1F�	IrNc��X:X+$rr$r3s  r�__ne__�tzutc.__ne__s����"�"rc�4�SURR-$�Nz%s()��	__class__�__name__�rs r�__repr__�tzutc.__repr__v�������/�/�/�/rr$)r?�
__module__�__qualname__�__firstlineno__�__doc__rr rr%r)r	r,r5�__hash__r8rA�object�
__reduce__�__static_attributes__r$rrrr(sb���>������� ����I��H�#�0��"�"�Jrr)�	metaclassc�~�\rSrSrSrSrSrSr\S5r	\
S5rSrS	r
S
rSrSr\R$rS
rg
)r0�a
A simple class for representing a fixed offset from UTC.

:param name:
    The timezone name, to be returned when ``tzname()`` is called.
:param offset:
    The time zone offset in seconds, or (since version 2.6.0, represented
    as a :py:class:`datetime.timedelta` object).
c��XlUR5n[R
"[
U5S9Ulg![[4a N5f=f�N��seconds)�_name�
total_seconds�	TypeError�AttributeError�datetime�	timedelta�_get_supported_offsetr2)r�name�offsets   r�__init__�tzoffset.__init__�sM���
�	��)�)�+�F� �)�)�2G��2O�P�����>�*�	��	�s�;�A�
Ac��UR$r�r2rs  rr�tzoffset.utcoffset�s���|�|�rc��[$rrrs  rr �tzoffset.dst�rrc��UR$r)rSrs  rr%�tzoffset.tzname�s���z�z�rc��XR-$rr_rs  rr,�tzoffset.fromutc�s���L�L� � rc��g)z�
Whether or not the "wall time" of a given datetime is ambiguous in this
zone.

:param dt:
    A :py:class:`datetime.datetime`, naive or time zone aware.
:return:
    Returns ``True`` if ambiguous, ``False`` otherwise.

.. versionadded:: 2.6.0
Fr$rs  rr)�tzoffset.is_ambiguous�s��rc�j�[U[5(d[$URUR:H$r)r/r0r1r2r3s  rr5�tzoffset.__eq__�s(���%��*�*�!�!��|�|�u�}�}�,�,rNc��X:X+$rr$r3s  rr8�tzoffset.__ne__�r:rc��URR<S[UR5<S[	UR
R
55<S3$)N�(�, �))r>r?�reprrS�intr2rTr@s rrA�tzoffset.__repr__�s<��#�~�~�6�6�#�D�J�J�/�"�4�<�<�#=�#=�#?�@�B�	Br)rSr2)r?rDrErFrGr\rr rr%r	r,r)r5rHr8rArIrJrKr$rrr0r0�sh���	Q��������!��!��-��H�#�B�
�"�"�Jrr0c�^�\rSrSrSrU4SjrSrSr\S5r	Sr
SrSS	jrS
r
SrSrS
r\R$rSrU=r$)�tzlocal��zJ
A :class:`tzinfo` subclass built around the ``time`` timezone functions.
c��>�[[U]5 [R"[
R*S9Ul[
R(a)[R"[
R*S9Ul
OURUl
URUR-
Ul[UR5Ul
[[
R5UlgrP)�superrur\rWrX�time�timezone�_std_offset�daylight�altzone�_dst_offset�
_dst_saved�bool�_hasdst�tupler%�_tznames)rr>s �rr\�tzlocal.__init__�s����
�g�t�%�'�#�-�-�t�}�}�n�E����=�=�'�1�1�4�<�<�-�H�D��#�/�/�D���*�*�T�-=�-=�=����D�O�O�,����d�k�k�*��
rc��UcUR(agURU5(aUR$UR$r)r��_isdstr~r{rs  rr�tzlocal.utcoffset�s5��
�:�$�,�,���;�;�r�?�?��#�#�#��#�#�#rc��UcUR(agURU5(aURUR-
$[$r)r�r�r~r{rrs  rr �tzlocal.dst�s9��
�:�$�,�,���;�;�r�?�?��#�#�d�&6�&6�6�6��Krc�>�URURU5$r)r�r�rs  rr%�tzlocal.tzname�s���}�}�T�[�[��_�-�-rc�~�URU5nU(+=(a X RXR-
5:g$)r()�
_naive_is_dstr)rr�	naive_dsts   rr)�tzlocal.is_ambiguous�s=���&�&�r�*�	��
�H��0�0��o�o�1E�F�F�	Irc�z�[U5n[R"U[R-5R$r)�_datetime_to_timestampry�	localtimerz�tm_isdst)rr�	timestamps   rr��tzlocal._naive_is_dst�s*��*�2�.�	��~�~�i�$�-�-�7�8�A�A�Arc���UR(dgURU5n[USS5nURU5(aUbUR	U5(+$gU$)NF�foldT)r�r��getattrr)�_fold)rr�
fold_naive�dstvalr�s     rr��tzlocal._isdsts^��2�|�|���#�#�B�'���r�6�4�(�����R� � ����:�:�b�>�)�)���
rc�.�[U[5(a9URUR:H=(a URUR:H$[U[5(aDUR
(+=(a, URSS;=(a UR[:H$[U[5(aTUR
(+=(a< URSUR:H=(a URUR:H$[$)Nr>�GMTr#)r/rur{r~rr�r�rr0rSr2r1r3s  rr5�tzlocal.__eq__+s����e�W�%�%��$�$��(9�(9�9�:��$�$��(9�(9�9�
;�
��u�
%�
%����$�-��M�M�!�$��6�-��$�$��,�
.���x�
(�
(����$�6��M�M�!�$����3�6��$�$��
�
�5�
7�"�!rNc��X:X+$rr$r3s  rr8�tzlocal.__ne__<r:rc�4�SURR-$r<r=r@s rrA�tzlocal.__repr__?rCr)r~rr�r{r�)T)r?rDrErFrGr\rr rr%r)r�r�r5rHr8rArIrJrK�
__classcell__�r>s@rruru�s`����+�$���.��.�I�$B�&�P
"��H�#�0��"�"�Jrruc�D�\rSrSr/SQrSrSrSrSrSr	Sr
S	rS
rg)�_ttinfoiE)r[�delta�isdst�abbr�isstd�isgmt�	dstoffsetc�B�URHn[XS5 M gr��	__slots__�setattr)r�attrs  rr\�_ttinfo.__init__Is���N�N�D��D��%�#rc���/nURH4n[X5nUcMURU<S[U5<35 M6 URR
<SSR
U5<S3$)N�=rnrorp)r�r��appendrqr>r?�join)r�lr��values    rrA�_ttinfo.__repr__MsY�����N�N�D��D�'�E�� ����D�$�u�+�6�7�#� �>�>�2�2�D�I�I�a�L�A�Arc���[U[5(d[$URUR:H=(a� URUR:H=(a� UR
UR
:H=(ay URUR:H=(aY URUR:H=(a9 URUR:H=(a URUR:H$r)
r/r�r1r[r�r�r�r�r�r�r3s  rr5�_ttinfo.__eq__Us����%��)�)�!�!����u�|�|�+�2��
�
�e�k�k�)�2��
�
�e�k�k�)�2��	�	�U�Z�Z�'�2��
�
�e�k�k�)�	2�
�
�
�e�k�k�)�2����%�/�/�1�
	3rNc��X:X+$rr$r3s  rr8�_ttinfo.__ne__cr:rc�L�0nURHn[XS5X'M U$r)r�r��r�staterZs   r�__getstate__�_ttinfo.__getstate__fs(�����N�N�D�!�$�d�3�E�K�#��rc�T�URHnX!;dM
[XX5 M grr�r�s   r�__setstate__�_ttinfo.__setstate__ls!���N�N�D��}���E�K�0�#rr$)
r?rDrErFr�r\rAr5rHr8r�r�rKr$rrr�r�Es/��0�I�&�B�
3��H�#��1rr�c�&�\rSrSrSr/SQrSrSrg)�_tzfileirzk
Lightweight class for holding the relevant transition and time zone
information read from binary tzfiles.
)�
trans_list�trans_list_utc�	trans_idx�ttinfo_list�
ttinfo_std�
ttinfo_dst�
ttinfo_before�ttinfo_firstc	�b�URHn[XURUS55 M! gr)�attrsr��get)r�kwargsr�s   rr\�_tzfile.__init__zs%���J�J�D��D��
�
�4�� 6�7�rr$N)r?rDrErFrGr�r\rKr$rrr�r�rs���
J�E�8rr�c�^�\rSrSrSrSU4SjjrSrSrSSjrSr	S	r
S
rSSjrSr
S
rSr\S5rSrSrSrSrSrSrSrU=r$)�tzfileia,	
This is a ``tzinfo`` subclass that allows one to use the ``tzfile(5)``
format timezone files to extract current and historical zone information.

:param fileobj:
    This can be an opened file stream or a file name that the time zone
    information can be read from.

:param filename:
    This is an optional parameter specifying the source of the time zone
    information in the event that ``fileobj`` is a file object. If omitted
    and ``fileobj`` is a file stream, this parameter will be set either to
    ``fileobj``'s ``name`` attribute or to ``repr(fileobj)``.

See `Sources for Time Zone and Daylight Saving Time Data
<https://data.iana.org/time-zones/tz-link.html>`_ for more information.
Time zone files can be compiled from the `IANA Time Zone database files
<https://www.iana.org/time-zones>`_ with the `zic time zone compiler
<https://www.freebsd.org/cgi/man.cgi?query=zic&sektion=8>`_

.. note::

    Only construct a ``tzfile`` directly if you have a specific timezone
    file on disk that you want to read into a Python ``tzinfo`` object.
    If you want to get a ``tzfile`` representing a specific IANA zone,
    (e.g. ``'America/New_York'``), you should call
    :func:`dateutil.tz.gettz` with the zone identifier.


**Examples:**

Using the US Eastern time zone as an example, we can see that a ``tzfile``
provides time zone information for the standard Daylight Saving offsets:

.. testsetup:: tzfile

    from dateutil.tz import gettz
    from datetime import datetime

.. doctest:: tzfile

    >>> NYC = gettz('America/New_York')
    >>> NYC
    tzfile('/usr/share/zoneinfo/America/New_York')

    >>> print(datetime(2016, 1, 3, tzinfo=NYC))     # EST
    2016-01-03 00:00:00-05:00

    >>> print(datetime(2016, 7, 7, tzinfo=NYC))     # EDT
    2016-07-07 00:00:00-04:00


The ``tzfile`` structure contains a fully history of the time zone,
so historical dates will also have the right offsets. For example, before
the adoption of the UTC standards, New York used local solar  mean time:

.. doctest:: tzfile

   >>> print(datetime(1901, 4, 12, tzinfo=NYC))    # LMT
   1901-04-12 00:00:00-04:56

And during World War II, New York was on "Eastern War Time", which was a
state of permanent daylight saving time:

.. doctest:: tzfile

    >>> print(datetime(1944, 2, 7, tzinfo=NYC))    # EWT
    1944-02-07 00:00:00-04:00

Nc�>�[[U]5 Sn[U[5(aXl[
US5nSnO=UbX lO3[US5(aURUlO[U5UlUb@U(d[U5nUnURU5nSSS5 URW5 gg!,(df   N!=f)NF�rbTrZ)
rxr�r\r/�str�	_filename�open�hasattrrZrq�_nullcontext�_read_tzfile�_set_tzdata)r�fileobj�filename�file_opened_here�file_stream�tzobjr>s      �rr\�tzfile.__init__�s����
�f�d�$�&� ���g�s�#�#�$�N��7�D�)�G�#��
�
!�%�N�
�W�f�
%�
%�$�\�\�D�N�!�'�]�D�N���#�&�w�/���K��)�)�+�6���
���U�#����s�C�
Cc	�d�[RHn[USU-[X55 M g)z<Set the time zone data of this object from a _tzfile object �_N)r�r�r�r�)rr�r�s   rr��tzfile._set_tzdata�s'���M�M�D��D�#��*�g�e�&:�;�"rc	�6�[5nURS5R5S:wa[S5eURS5 [R
"SURS55unnnnnnU(a;[
[R
"SU-URUS-555UlO/UlU(a/[R
"SU-URU55UlO/Ul/n	[U5H8n
U	R[R
"S	URS
555 M: URU5R5nU(a#URUS-[R5 U(a)[R
"SU-URU55nU(a)[R
"SU-URU55n
/Ul[U5H�n
X�up�n[U5n[!5nUUl[$R&"S
5Ul[$R&"US9UlUUlUUUR/SU5UlXJ:�=(a WU
S
:gUlX::�=(a W
U
S
:gUlURRU5 M� URVs/sHnURUPM snUlSUlSUlSUlUR(GaAUR(dURS
=UlUlGO[US-
SS5H�n
URU
nUR6(dUR,(dUUlO)UR8(dUR,(aUUlUR6(dMxUR8(dM� O5 UR8(a"UR6(dUR8UlURHnUR,(aMUUl O URS
UlSnSnSnSn/Ul[AUR5H�un
nUR"nS
nUbHUR,(a7U(dUU-
nU(d	U(aUn[$R&"US9UlUnUU-
nUnUbUU:waUR,U:waUnUR,nUnUnUR>RURU
U-5 M� [CUR5Ul[CUR>5Ul[CUR5UlU$s snf)N��TZifzmagic not found�z>6l�z>%dlz>%dBz>lbb��z>%dbrrQ�r���)"r��read�decode�
ValueError�struct�unpack�listr�r��ranger��seek�os�SEEK_CURr�rYr�r[rWrXr�r�r��findr�r�r�r�r�r�r�r��	enumerater�)rr��out�
ttisgmtcnt�
ttisstdcnt�leapcnt�timecnt�typecnt�charcnt�ttinfo�ir�r�r��gmtoffr��abbrind�tti�idx�lastdst�
lastoffset�
lastdstoffset�lastbaseoffsetr[r��
baseoffset�
adjustments                           rr��tzfile._read_tzfile�s����i���<�<��?�!�!�#�v�-��.�/�/����R��2
�M�M�%����b�!1�2�/	
��
�
�
�
�
��!%�f�m�m�F�W�4D�4;�L�L����4K�'M�"N�C��"$�C���"�M�M�&�7�*:�*1�,�,�w�*?�A�C�M��C�M����w��A��M�M�&�-�-�����Q��@�A� ��|�|�G�$�+�+�-����L�L��1��b�k�k�2���M�M�&�:�"5�")�,�,�z�":�<�E���M�M�&�:�"5�")�,�,�z�":�<�E�����w��A�%+�Y�"�F�7�*�6�2�F��)�C��C�J�$�.�.�q�1�C�M� �*�*�6�:�C�I��C�I��G�D�I�I�f�g�$>�?�C�H�#��9�E�!�H��M�C�I�#��9�E�!�H��M�C�I��O�O�"�"�3�'� �:=���G��#�����-��G��
������� ����?�?�?��%�%�47�O�O�A�4F�F����!1��w�q�y�"�b�1�A��-�-��*�C��>�>�#�)�)�),��� �^�^��	�	�),����~�~�~�#�.�.�.��2��~�~�c�n�n�),������?�?�C��9�9�9�,/��)��+�
),����(:�C�%����
��
��������
�
�.�F�A�s��Z�Z�F��I��"��9�9�"�$*�Z�$7�	�$��$1�	�$,�$6�$6�y�$I�C�M�$-�M� �)�+�J�#�J��*�z�^�/K��	�	�W�,�+�
��i�i�G��J�'�N��N�N�!�!�#�"4�"4�Q�"7�*�"D�E�?/�B�c�m�m�,��
��s�~�~�.���"�3�#5�#5�6����
��gHs�Vc��UR(dg[U5nU(aUROURn[R"XC5nUS-
$)Nr)�_trans_listr��_trans_list_utc�bisect�bisect_right)rr�in_utcr�r�rs      r�_find_last_transition�tzfile._find_last_transition�sJ������*�2�.�	�.4�T�)�)��9I�9I�
��!�!�*�8���Q�w�rc��UbUS-[UR5:�aUR$US:aUR$URU$)Nrr)�lenr�_ttinfo_std�_ttinfo_before�
_trans_idx)rrs  r�_get_ttinfo�tzfile._get_ttinfo�sM���;�3��7�s�4�+;�+;�'<�<��#�#�#���7��&�&�&����s�#�#rc�F�URU5nURU5$r)�_resolve_ambiguous_timer )rrrs   r�_find_ttinfo�tzfile._find_ttinfo�s#���*�*�2�.������$�$rc�R�[U[R5(d[S5eURULa[	S5eURUSS9nUR
U5nU[R"URS9-nURXBS9n[U[U5S9$)a�
The ``tzfile`` implementation of :py:func:`datetime.tzinfo.fromutc`.

:param dt:
    A :py:class:`datetime.datetime` object.

:raises TypeError:
    Raised if ``dt`` is not a :py:class:`datetime.datetime` object.

:raises ValueError:
    Raised if this is called with a ``dt`` which does not have this
    ``tzinfo`` attached.

:return:
    Returns a :py:class:`datetime.datetime` object representing the
    wall time in ``self``'s time zone.
z&fromutc() requires a datetime argumentzdt.tzinfo is not selfT)rrQ)r�r�)r/rWrU�tzinfor�rr rXr[r)rrr)rrrr
�dt_outr�s      rr,�tzfile.fromutc�s���(�"�h�/�/�0�0��D�E�E�
�9�9�D� ��4�5�5��(�(��D�(�9�����s�#���h�(�(����<�<��� � �� �1���f�3�t�9�-�-rc��UcURU5n[U5nURU5nUbUS::agURUS-
5RUR-
nURUnX6U-:$)r(rFr)rr�r r[r)rrrr�r
�od�tts       rr)�tzfile.is_ambiguouss����;��,�,�R�0�C�+�2�.�	����s�#���;�#��(��
�
�
�c�A�g�
&�
-�
-��
�
�
:��
�
�
�c�
"����7�"�"rc��URU5nURU5nUbUS:XaU$[U(+=(a URX55nX$-
$)Nr)rr�rrr))rrrr��
idx_offsets     rr#�tzfile._resolve_ambiguous_time%sX���(�(��,���
�
�2����;�#��(��J��U��A�t�'8�'8��'A�B�
���rc�n�UcgUR(d[$URU5R$r)rrr$r�rs  rr�tzfile.utcoffset2s/��
�:������K�� � ��$�*�*�*rc��UcgUR(d[$URU5nUR(d[$UR$r)�_ttinfo_dstrr$r�r�)rrr
s   rr �
tzfile.dst;s@��
�:������K�����#���y�y��K��}�}�rc�b�UR(aUcgURU5R$r)rr$r�rs  rr%�
tzfile.tznameKs)�����2�:��� � ��$�)�)�)rc���[U[5(d[$URUR:H=(a9 URUR:H=(a UR
UR
:H$r)r/r�r1rr�_ttinfo_listr3s  rr5�
tzfile.__eq__Qs^���%��(�(�!�!�� � �E�$5�$5�5�8����5�#3�#3�3�8��!�!�U�%7�%7�7�	9rc��X:X+$rr$r3s  rr8�
tzfile.__ne__Zr:rc�d�URR<S[UR5<S3$�Nrnrp)r>r?rqr�r@s rrA�tzfile.__repr__]s ���>�>�2�2�D����4H�I�Irc�$�URS5$r)�
__reduce_ex__r@s rrJ�tzfile.__reduce__`s���!�!�$�'�'rc�L�URSUR4UR4$r)r>r��__dict__)r�protocols  rrB�tzfile.__reduce_ex__cs ������t�~�~� 6��
�
�F�Fr)r�r�F)r?rDrErFrGr\r�r�rr r$r,r)r#rr rr%r5rHr8rArJrBrKr�r�s@rr�r�s����E�N$�0<�^�@
�	$�%�
".�H#�: �+�� �*��*�
9��H�#�J�(�G�Grr�c�D�\rSrSrSrS	SjrSrSr\S5r	Sr
g)
�tzrangeiga�

The ``tzrange`` object is a time zone specified by a set of offsets and
abbreviations, equivalent to the way the ``TZ`` variable can be specified
in POSIX-like systems, but using Python delta objects to specify DST
start, end and offsets.

:param stdabbr:
    The abbreviation for standard time (e.g. ``'EST'``).

:param stdoffset:
    An integer or :class:`datetime.timedelta` object or equivalent
    specifying the base offset from UTC.

    If unspecified, +00:00 is used.

:param dstabbr:
    The abbreviation for DST / "Summer" time (e.g. ``'EDT'``).

    If specified, with no other DST information, DST is assumed to occur
    and the default behavior or ``dstoffset``, ``start`` and ``end`` is
    used. If unspecified and no other DST information is specified, it
    is assumed that this zone has no DST.

    If this is unspecified and other DST information is *is* specified,
    DST occurs in the zone but the time zone abbreviation is left
    unchanged.

:param dstoffset:
    A an integer or :class:`datetime.timedelta` object or equivalent
    specifying the UTC offset during DST. If unspecified and any other DST
    information is specified, it is assumed to be the STD offset +1 hour.

:param start:
    A :class:`relativedelta.relativedelta` object or equivalent specifying
    the time and time of year that daylight savings time starts. To
    specify, for example, that DST starts at 2AM on the 2nd Sunday in
    March, pass:

        ``relativedelta(hours=2, month=3, day=1, weekday=SU(+2))``

    If unspecified and any other DST information is specified, the default
    value is 2 AM on the first Sunday in April.

:param end:
    A :class:`relativedelta.relativedelta` object or equivalent
    representing the time and time of year that daylight savings time
    ends, with the same specification method as in ``start``. One note is
    that this should point to the first time in the *standard* zone, so if
    a transition occurs at 2AM in the DST zone and the clocks are set back
    1 hour to 1AM, set the ``hours`` parameter to +1.


**Examples:**

.. testsetup:: tzrange

    from dateutil.tz import tzrange, tzstr

.. doctest:: tzrange

    >>> tzstr('EST5EDT') == tzrange("EST", -18000, "EDT")
    True

    >>> from dateutil.relativedelta import *
    >>> range1 = tzrange("EST", -18000, "EDT")
    >>> range2 = tzrange("EST", -18000, "EDT", -14400,
    ...                  relativedelta(hours=+2, month=4, day=1,
    ...                                weekday=SU(+1)),
    ...                  relativedelta(hours=+1, month=10, day=31,
    ...                                weekday=SU(-1)))
    >>> tzstr('EST5EDT') == range1 == range2
    True

Nc�6�SSKJq XlX0lUR	5nUR	5nUb[R"US9Ul	O[Ul	Ub[R"US9UlO<U(a*Ub'UR[R"SS9-UlO[UlU(a2Uc/[RSSS[RS5S9Ul
OXPl
U(a2Uc/[RSS	S
[RS5S9UlOX`lURUR-
Ul[!UR5Ulg![
[4a GN\f=f![
[4a GNbf=f)Nr��
relativedeltarQr��hours�r�)rO�month�day�weekday�
�r�)�dateutilrM�	_std_abbr�	_dst_abbrrTrUrVrWrXr{rr~�SU�_start_delta�
_end_delta�_dst_base_offset_r��hasdst)r�stdabbr�	stdoffset�dstabbrr��start�ends       rr\�tzrange.__init__�st��
	+� �� ��	�!�/�/�1�I�	�!�/�/�1�I�� �'�1�1�)�D�D��#�D��� �'�1�1�)�D�D��
��.�#�/�/�(�2D�2D�2�2N�N�D��#�D���u�}� -� ;� ;���q�-�2B�2B�2�2F�!<�!H�D��!&���s�{�+�9�9����M�4D�4D�R�4H�:�J�D�O�"�O�!%�!1�!1�D�4D�4D�!D����4�,�,�-����C�>�*�	��	��
�>�*�	��	�s"�E-�F�-F�F�F�Fc��UR(dg[R"USS5nX R-nX R-nX44$)a�
For a given year, get the DST on and off transition times, expressed
always on the standard time side. For zones with no transitions, this
function returns ``None``.

:param year:
    The year whose transitions you would like to query.

:return:
    Returns a :class:`tuple` of :class:`datetime.datetime` objects,
    ``(dston, dstoff)`` for zones with an annual DST transition, or
    ``None`` for fixed offset zones.
Nr)r]rWrZr[)r�year�	base_yearrarbs     r�transitions�tzrange.transitions�sD���{�{���%�%�d�A�q�1�	��-�-�-���/�/�)���|�rc��[U[5(d[$URUR:H=(a� URUR:H=(ay UR
UR
:H=(aY URUR:H=(a9 URUR:H=(a URUR:H$r)	r/rJr1rWrXr{r~rZr[r3s  rr5�tzrange.__eq__�s����%��)�)�!�!����%�/�/�1�4����%�/�/�1�4�� � �E�$5�$5�5�4�� � �E�$5�$5�5�4��!�!�U�%7�%7�7�	4�
���5�#3�#3�3�	5rc��UR$r)r\r@s r�_dst_base_offset�tzrange._dst_base_offsets���%�%�%r)rXr\r~r[rZrWr{r])NNNNN)r?rDrErFrGr\rgr5�propertyrlrKr$rrrJrJgs8��I�T+/�)-�!%�-.�^�0	5��&��&rrJc�2�\rSrSrSrSSjrS	SjrSrSrg)
�tzstri	a>
``tzstr`` objects are time zone objects specified by a time-zone string as
it would be passed to a ``TZ`` variable on POSIX-style systems (see
the `GNU C Library: TZ Variable`_ for more details).

There is one notable exception, which is that POSIX-style time zones use an
inverted offset format, so normally ``GMT+3`` would be parsed as an offset
3 hours *behind* GMT. The ``tzstr`` time zone object will parse this as an
offset 3 hours *ahead* of GMT. If you would like to maintain the POSIX
behavior, pass a ``True`` value to ``posix_offset``.

The :class:`tzrange` object provides the same functionality, but is
specified using :class:`relativedelta.relativedelta` objects. rather than
strings.

:param s:
    A time zone string in ``TZ`` variable format. This can be a
    :class:`bytes` (2.x: :class:`str`), :class:`str` (2.x:
    :class:`unicode`) or a stream emitting unicode characters
    (e.g. :class:`StringIO`).

:param posix_offset:
    Optional. If set to ``True``, interpret strings such as ``GMT+3`` or
    ``UTC+3`` as being 3 hours *behind* UTC rather than ahead, per the
    POSIX standard.

.. caution::

    Prior to version 2.7.0, this function also supported time zones
    in the format:

        * ``EST5EDT,4,0,6,7200,10,0,26,7200,3600``
        * ``EST5EDT,4,1,0,7200,10,-1,0,7200,3600``

    This format is non-standard and has been deprecated; this function
    will raise a :class:`DeprecatedTZFormatWarning` until
    support is removed in a future version.

.. _`GNU C Library: TZ Variable`:
    https://www.gnu.org/software/libc/manual/html_node/TZ-Variable.html
c
�p�SSKJq Xl[R	U5nUbUR
(a[
S5eURS;aU(dU=RS-sl[RXRURURURSSS9 UR(dSUl
SUlOPURUR 5Ul
UR(aURUR"SS	9Ul[%UR5Ulg)
Nr)�_parserzunknown string format�r�r#r�F)rarbr)�isend)�dateutil.parserrr�parser�_s�_parsetz�any_unused_tokensr�r^r_rJr\r`r�rZr[�_deltararbr�r])r�s�posix_offset�ress    rr\�tzstr.__init__3s���5����o�o�a� ���;�#�/�/��4�5�5��;�;�.�(���M�M�R��M�
	����{�{�C�M�M����c�m�m�$�%�	�	1��{�{� $�D��"�D�O� $���C�I�I� 6�D��� � �"&�+�+�c�g�g�Q�+�"?����4�,�,�-��rc�.�SSKJn 0nURb�URUS'URbEURURUR5US'URS:�aSUS'O`SUS'OZUR
(aUR
US'O9URbURUS'OURbURUS	'U(dDU(dS
US'SUS'URS5US'OSUS'SUS'URS5US'URbURUS
'OSUS
'U(a@URUR-
nUS
==URURS---ss'UR"S0UD6$)NrrLrQrSrrRrU�yearday�	nlyeardayr�rTr�rRi i�Qr$)rVrMrQrS�weekrR�yday�jydayrYryr~r{rR�days)r�xrtrMr�r�s      rrz�tzstr._deltaSsw��*����7�7���g�g�F�7�O��y�y�$�$1�$9�$9�!�)�)�Q�V�V�$L��y�!��6�6�A�:�$%�F�5�M�$&�F�5�M���� !����u�
��
�V�V�
� !���F�9��
�W�W�
 �"#�'�'�F�;����"#��w�� !��u�
�$1�$4�$4�R�$8��y�!�"$��w�� "��u�
�$1�$4�$4�R�$8��y�!��6�6�� !���F�9��!%�F�9����$�$�t�'7�'7�7�E��9��������e�1C�!C�C���*�*�4�V�4�4rc�d�URR<S[UR5<S3$r?�r>r?rqrwr@s rrA�tzstr.__repr__|����>�>�2�2�D����M�B�Br)r[rwrZr]NrH)r)	r?rDrErFrGr\rzrArKr$rrrprp	s��(�R.�@'5�RCrrpc� �\rSrSrSSjrSrg)�_tzicalvtzcompi�Nc���[R"US9Ul[R"US9UlURUR-
UlX0lX@lXPlgrP)rWrX�tzoffsetfrom�
tzoffsetto�tzoffsetdiffr�r%�rrule)rr�r�r�r%r�s      rr\�_tzicalvtzcomp.__init__�sM��$�.�.�|�D���"�,�,�Z�@��� �O�O�d�.?�.?�?����
����
r)r�r�r%r�r�r�)NN)r?rDrErFr\rKr$rrr�r��s
��$(�rr�c�t^�\rSrSr/4U4SjjrSrSrSrSr\	S5r
Sr\Rr
S	rU=r$)
�
_tzicalvtzi�c�>�[[U]5 XlX l/Ul/Ul[R"5Ul	gr)
rxr�r\�_tzid�_comps�
_cachedate�
_cachecomp�_thread�
allocate_lock�_cache_lock)r�tzid�compsr>s   �rr\�_tzicalvtz.__init__�s9���
�j�$�(�*��
���������"�0�0�2��rc��[UR5S:XaURS$URSS9nUR URUR
R
XRU545sSSS5 $!,(df   O=f![a Of=fSnSnURH/nURXA5nU(dMU(aX%:dM+UnUnM1 U(d-URHnUR(aMUn O WSnUR UR
RSXRU545 URRSU5 [UR
5S:�a4UR
R5 URR5 SSS5 U$!,(df   U$=f)Nrr�r(rT)
rr��replacer�r�r��indexr�r��_find_compdtr��insert�pop)rr�
lastcompdt�lastcomp�comp�compdts      r�
_find_comp�_tzicalvtz._find_comp�s����t�{�{��q� ��;�;�q�>�!�
�Z�Z�t�Z�
$��	��!�!����t���'<�'<����B��(�(*�+�"�!�!���	��	���
����K�K�D��&�&�t�0�F��v�z�Z�-@�#�
��� ��
�����z�z�z�#�H��$�
 ��7��
�
�
��O�O�"�"�1�r�:�:�b�>�&:�;��O�O�"�"�1�h�/��4�?�?�#�b�(����#�#�%����#�#�%�
����
���s<�B�8B�=	B�
B�B�B�
B%�$B%�+BG�
Gc��UR[:a$URU5(aX!R-nURR	USS9nU$)NT)�inc)r�rr�r��before)rr�rr�s    rr��_tzicalvtz._find_compdt�sH�����t�#��
�
�2����#�#�#�B����"�"�2�4�"�0���
rc�@�UcgURU5R$r)r�r�rs  rr�_tzicalvtz.utcoffset�s��
�:�����r�"�-�-�-rc�j�URU5nUR(aUR$[$r)r�r�r�r)rrr�s   rr �_tzicalvtz.dst�s(�����r�"���:�:��$�$�$��Krc�8�URU5R$r)r�r%rs  rr%�_tzicalvtz.tzname�s�����r�"�)�)�)rc�2�S[UR5-$)Nz<tzicalvtz %s>)rqr�r@s rrA�_tzicalvtz.__repr__�s���$�t�z�z�"2�2�2r)r�r�r�r�r�)r?rDrErFr\r�r�rr rr%rArIrJrKr�r�s@rr�r��sF���#%�3�+�Z�.���*��*�3��"�"�Jrr�c�@�\rSrSrSrSrSrSSjrSrSr	S	r
S
rg)�tzicali�a?
This object is designed to parse an iCalendar-style ``VTIMEZONE`` structure
as set out in `RFC 5545`_ Section 4.6.5 into one or more `tzinfo` objects.

:param `fileobj`:
    A file or stream in iCalendar format, which should be UTF-8 encoded
    with CRLF endings.

.. _`RFC 5545`: https://tools.ietf.org/html/rfc5545
c�0�SSKJq [U[5(aXl[US5nO&[
US[U55Ul[U5n0Ul	UnURUR55 SSS5 g!,(df   g=f)Nr)r��rrZ)rVr�r/r�rwr�r�rqr��_vtz�
_parse_rfcr�)rr��fobjs   rr\�tzical.__init__�si��"��g�s�#�#��G��7�C�(�G��g�v�t�G�}�=�D�G�"�7�+�G���	�
���O�O�D�I�I�K�(��W�W�s� B�
Bc�H�[URR55$)z/
Retrieves the available time zones as a list.
)r�r��keysr@s rr��tzical.keys�s���D�I�I�N�N�$�%�%rNc�
�Ucf[UR5S:Xa[S5e[UR5S:�a[S5e[[	UR55nURRU5$)a0
Retrieve a :py:class:`datetime.tzinfo` object by its ``tzid``.

:param tzid:
    If there is exactly one time zone available, omitting ``tzid``
    or passing :py:const:`None` value returns it. Otherwise a valid
    key (which can be retrieved from :func:`keys`) is required.

:raises ValueError:
    Raised if ``tzid`` is not specified but there are either more
    or fewer than 1 zone defined.

:returns:
    Returns either a :py:class:`datetime.tzinfo` object representing
    the relevant time zone or :py:const:`None` if the ``tzid`` was
    not found.
rzno timezones definedrz more than one timezone available)rr�r��next�iterr�)rr�s  rr��
tzical.getsf��$�<��4�9�9�~��"� �!7�8�8��T�Y�Y��!�#� �!C�D�D���T�Y�Y��(�D��y�y�}�}�T�"�"rc��UR5nU(d[S5eUSS;aSUSS:HnUSSnOSn[U5S:Xa&[USS5S	-[USS5S
--U-$[U5S:Xa5[USS5S	-[USS5S
--[USS5-U-$[SU-5e)
Nzempty offsetr)�+�-)r�rr�rr�rPi�<r�zinvalid offset: )�stripr�rrr)rr{�signals   r�
_parse_offset�tzical._parse_offsets���
�G�G�I����^�,�,��Q�4�:���a��d�c�k�*�F��!�"��A��F��q�6�Q�;���"�1��J��%��A�a�b�E�
�R��7�6�A�A�
��V�q�[���"�1��J��%��A�a��F��b�(8�8�3�q���u�:�E��O�O��/�!�3�4�4rc���UR5nU(d[S5eSnU[U5:aVX#R5nU(dX#	O)US:�aUSS:XaX#S-
==USS-
ss'X#	OUS-
nU[U5:aMVSn/nSnSnUGH�nU(dM
UR	SS5up�U	R	S5nU(d[S5eUSR5n	USSnU(GaZU	S	:Xa#U
S
;aO[SU
-5eU
nSnSn
Sn/nSnM�U	S:Xa�U
S
:XaUU(a[SU-5eU(d[S5eU(d[S5e[
XV5URU'SnM�X�:Xa�W(d[S5eW
c[S5eWc[S5eSnW(a%[RSRU5SSSS9n[X�US:HWU5nURU5 SnGMv[SU
-5eU(a�U	S:Xa5UHnUS:wdMSU-n[U5e WRU5 SnGM�U	S;aWRU5 GM�U	S:Xa2U(a[SU	<SUS<S35eURU
5n
GMU	S:Xa,U(a[S US-5eURU
5nGMJU	S!:XaU(a[S"US-5eU
nGMmU	S#:XaGMv[S$U	-5eU	S%:XaU(a[S&US-5eU
nGM�U	S';aGM�[S$U	-5eU	S	:XdGM�U
S
:XdGM�Sn/nSnGM� g)(Nzempty stringr� rF�:�;zempty property name�BEGIN)�STANDARD�DAYLIGHTzunknown component: �END�	VTIMEZONEzcomponent not closed: zmandatory TZID not foundz at least one component is neededzmandatory DTSTART not foundz mandatory TZOFFSETFROM not found�
T)�
compatible�ignoretz�cacher�zinvalid component end: �DTSTARTzVALUE=DATE-TIMEz(Unsupported DTSTART param in VTIMEZONE: )�RRULE�RDATE�EXRULE�EXDATE�TZOFFSETFROMzunsupported z parm: �
TZOFFSETTOzunsupported TZOFFSETTO parm: �TZNAMEzunsupported TZNAME parm: �COMMENTzunsupported property: �TZIDzunsupported TZID parm: )�TZURLz
LAST-MODIFIEDr�)�
splitlinesr�r�rstrip�split�upperr�r�r��rrulestrr�r�r�r�)rr{�linesr�liner�r��invtz�comptyperZr��parms�founddtstartr�r��
rrulelinesr%�rrr��parm�msgs                     rr��tzical._parse_rfc.s����������^�,�,�
���#�e�*�n��8�?�?�$�D���H��Q��4��7�c�>���c�
�d�1�2�h�&�
��H��Q����#�e�*�n����������D����*�*�S�!�,�K�D��J�J�s�O�E�� �!6�7�7���8�>�>�#�D��!�"�I�E���7�?�� 8�8��(�)>�u�)D�E�E�$�H�#(�L�#'�L�!%�J�!#�J�!�F��U�]���+�#�",�-E�h�-N�"O�O�#�",�-G�"H�H�$�",� B�#D�D�+5�T�*A��	�	�$�� %���*�+�",�-J�"K�K�'�/�",� B�#D�D�%�-�",� B�#D�D�"��%�!&����	�	�*�0E�;?�9=�6:�"0�"<�B� .�l�/7�:�/E�.4�b� :�����T�*�#'��(�)B�5�)H�I�I���y�(�%*�D�#�'8�8�(5�7;�(<��&0��o� 5�	%*�
#�)�)�$�/�'+���!G�G�"�)�)�$�/���/� �",�>B�E�!�H� M�#O�O�'+�'9�'9�%�'@����-� �",� ?��a�� H�#J�J�%)�%7�%7��%>�
���)� �",� ;�E�!�H� D�#F�F�!&����*��(�)A�$�)F�G�G��v�~� �",� 9�%��(� B�#D�D�$���!F�F��(�)A�$�)F�G�G����U�k�%9�������Mrc�d�URR<S[UR5<S3$r?r�r@s rrA�tzical.__repr__�r�r)rwr�r)r?rDrErFrGr\r�r�r�r�rArKr$rrr�r��s(��	�)�"&�#�65� {�zCrr��win32z/etc/localtimer�)z/usr/share/zoneinfoz/usr/lib/zoneinfoz/usr/share/lib/zoneinfoz
/etc/zoneinfoc�f^�[4m[b
T[4-
m"U4SjS[5nU"5$)Nc�P>�\rSrSrSrSrS
U4SjjrSrSr\	S
Sj5r
S	rg)�__get_gettz.<locals>.GettzFunci�a�
Retrieve a time zone object from a string representation

This function is intended to retrieve the :py:class:`tzinfo` subclass
that best represents the time zone that would be used if a POSIX
`TZ variable`_ were set to the same value.

If no argument or an empty string is passed to ``gettz``, local time
is returned:

.. code-block:: python3

    >>> gettz()
    tzfile('/etc/localtime')

This function is also the preferred way to map IANA tz database keys
to :class:`tzfile` objects:

.. code-block:: python3

    >>> gettz('Pacific/Kiritimati')
    tzfile('/usr/share/zoneinfo/Pacific/Kiritimati')

On Windows, the standard is extended to include the Windows-specific
zone names provided by the operating system:

.. code-block:: python3

    >>> gettz('Egypt Standard Time')
    tzwin('Egypt Standard Time')

Passing a GNU ``TZ`` style string time zone specification returns a
:class:`tzstr` object:

.. code-block:: python3

    >>> gettz('AEST-10AEDT-11,M10.1.0/2,M4.1.0/3')
    tzstr('AEST-10AEDT-11,M10.1.0/2,M4.1.0/3')

:param name:
    A time zone name (IANA, or, on Windows, Windows keys), location of
    a ``tzfile(5)`` zoneinfo file or ``TZ`` variable style time zone
    specifier. An empty string, no argument or ``None`` is interpreted
    as local time.

:return:
    Returns an instance of one of ``dateutil``'s :py:class:`tzinfo`
    subclasses.

.. versionchanged:: 2.7.0

    After version 2.7.0, any two calls to ``gettz`` using the same
    input strings will return the same object:

    .. code-block:: python3

        >>> tz.gettz('America/Chicago') is tz.gettz('America/Chicago')
        True

    In addition to improving performance, this ensures that
    `"same zone" semantics`_ are used for datetimes in the same zone.


.. _`TZ variable`:
    https://www.gnu.org/software/libc/manual/html_node/TZ-Variable.html

.. _`"same zone" semantics`:
    https://blog.ganssle.io/articles/2018/02/aware-datetime-arithmetic.html
c��[R"5UlSUl[	5Ul[R"5Ulg)Nr�)	�weakref�WeakValueDictionary�_GettzFunc__instances�_GettzFunc__strong_cache_sizer�_GettzFunc__strong_cacher�r�r�r@s rr\�'__get_gettz.<locals>.GettzFunc.__init__s6��&�:�:�<�D��'(�D�$�"-�-�D��&�4�4�6�D�rNc��>�UR URRUS5nUc@URUS9nUb#[	UT5(dUbX RU'OUsSSS5 $UR
R
X5UR
U'[UR
5UR:�aUR
RSS9 SSS5 U$!,(df   W$=f)N)rZF��last)
r�rr��nocacher/rr�rr�popitem)rrZ�rv�tzlocal_classess   �r�__call__�'__get_gettz.<locals>.GettzFunc.__call__s�����!�!��%�%�)�)�$��5���:����4��0�B� �L�)�"�o�>�>�!�z�24�(�(��.� "�#"�!�&-1�,?�,?�,C�,C�D�,M��#�#�D�)��t�*�*�+�d�.F�.F�F��'�'�/�/�U�/�;�-"�0�I�1"�!�0�I�s�AC�.A$C�
C+c��UR Xl[UR5U:�a4URR	SS9 [UR5U:�aM4SSS5 g!,(df   g=f)NFr)r�rrrr
)r�sizes  r�set_cache_size�-__get_gettz.<locals>.GettzFunc.set_cache_size's\���!�!�+/�(��$�-�-�.��5��'�'�/�/�U�/�;��$�-�-�.��5�"�!�!�s�AA*�*
A8c��UR [R"5UlURR5 SSS5 g!,(df   g=fr)r�rrrr�clearr@s r�cache_clear�*__get_gettz.<locals>.GettzFunc.cache_clear-s:���!�!�#*�#>�#>�#@�� ��#�#�)�)�+�"�!�!�s�5A�
Ac��SnU(d[RSnUbUS;a�[H�n[RRU5(dVUn[HHn[RRXC5n[RRU5(dMH O M}[RRU5(dM�[U5n U$ [5nU$URS5(aUSSn[RRU5(a6[RRU5(a
[U5nU$SnU$[H�n[RRX@5n[RRU5(d8UR%SS5n[RRU5(dM~[U5n U$ Sn[&b['U5nU(dJUHnUS	;dM[-U5n U$ US
;a[.nU$U[0R2;a
[5nU$![a GNPf=f![[[4a GM^f=f![a)n[!U["5(aSn[U5UeeSnAff=f![[[4a GMtf=f![([*4a SnN�f=f![a N�f=f)zA non-cached version of gettzN�TZ)�r�r�rz'gettz argument should be str, not bytesr�r��
0123456789rs)r��environ�KeyError�TZFILES�path�isabs�TZPATHSr��isfiler��IOError�OSErrorr�ru�
startswithrUr/�bytesr�r
�WindowsError�UnicodeEncodeErrorrpr#ryr%)rZ�tz�filepathr�r�e�new_msg�cs        rr	�&__get_gettz.<locals>.GettzFunc.nocache2s����B����:�:�d�+�D��|�t�y�0� '�H��7�7�=�=��2�2�#+��$+�D�')�w�w�|�|�D�'C�H�!�w�w�~�~�h�7�7� %�%,�
%��w�w�~�~�h�/�/�!�!'��!1�B�!�t�I�M!(� !��B�l�I�i����s�+�+�#�A�B�x���7�7�=�=��&�&��w�w�~�~�d�+�+�#�D�\��R�I�O"��N�I�K!(��#%�7�7�<�<��#;��!�w�w�~�~�h�7�7�'/�'7�'7��S�'A�H�#%�7�7�>�>�(�#;�#;� (�!�!'��!1�B�!�:�I�K!(�"�� �,�*�%*�4�[��
 "�%)��
$%��#4�%-�-2�4�[��%*��I�!&*�$(�>�#9�),�B��I�&*�T�[�[�%8�)0��B��I��S ����� !(��*�=�!� �!��!��!�$��.�.�"K��'��0�a�7�����*!(��*�=�!� �!��%1�2D�#E�*�%)��*��,6�%-�(,�%-�sq�I!�I2�/J�)K�K"�#K:�!
I/�.I/�2J�J�
K�$J=�=K�K�K�"K7�6K7�:
L�L)�__instances�__strong_cache�__strong_cache_sizer�r)r?rDrErFrGr\r
rr�staticmethodr	rK)rs�r�	GettzFuncr��s4���D	�J	7�	�6	<�	,�

�O	�
�O	rr2)rurrI)r2rs @r�__get_gettzr3�s5����j�O����J�=�(��C�F�C�J�;�rc��Uc$URc[S5eURnURSS9nURUS9R[5RU5nURSS9nX:H$)a�
Given a datetime and a time zone, determine whether or not a given datetime
would fall in a gap.

:param dt:
    A :class:`datetime.datetime` (whose time zone will be ignored if ``tz``
    is provided.)

:param tz:
    A :class:`datetime.tzinfo` with support for the ``fold`` attribute. If
    ``None`` or not provided, the datetime's own time zone will be used.

:return:
    Returns a boolean value whether or not the "wall time" exists in
    ``tz``.

.. versionadded:: 2.7.0
N�,Datetime is naive and no time zone provided.r�)r(r�r��
astimezoner#)rr(�dt_rts   r�datetime_existsr8�sx��&
�z�
�9�9���K�L�L�
�Y�Y��	���4��	 �B�
�J�J�b�J�!�,�,�S�1�<�<�R�@�E��M�M��M�&�E�
�;�rc��Uc$URc[S5eURn[USS5nUbURU5$URUS9n[
USS9n[
USS9nUR5UR5:HnUR5UR5:HnU=(a U(+$![a N�f=f)a$
Given a datetime and a time zone, determine whether or not a given datetime
is ambiguous (i.e if there are two times differentiated only by their DST
status).

:param dt:
    A :class:`datetime.datetime` (whose time zone will be ignored if ``tz``
    is provided.)

:param tz:
    A :class:`datetime.tzinfo` with support for the ``fold`` attribute. If
    ``None`` or not provided, the datetime's own time zone will be used.

:return:
    Returns a boolean value whether or not the "wall time" is ambiguous in
    ``tz``.

.. versionadded:: 2.6.0
Nr5r)r�rr'r)	r(r�r�r)�	Exceptionr�rrr )rr(�is_ambiguous_fn�wall_0�wall_1�same_offset�same_dsts       r�datetime_ambiguousr@�s���(
�z�
�9�9���K�L�L�
�Y�Y���b�.�$�7�O��"�	��?�?�2�&�&�
���2��	�B�
�B�Q�
�F�
�B�Q�
�F��"�"�$��(8�(8�(:�:�K��z�z�|�v�z�z�|�+�H��(��)�)���	��	�s�B?�?
C�Cc���URba[U5(dQU[R"SS9-R	5nU[R"SS9-
R	5nXU-
-
nU$)a�
Given a datetime that may be imaginary, return an existing datetime.

This function assumes that an imaginary datetime represents what the
wall time would be in a zone had the offset transition not occurred, so
it will always fall forward by the transition's change in offset.

.. doctest::

    >>> from dateutil import tz
    >>> from datetime import datetime
    >>> NYC = tz.gettz('America/New_York')
    >>> print(tz.resolve_imaginary(datetime(2017, 3, 12, 2, 30, tzinfo=NYC)))
    2017-03-12 03:30:00-04:00

    >>> KIR = tz.gettz('Pacific/Kiritimati')
    >>> print(tz.resolve_imaginary(datetime(1995, 1, 1, 12, 30, tzinfo=KIR)))
    1995-01-02 12:30:00+14:00

As a note, :func:`datetime.astimezone` is guaranteed to produce a valid,
existing datetime, so a round-trip to and from UTC is sufficient to get
an extant datetime, however, this generally "falls back" to an earlier time
rather than falling forward to the STD side (though no guarantees are made
about this behavior).

:param dt:
    A :class:`datetime.datetime` which may or may not exist.

:return:
    Returns an existing :class:`datetime.datetime`. If ``dt`` was not
    imaginary, the datetime returned is guaranteed to be the same object
    passed to the function.

.. versionadded:: 2.7.0
r�rN)r(r8rWrXr)r�curr_offset�
old_offsets   r�resolve_imaginaryrD�sg��H
�y�y��_�R�%8�%8��H�.�.�R�8�8�C�C�E���8�-�-�B�7�7�B�B�D�
�
�J�&�&��
�Irc�J�URSS9[-
R5$)z}
Convert a :class:`datetime.datetime` object to an epoch timestamp in
seconds since January 1, 1970, ignoring the time zone.
Nr�)r��EPOCHrT)rs rr�r�	s#��

�J�J�d�J�#�e�+�:�:�<�<r)�r�c��U$rr$)�
second_offsets rrYrYs���rc� �UnSUS-S--nU$)Nr��r$)rIrC�calculated_offsets   rrYrYs$��
#�
��=�2�#5�"�"<�=�� � r)�nullcontextc�*�\rSrSrSrSrSrSrSrg)r�i#zR
Class for wrapping contexts so that they are passed through in a
with statement.
c��Xlgr��context)rrQs  rr\�_nullcontext.__init__(s��"�Lrc��UR$rrPr@s r�	__enter__�_nullcontext.__enter__+s���<�<�rc��grr$)�argsr�s  r�__exit__�_nullcontext.__exit__.s��rrPN)	r?rDrErFrGr\rTrXrKr$rrr�r�#s��	�	#�	 �	rr�r)<rGrWr�ry�sysr�rr�collectionsrr��_commonrrrrr	�
_factoriesr
rr�winr
r�ImportError�warningsrrXrrF�	toordinal�EPOCHORDINALr(rr#r0rurIr�r�r�rJrpr�r�r��platformrr r3�gettzr8r@rDr��version_inforY�
contextlibrMr�r$rr�<module>rgs�����
��
�	�
��#��/�(�-�6�%��&�
����!������$��1�a��+����� ��Q#�H�O�O�|�Q#�n�g��A#�x���*:�A#�H|#�g�|#�~*1�f�*1�Z
8�f�
8�eG�W�eG�P_&�k�_&�DtC�G�}�tC�n�V��S#��S#�lKC�V�KC�\�<�<�7����-�G� �G�
�G��G�J�Z	�
����D+*�\+�\=����v���!��6��I8����E�J���J8�
��v��
�s$�E<�5F
�<
F
�	F
�
F!� F!

Filemanager

Name Type Size Permission Actions
__init__.cpython-313.pyc File 731 B 0644
_common.cpython-313.pyc File 12.99 KB 0644
_factories.cpython-313.pyc File 4.58 KB 0644
tz.cpython-313.pyc File 64.01 KB 0644
win.cpython-313.pyc File 16.9 KB 0644
Filemanager