tj`dZddlZddlZddlZddlZddlZddlZddlZddlZddl m Z ddl Z ddl m Z ddl mZddlmZdd lmZdd lmZmZmZmZmZdd lmZmZmZdd lmZ dd lmZm Z ddlm"Z"ejFdZ$ejdddddZ%e jLeGddejNZ(e(Z)e jLeGddejNZ*GddeZ+GddeZ,e jLeGdde,Z-Gdde.Z/GddeZ0Gdde.Z1d d!gZ2d"Z3e3Z4[3Gd#d$e5Z6d%Z7d&Z8d'Z9d4d(Z:d4d)Z;d*Z>> 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 ctSNZEROselfdts Y/var/www/html/python-recuperauto-other/env/lib/python3.12/site-packages/dateutil/tz/tz.py utcoffsetztzutc.utcoffsetR ctSrrrs rdstz tzutc.dstUr!r"cy)NUTCrs rtznamez tzutc.tznameXsr"cy)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 Fr'rs r is_ambiguousztzutc.is_ambiguous\sr"c|S)z Fast track version of fromutc() returns the original ``dt`` object for any valid :py:class:`datetime.datetime` object. r'rs rfromutcz tzutc.fromutcls  r"ct|ttfstSt|txs%t|txr|jt k(Sr) isinstancertzoffsetNotImplemented_offsetrrothers r__eq__z tzutc.__eq__tsE%%!23! !5%(HE8,F$1F Ir"Nc||k( Srr'r3s r__ne__z tzutc.__ne__}EM""r"c4d|jjzSNz%s() __class____name__rs r__repr__ztzutc.__repr__////r")r= __module__ __qualname____doc__r r$r r(r+r r-r5__hash__r7r?object __reduce__r'r"rrr1sb> IH#0""Jr"rcveZdZdZdZdZdZedZe dZ dZ dZ d Z d Zd Zej"Zy ) r0a1 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||_ |j}t j t ||_y#ttf$rY6wxYwNseconds)_name total_seconds TypeErrorAttributeErrordatetime timedelta_get_supported_offsetr2)rnameoffsets r__init__ztzoffset.__init__sO  ))+F ))2G2OP >*   s>AAc|jSrr2rs rr ztzoffset.utcoffsets ||r"ctSrrrs rr$z tzoffset.dstr!r"c|jSr)rLrs rr(ztzoffset.tznames zzr"c ||jzSrrWrs rr-ztzoffset.fromutcsDLL  r"cy)a4 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+ztzoffset.is_ambiguoussr"c`t|tstS|j|jk(Sr)r/r0r1r2r3s rr5ztzoffset.__eq__s%%*! !||u}},,r"Nc||k( Srr'r3s rr7ztzoffset.__ne__r8r"c|jjdt|jdt |j j dS)N(z, ))r<r=reprrLintr2rMr>s rr?ztzoffset.__repr__s<#~~66#DJJ/"4<<#=#=#?@B Br")r=rArBrCrUr r$r r(r r-r+r5rDr7r?rErFr'r"rr0r0sh Q!! - H#B ""Jr"r0ceZdZdZfdZdZdZedZdZ dZ d dZ d Z d Z d Zd Zej"ZxZS)tzlocalzR A :class:`tzinfo` subclass built around the ``time`` timezone functions. ctt| tjt j |_t jr+tjt j |_ n|j|_ |j|jz |_ t|j|_ tt j|_yrI)superrdrUrPrQtimetimezone _std_offsetdaylightaltzone _dst_offset _dst_savedbool_hasdsttupler(_tznames)rr<s rrUztzlocal.__init__s gt%'#--t}}nE =='114<<-HD #//D **T-=-==DOO, dkk* r"cr| |jry|j|r |jS|jSr)ro_isdstrlrirs rr ztzlocal.utcoffsets3 :$,, ;;r?## ### #r"c| |jry|j|r|j|jz StSr)rorsrlrirrs rr$z tzlocal.dsts7 :$,, ;;r?##d&6&66 6Kr"c>|j|j|Sr)rqrsrs rr(ztzlocal.tznames}}T[[_--r"cp|j|}| xr!||j||jz k7S)r*) _naive_is_dstrm)rr naive_dsts rr+ztzlocal.is_ambiguoussA&&r*  Hd00doo1EFF Ir"cxt|}tj|tjzjSr)_datetime_to_timestamprg localtimerhtm_isdst)rr timestamps rrwztzlocal._naive_is_dst s**2. ~~i$--78AAAr"c|jsy|j|}t|dd}|j|r||j | Sy|S)NFfoldT)rorwgetattrr+_fold)rr fold_naivedstvalrs rrsztzlocal._isdsts[2||##B'r64(   R ::b>)) r"ct|tr4|j|jk(xr|j|jk(St|tr5|j xr&|j ddvxr|jtk(St|trF|j xr7|j d|jk(xr|j|jk(StS)Nr>GMTr&) r/rdrirlrrorqrr0rLr2r1r3s rr5ztzlocal.__eq__6s eW %$$(9(99:$$(9(99 ; u % $-MM!$6-$$, .x ( $6MM!$ 36$$ 5 7" !r"Nc||k( Srr'r3s rr7ztzlocal.__ne__Gr8r"c4d|jjzSr:r;r>s rr?ztzlocal.__repr__Jr@r")T)r=rArBrCrUr r$r r(r+rwrsr5rDr7r?rErF __classcell__r<s@rrdrds` +$..I$B&P "H#0""Jr"rdc:eZdZdZ ddZdZdZedZy)tzrangea[ 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*ddlma||_||_ |j } |j }|tj||_ n t|_ |tj||_ n8|r+|)|jtjdz|_ n t|_ |r4|2tjdddtjd|_ n||_ |r4|2tjdd d tjd |_n||_|j|jz |_t!|j|_y#t t f$rYUwxYw#t t f$rYZwxYw) Nr relativedeltarJrhoursr)rmonthdayweekday )dateutilr _std_abbr _dst_abbrrMrNrOrPrQrirrlSU _start_delta _end_delta_dst_base_offset_rnhasdst)rstdabbr stdoffsetdstabbr dstoffsetstartends rrUztzrange.__init__s| +   !//1I !//1I  '11)DD #D   '11)DD  .#//(2D2D22NND #D  u} - ; ;q-2B2B22F!<!HD !&D  s{+99M4D4DR4H:JDO"DO!%!1!1D4D4D!D4,,- C>*    >*   s"E)E?)E<;E<?FFc|jsytj|dd}||jz}||jz}||fS)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)rrPrr)ryear base_yearrrs r transitionsztzrange.transitionssJ{{%%dAq1 D---$//)s|r"cnt|tstS|j|jk(xr|j|jk(xrj|j |j k(xrO|j |j k(xr4|j|jk(xr|j|jk(Sr) r/rr1rrrirlrrr3s rr5ztzrange.__eq__s%)! !%//14%//14  E$5$554  E$5$554!!U%7%77 4 5#3#33  5r"c|jSr)rr>s r_dst_base_offsetztzrange._dst_base_offsets%%%r")NNNNN) r=rArBrCrUrr5propertyrr'r"rrrPs8IT+/)-!%-.^0 5&&r"rc&eZdZdZddZddZdZy)tzstra ``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 Rddlma||_tj |}| |j r t d|jdvr|s|xjdzc_tj||j|j|j|jdd|jsd|_ d|_nN|j|j |_ |jr"|j|j"d |_t%|j|_y) Nr)_parserzunknown string formatrr&rF)rrr)isend)dateutil.parserrparser_s_parsetzany_unused_tokens ValueErrorrrrrUrrrr_deltarrrnr)rs posix_offsetress rrUztzstr.__init__s5ooa  ;#//45 5 ;;. ( MMR M s{{CMMcmm$%  1{{ $D "DO $ CII 6D   "&++cggQ+"?4,,- r"cddlm}i}|j{|j|d<|jD|j|j|j|d<|jdkDrd|d<nYd|d<nS|j rG|j |d<n7|j |j |d<n|j|j|d <|s?|sd |d<d|d<|jd|d<nd |d<d|d<|jd |d<|j|j|d <nd|d <|r@|j|jz }|d xx|j|jdzzzcc<|jdi|S)Nrrrrrrryearday nlyeardayrrrrKi iQr')rrrrweekrydayjydayrrgrlrirKdays)rxrrkwargsdeltas rrz tzstr._delta=sx* 77 ggF7Oyy$$1$9$9!))QVV$Ly!66A:$%F5M$&F5M !u VV  !F9  WW "#''F; "#w !u $1$4$4R$8y!"$w "u $1$4$4R$8y! 66  !F9 !%F9  $$t'7'77E 9 e1C!C C *}**4V44r"c`|jjdt|jdSNr_r`r<r=rarr>s rr?ztzstr.__repr__f>>22DMBBr"N)F)r)r=rArBrCrUrr?r'r"rrrs(R.@'5RCr"rceZdZ ddZy)_tzicalvtzcompNctj||_tj||_|j|jz |_||_||_||_yrI)rPrQ tzoffsetfrom tzoffsetto tzoffsetdiffisdstr(rrule)rrrrr(rs rrUz_tzicalvtzcomp.__init__ksS$..|D",,Z@ OOd.?.??   r")NN)r=rArBrUr'r"rrrjs $(r"rcheZdZgffd ZdZdZdZdZedZ dZ e jZ xZ S) _tzicalvtzctt| ||_||_g|_g|_tj|_ yr) rfrrU_tzid_comps _cachedate _cachecompr allocate_lock _cache_lock)rtzidcompsr<s rrUz_tzicalvtz.__init__vs= j$(*  "002r"czt|jdk(r|jdS|jd} |j5|j|j j ||j|fcdddS#1swYnxYwn#t$rYnwxYwd}d}|jD]#}|j||}|s|r||ks |}|}%|s&|jD]}|jr|}nd}|j5|j jd||j|f|jjd|t|j dkDr4|j j|jjddd|S#1swY|SxYw)Nrrtzinfor) lenrreplacerrrindexrr _find_compdtrinsertpop)rr lastcompdtlastcompcompcompdts r _find_compz_tzicalvtz._find_comps t{{ q ;;q> ! ZZtZ $ !! +t'<'<B((*+ + + + +    KK D&&tR0FzZ&-@#      #zz#H #  7    & OO " "1r4::b>&: ; OO " "1h /4??#b(##%##%  & &s6 B9B  B BB B#"B#BF00F:c|jtkr |j|r||jz}|jj |d}|S)NT)inc)rrrrbefore)rrrrs rrz_tzicalvtz._find_compdtsH   t # 2 $## #B""24"0 r"c>|y|j|jSr)rrrs rr z_tzicalvtz.utcoffsets :r"---r"c`|j|}|jr |jStSr)rrrr)rrrs rr$z_tzicalvtz.dsts(r" ::$$ $Kr"c8|j|jSr)rr(rs rr(z_tzicalvtz.tznamesr")))r"c2dt|jzS)Nz)rarr>s rr?z_tzicalvtz.__repr__s$tzz"222r")r=rArBrUrrr r$r r(r?rErFrrs@rrrusF#%3+Z. **3""Jr"rc6eZdZdZdZdZd dZdZdZdZ y) tzicala[ 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 cddlmat|tr||_t |d}n&t |dt||_t|}i|_ |5}|j|jdddy#1swYyxYw)Nr)rrrS) rrr/rropenrra _nullcontext_vtz _parse_rfcread)rfileobjfobjs rrUztzical.__init__ss" g| ,DG7C(GgvtG}=DG"7+G  ) OODIIK ( ) ) )s  BB cHt|jjS)z? Retrieves the available time zones as a list. )listrkeysr>s rrz tzical.keyssDIINN$%%r"Nc|dt|jdk(r tdt|jdkDr tdtt |j}|jj |S)a 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)rrrnextiterget)rrs rrz tzical.getsf$ <499~" !788TYY!# !CDDTYY(Dyy}}T""r"cz|j}|s td|ddvrd|ddk(}|dd}nd}t|dk(r&t|ddd zt|ddd zz|zSt|d k(r5t|ddd zt|ddd zzt|ddz|zStd |z) Nz empty offsetr)+-)rrrrrri<zinvalid offset: )striprrrb)rrsignals r _parse_offsetztzical._parse_offsets GGI^, , Q4: adck*F!"AF q6Q;"1J%AabE R76A A Vq["1J%AaF b(883qu:EO O/!34 4r"c|j}|s tdd}|t|krQ||j}|s||=n)|dkDr|ddk(r||dz xx|ddz cc<||=n|dz }|t|krQd}g}d}d}|D]t}|s|j dd\} } | j d} | s td| dj } | dd} |r | d k(r | d vrntd | z| }d} d} d}g}d}z| d k(r| d k(rF|rtd|z|s td|s tdt |||j|<d}| |k(rz s td td tdd}r(tjdj|ddd}t| ||dk(|}|j|d}Itd| z|r| dk(r1| D]}|dk7s d|z}t|j|d} | dvrj|| dk(r*| rtd| d| dd|j| } | dk(r&| rtd | dz|j| }| d!k(r| rtd"| dz| }| d#k(r#td$| z| d%k(r| rtd&| dz| }M| d'vrStd$| z| d k(sh| d k(sod}g}d}wy)(Nz empty stringr rF:;zempty property nameBEGIN)STANDARDDAYLIGHTzunknown component: END VTIMEZONEzcomponent not closed: zmandatory TZID not foundz at least one component is neededzmandatory DTSTART not foundz mandatory TZOFFSETFROM not found T) compatibleignoretzcacherzinvalid component end: DTSTARTzVALUE=DATE-TIMEz(Unsupported DTSTART param in VTIMEZONE: )RRULERDATEEXRULEEXDATE TZOFFSETFROMz unsupported z parm: TZOFFSETTOzunsupported TZOFFSETTO parm: TZNAMEzunsupported TZNAME parm: COMMENTzunsupported property: TZIDzunsupported TZID parm: )TZURLz LAST-MODIFIEDr#) splitlinesrrrstripsplitupperrrrrrulestrjoinrappendr )rrlinesilinerrinvtzcomptyperSvalueparms founddtstartrr rrulelinesr(rrrparmmsgs rrztzical._parse_rfcs ^, , #e*n8??$D!HQ47c>ac d12h& !HQ#e*nf D**S!,KD%JJsOE !6778>>#D!"IE7? 88()>u)DEE$H#(L#'L!%J!#J!FU] +#",-Eh-N"OO#",-G"HH$", B#DD+5T5*A $ %(*+",-J"KK'/", B#DD%-", B#DD"%!& *0E;?9=6:"0"BE!H M#OO'+'9'9%'@ - ", ?a H#JJ%)%7%7%> ) ", ;E!H D#FF!&*()A$)FGGv~ ", 9%( B#DD$!FF()A$)FGGUk%9Mf r"c`|jjdt|jdSrrr>s rr?ztzical.__repr__rr"r) r=rArBrCrUrrr rr?r'r"rrrs( )"& #65 {zCr"rz/etc/localtimer{cbtft tfz Gfddt}|S)NcBeZdZdZdZdfd ZdZdZeddZ y) __get_gettz..GettzFunca 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. It searches for these keys in the following order: 1. On the search path defined in :data:`TZPATH`. 2. In the `tzdata `_ Python package. 3. Using the system-specific mechanisms (e.g. the Windows registry). .. 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 ctj|_d|_t |_t j|_y)N) weakrefWeakValueDictionary_GettzFunc__instances_GettzFunc__strong_cache_sizer_GettzFunc__strong_cacherrrr>s rrUz'__get_gettz..GettzFunc.__init__s6&::.GettzFunc.__call__s!! <%%))$5: 40B L)"o>!z24((. "+ < <.-1,?,?,C,CD",M##D)t**+d.F.FF''//U/;5 <8I9 <8IsAC*A'CC%c|j5||_t|j|kDr5|jj dt|j|kDr5dddy#1swYyxYw)NFrF)rrBrrCrI)rsizes rset_cache_sizez-__get_gettz..GettzFunc.set_cache_sizesg!! <+/($--.5''//U/;$--.5 < < s r cache_clearz*__get_gettz..GettzFunc.cache_clearsC!! ,#*#>#>#@ ##))+ , , ,s 4A  Ac:d}|s tjd}||dvrtD]}tjj |sE|}t jD]/}tjj||}t|s/ngt|ss t|}|St}|S |jdr|dd}d|vrytjj |rt|r t|}|Sd}|St+|r t-|t jD][}tjj||}t|s|j/dd }t|sL t|| }|Sd}|g}d|vr!|j1|j/dd |D]0} t3j4|5} t| | cdddcSt6 t7|}|sB|D]} | d vs t=|}|S|d vrt>}|S|t@jBvr t}|S#t$rY9wxYw#tttf$rYHwxYw#t $r>}t#|t$r"d}t'j(t!||nYd}~d}~wwxYw#tttf$rYwxYw#1swYnxYw)#t$rY5wxYw#t8t:f$rd}YwxYw#t$rY|SwxYw) zA non-cached version of gettzNTZ)rrrz'gettz argument should be str, not bytesr_)key 0123456789r)"osenvironKeyErrorTZFILESpathisabsr TZPATHr+_isfilerIOErrorOSErrorrrd startswithrNr/bytessix raise_from_escapes_tzpath_warn_tzpath_escaperr,r _load_tzdatar WindowsErrorUnicodeEncodeErrorrr&rgr() rStzfilepathfilenamer^enew_msg candidates candidatefcs rrHz&__get_gettz..GettzFunc.nocachesgB::d+D|ty0 '#H77==2#+$+NN%D')ww||D('CH&x0 %% %x(!!'!1B!xIQ# !BpIms+#ABxT>77==&t}#D\FIC"BI't,+D1 ';3#%77<<d#;&x0'/'7'7S'AH#*8#4 ( !!'d!;B!hIy;3$"'+V $;&--dll3.DE)3 %I%%1%>%>y%I!?Q+1!+>!?!? %!,*%*4[ "%)3 $% #4%--24[%* I!3$(>#9),BI&*T[[%8)0BIW  !(*=! !!!$."Ky'91=>@!(*=!!!$!?!?!?#-% !% %%12D#E*%)*,6%-(,$) I%-sI I5I1> J;?K$ K! K$5 K4 L  III.-I.1 J8:3J33J8;KKK K$$ K10K14L L  LLr) r=rArBrCrUrLrOrR staticmethodrH)rKsr GettzFuncr<s4I T 7 > <  , q  q r"rw)rdrrE)rwrKs @r __get_gettzrxs5jOJ=(nFn` ;r"ceZdZdZy)DeprecatedTzKeyWarningaWarning raised when :func:`gettz` is given a key outside of TZPATH. Relative keys like ``"../../etc/localtime"`` resolve to files outside of every directory on :data:`TZPATH`. Support for these is deprecated, and a warnings filter turns this warning into an error by default. To keep the old behavior for now, filter it out, e.g.:: warnings.filterwarnings( "ignore", category=dateutil.tz.DeprecatedTzKeyWarning ) Absolute paths to TZif files are not affected. N)r=rArBrCr'r"rrzrzs r"rzctjj|jtjddtj k(S)Nrr)rZr^normpathr(seppardirrEs rrhrhs8 77  D ! ' ' 21 5 BBr"c|tjdtdtjd|dtdy)NerrorT)categoryr,zgettz(z) refers to a file outside of TZPATH; support for keys like this is deprecated and will be removed in a future version. Use an absolute path instead.r) stacklevel)warningsfilterwarningsrzrrEs rriris: 0 MM,0 2  r"c ttj}d}tj D] }t jj|s$t j|D]\}}}||k(r*d|vr|jdd|vr|jd|D]}t jj||}t jj||}t jdk7r |jt jd}|r||vr~||s|j|d|vr|jdd|vr|jd|S#t$rt}YewxYw)aReturns a set containing all available IANA time zones keys. These are suitable for use with :func:`gettz`. This is essentially a direct port of :py:func:`zoneinfo.available_timezones`. The search includes time zones found on :data:`TZPATH` as well as any time zones provided by the `tzdata `_ package if it is installed. :return: Returns a mutable set containing strings of time zones. Each call will return a fresh set. .. caution:: This may attempt to open a large number of files, since the best way to determine if a given file on the time zone search path is to open it and check for the "magic string" at the beginning. .. note:: These values are not designed to be exposed to end-users; for user-facing elements, applications should use something like CLDR (the Unicode Common Locale Data Repository) to get more user-friendly strings. c t|d5}|jddk(cdddS#1swYyxYw#t$rYywxYw)NrbrsTZifF)rr Exception)fpathrts r valid_keyz+available_iana_timezones..valid_keysI eT" ,avvayG+ , , ,  s# 8, 8588 AArightposix)r/ posixrulesr{)setr_load_tzdata_keys ImportErrorr r`rZr^existswalkremover+relpathr}radd) valid_zonesrtz_rootrootdirnamesfilesfilerrXs ravailable_iana_timezonesrsa:,88:; >>)ww~~g& %'WWW%5 ) !D(Ewh&OOG,h&OOG, ) T40ggooe7o;66S=++bffc2Cc[0U#OOC( ) ) )4{" <(k! ;' [ e sE..FFc|#|j td|j}|jd}|j|jtj|}|jd}||k(S)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)rrr astimezoner&)rrmdt_rts rdatetime_existsr sz& z 99 KL L YY 4 B JJbJ ! , ,S 1 < >> 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)rrrPrQr )r curr_offset old_offsets rresolve_imaginaryr\sfH yy_R%8H..R88CCE 8--B77BBD  kJ&& Ir"cP|jdtz jS)z Convert a :class:`datetime.datetime` object to an epoch timestamp in seconds since January 1, 1970, ignoring the time zone. Nr)rEPOCHrM)rs rrzrzs# JJdJ #e + : : <c` tjj|S#t$rYywxYw)NF)rZr^isfiler)r^s rraras, 77>>$' '  s ! --) nullcontextc"eZdZdZdZdZdZy)rzj Class for wrapping contexts so that they are passed through in a with statement. c||_yrcontext)rrs rrUz_nullcontext.__init__s "DLr"c|jSrrr>s r __enter__z_nullcontext.__enter__s << r"cyrr')argsrs r__exit__z_nullcontext.__exit__s r"N)r=rArBrCrUrrr'r"rrrs  #  r"rr)FrCbisectrPrZstructsysrgrr? collectionsrrfr six.movesrrUrr _commonr r r r r _factoriesrrr_tzfilerwinrrrrrQrr add_metaclassrrr&r0rdrrrErrrr]rxgettz FutureWarningrzrhrirrrrrz version_inforRrar^r contextlibrrr'r"rrs; # FE& x!$1a+< Q#HOOQ#!Q#n g#$A#xA#%A#H|#g|#~_&k_&D=!tCGtC"tCnVS#S#lKCVKC\ [ )up   ]  C L^D+*\+\=v!fggnnG6S,EJT,  v  s$$G=G GGG'&G'