MhdZddlZddlZddlZddlmZddlmZddlmZddlm Z ddlm Z ddl m Z dd lmZdd lmZmZmZmZmZmZmZmZmZmZmZdd lmZdd lmZdd l m!Z!m"Z"m#Z#m$Z$ddl%m&Z&m'Z'ddl(m)Z)ej*dkr ddl+m,Z,m-Z-nddlm,Z,m-Z-ee e.fZ/e-dZ0e-dZ1e-dZ2GddZ3e34ej5e3_5e34ej6e3_6dS)z_ Provides the :class:`Arrow ` class, an enhanced ``datetime`` replacement. Ndate)datetime)time) timedeltatzinfo)trunc) struct_time) AnyClassVar GeneratorIterableListMappingOptionalTupleUnioncastoverload)tz) relativedelta) formatterlocalesparserutil)DEFAULT_LOCALEDEHUMANIZE_LOCALES)TimeFrameLiteral))FinalLiteral)yearyearsmonthmonthsdaydayshourhoursminuteminutessecondseconds microsecond microsecondsweekweeksquarterquarters)[)()z(]z[]) autor.r,r*r(r2r&r4r$cp eZdZUdZejZeeed<eded<eded<gdZ e e e ed<de DZ e e e ed<d Ze eed <d Ze eed <d Ze eed<dZe eed<dZe eed<dZe eed<dZe eed<dZe eed<deeeeeeedZe eeefed<eed< dded ed!ed"ed#ed$ed%ed&eed'ed(dfd)Zedd&ee d(dfd*Z!edd+Z"e dd,e#eee fd&eed(dfd-Z$ed,e#eee fd(dfd.Z%edd/ed&eed(dfd0Z&edd1e'd&eed(dfd2Z(e dd3e d4e d&eed(dfd5Z)ed6ed(dfd7Z*e dd8e+d9e#defd:e#dedfd;eedZ- dd8e+dBedCe.dDe/dEed(e0dFf dGZ1d8e+d(dfdHZ2d8e+d(dfdIZ3e dd8e+d9ed:ed;eede` object. Implements the ``datetime`` interface, behaving as an aware ``datetime`` while implementing additional functionality. :param year: the calendar year. :param month: the calendar month. :param day: the calendar day. :param hour: (optional) the hour. Defaults to 0. :param minute: (optional) the minute, Defaults to 0. :param second: (optional) the second, Defaults to 0. :param microsecond: (optional) the microsecond. Defaults to 0. :param tzinfo: (optional) A timezone expression. Defaults to UTC. :param fold: (optional) 0 or 1, used to disambiguate repeated wall times. Defaults to 0. .. _tz-expr: Recognized timezone expressions: - A ``tzinfo`` object. - A ``str`` describing a timezone, similar to 'US/Pacific', or 'Europe/Berlin'. - A ``str`` in ISO 8601 style, as in '+07:00'. - A ``str``, one of the following: 'local', 'utc', 'UTC'. Usage:: >>> import arrow >>> arrow.Arrow(2013, 5, 5, 12, 30, 45) resolutionminmax)r$r&r(r*r,r.r0_ATTRScg|]}|dS)s).0as K/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/arrow/arrow.py zArrow.s&?&?&?1!www&?&?&? _ATTRS_PLURALr _MONTHS_PER_QUARTER<_SECS_PER_MINUTEi_SECS_PER_HOURiQ _SECS_PER_DAYi: _SECS_PER_WEEKgDA_SECS_PER_MONTHgP(^A_SECS_PER_QUARTERi3_SECS_PER_YEARg?)r.r,r*r(r2r&r4r$ _SECS_MAP _datetimerNr$r&r(r*r,r.r0r kwargsreturnc |tj}nt|trLt |dr &((FF vy ) ) 7 ++ 7'' 7  7 (..v{;;FF  $ $ 7(..v66Fzz&!$$$ %dFFKd   rFc|tj}tj|}||j|j|j|j|j|j |j |j t|dd S)a4Constructs an :class:`Arrow ` object, representing "now" in the given timezone. :param tzinfo: (optional) a ``tzinfo`` object. Defaults to local time. Usage:: >>> arrow.now('Asia/Baku') NrXrrY) rZtzlocalrcnowr$r&r(r*r,r.r0r getattr)clsr dts rDrhz Arrow.nowsv > (**F _V $ $s G H F G I I N IVQ''    rFctjtj}||j|j|j|j|j|j |j |j t|dd S)zConstructs an :class:`Arrow ` object, representing "now" in UTC time. Usage:: >>> arrow.utcnow() rXrrY) rcrhrZr[r$r&r(r*r,r.r0r ri)rjrks rDutcnowz Arrow.utcnowsl_[.00 1 1s G H F G I I N IVQ''    rF timestampc|tj}n4t|trtj|}tj|std|dtj t|}tj ||}||j|j|j|j|j|j|j|jt-|dd S)a0Constructs an :class:`Arrow ` object from a timestamp, converted to the given timezone. :param timestamp: an ``int`` or ``float`` timestamp, or a ``str`` that converts to either. :param tzinfo: (optional) a ``tzinfo`` object. Defaults to local time. NThe provided timestamp is invalid.rXrrY)rZrgr\rarr_r`r is_timestamp ValueErrornormalize_timestampfloatrc fromtimestampr$r&r(r*r,r.r0r ri)rjrnr rks rDrvzArrow.fromtimestamps > (**FF  $ $ 7(..v66F ++ RPyPPPQQ Q,U9-=-=>>  &y& 9 9s G H F G I I N IVQ''    rFchtj|std|dtjt |}t j|}||j|j|j |j |j |j |j tjt!|dd S)zConstructs an :class:`Arrow ` object from a timestamp, in UTC time. :param timestamp: an ``int`` or ``float`` timestamp, or a ``str`` that converts to either. rprqrXrrY)rrrrsrtrurcutcfromtimestampr$r&r(r*r,r.r0rZr[ri)rjrnrks rDrxzArrow.utcfromtimestamps ++ RPyPPPQQ Q,U9-=-=>>  )) 4 4s G H F G I I N    VQ''    rFrkc|"|jtj}n|j}||j|j|j|j|j|j|j |t|dd S)aConstructs an :class:`Arrow ` object from a ``datetime`` and optional replacement timezone. :param dt: the ``datetime`` :param tzinfo: (optional) A :ref:`timezone expression `. Defaults to ``dt``'s timezone, or UTC if naive. Usage:: >>> dt datetime.datetime(2021, 4, 7, 13, 48, tzinfo=tzfile('/usr/share/zoneinfo/US/Pacific')) >>> arrow.Arrow.fromdatetime(dt) NrXrrY) r rZr[r$r&r(r*r,r.r0ri)rjrkr s rD fromdatetimezArrow.fromdatetime1sv$ >y $*,,s G H F G I I N VQ''    rFrch|tj}||j|j|j|S)aConstructs an :class:`Arrow ` object from a ``date`` and optional replacement timezone. All time values are set to 0. :param date: the ``date`` :param tzinfo: (optional) A :ref:`timezone expression `. Defaults to UTC. Nr)rZr[r$r&r()rjrr s rDfromdatezArrow.fromdateUs6 > &((Fs49dj$(6BBBBrFdate_strfmtctj||}||j}||j|j|j|j|j|j|j |t|dd S)ajConstructs an :class:`Arrow ` object from a date string and format, in the style of ``datetime.strptime``. Optionally replaces the parsed timezone. :param date_str: the date string. :param fmt: the format string using datetime format codes. :param tzinfo: (optional) A :ref:`timezone expression `. Defaults to the parsed timezone if ``fmt`` contains a timezone directive, otherwise UTC. Usage:: >>> arrow.Arrow.strptime('20-01-2019 15:49:10', '%d-%m-%Y %H:%M:%S') NrXrrY) rcstrptimer r$r&r(r*r,r.r0ri)rjr}r~r rks rDrzArrow.strptimedsp& !(C 0 0 >YFs G H F G I I N VQ''    rFordinalctj|tj|}||j|j|j|j|j|j |j |j t|dd S)a+Constructs an :class:`Arrow ` object corresponding to the Gregorian Ordinal. :param ordinal: an ``int`` corresponding to a Gregorian Ordinal. Usage:: >>> arrow.fromordinal(737741) rXrrY) rvalidate_ordinalrc fromordinalr$r&r(r*r,r.r0r ri)rjrrks rDrzArrow.fromordinalsu g&&&  $W - -s G H F G I I N IVQ''    rFframestartendrlimit)r:NNc#K||\}}}|||jn|} ||| }|||\}}||| }|||j} d} d} |kr| |kr| dz } Vfd|jD} || d| ij d i||i|dvr j| krd } | r+| s| |kr | |k{dSdSdSdS) aReturns an iterator of :class:`Arrow ` objects, representing points in time between two inputs. :param frame: The timeframe. Can be any ``datetime`` property (day, hour, minute...). :param start: A datetime expression, the start of the range. :param end: (optional) A datetime expression, the end of the range. :param tz: (optional) A :ref:`timezone expression `. Defaults to ``start``'s timezone, or UTC if ``start`` is naive. :param limit: (optional) A maximum number of tuples to return. **NOTE**: The ``end`` or ``limit`` must be provided. Call with ``end`` alone to return the entire range. Call with ``limit`` alone to return a maximum # of results from the start. Call with both to cap a range at a maximum # of results. **NOTE**: ``tz`` internally **replaces** the timezones of both ``start`` and ``end`` before iterating. As such, either call with naive objects and ``tz``, or aware objects from the same timezone and no ``tz``. Supported frame values: year, quarter, month, week, day, hour, minute, second, microsecond. Recognized datetime expressions: - An :class:`Arrow ` object. - A ``datetime`` object. Usage:: >>> start = datetime(2013, 5, 5, 12, 30) >>> end = datetime(2013, 5, 5, 17, 15) >>> for r in arrow.Arrow.range('hour', start, end): ... print(repr(r)) ... **NOTE**: Unlike Python's ``range``, ``end`` *may* be included in the returned iterator:: >>> start = datetime(2013, 5, 5, 12, 30) >>> end = datetime(2013, 5, 5, 13, 30) >>> for r in arrow.Arrow.range('hour', start, end): ... print(repr(r)) ... NrFrc0g|]}t|SrAri)rBfcurrents rDrEzArrow.range..s#>>>aggq))>>>rFr )r&r4r$T)r(rA) _get_frames _get_tzinfor _get_datetimereplace_get_iteration_paramsrzr(r>shift_is_last_day_of_month)rjrrrrr_frame_relativerelative_stepsr original_dayday_is_clippedivaluesrs @rDrangez Arrow.rangesv-0OOE,B,B)>>DD!!%((000??..sE:: U$$,,F,;;""5))y  nnU FAMMM>>>>3:>>>F7cc61&117!>2G444|9S9S!% ` objects, representing the timespan of the :class:`Arrow ` object in a given timeframe. :param frame: the timeframe. Can be any ``datetime`` property (day, hour, minute...). :param count: (optional) the number of frames to span. :param bounds: (optional) a ``str`` of either '()', '(]', '[)', or '[]' that specifies whether to include or exclude the start and end values in the span. '(' excludes the start, '[' includes the start, ')' excludes the end, and ']' includes the end. If the bounds are not specified, the default bound '[)' is used. :param exact: (optional) whether to have the start of the timespan begin exactly at the time specified by ``start`` and the end of the timespan truncated so as not to extend beyond ``end``. :param week_start: (optional) only used in combination with the week timeframe. Follows isoweekday() where Monday is 1 and Sunday is 7. Supported frame values: year, quarter, month, week, day, hour, minute, second. Usage:: >>> arrow.utcnow() >>> arrow.utcnow().span('hour') (, ) >>> arrow.utcnow().span('day') (, ) >>> arrow.utcnow().span('day', count=2) (, ) >>> arrow.utcnow().span('day', bounds='[]') (, ) >>> arrow.utcnow().span('week') (, ) >>> arrow.utcnow().span('week', week_start=6) (, ) rz,week_start argument must be between 1 and 7.r2r(r4r&Nc0g|]}t|SrAr)rBrrds rDrEzArrow.span..@s#7771gdA&&777rFr r r)r))r'(r1)rA)rsrvalidate_boundsrr>indexrlenappend __class__r isoweekdayrr&)rdrrrrrframe_absoluterrattrfloorrframesrrdeltaceils` rDspanz Arrow.spansbJ####!####KLL L V$$$9=9I9I%9P9P6 V # #DD y ( (DD!D DK%%d++E[519-F7777777F1s6{{?++ ! ! a    "DNF?4;??E'''$//*;*;;; 4??+<+` object, representing the "floor" of the timespan of the :class:`Arrow ` object in a given timeframe. Equivalent to the first element in the 2-tuple returned by :func:`span `. :param frame: the timeframe. Can be any ``datetime`` property (day, hour, minute...). Usage:: >>> arrow.utcnow().floor('hour') rrrdrs rDrz Arrow.floorXyy""rFc8||dS)aReturns a new :class:`Arrow ` object, representing the "ceiling" of the timespan of the :class:`Arrow ` object in a given timeframe. Equivalent to the second element in the 2-tuple returned by :func:`span `. :param frame: the timeframe. Can be any ``datetime`` property (day, hour, minute...). Usage:: >>> arrow.utcnow().ceil('hour') rrrs rDrz Arrow.ceilirrFc#(K|||jn|}|||||d}|||}||||||} |s| D]} | |||V| D]m} | |||\} } | |kr!|} |ddkr| t dz } | |krdS| t dz|krdS| | fVndS) a+ Returns an iterator of tuples, each :class:`Arrow ` objects, representing a series of timespans between two inputs. :param frame: The timeframe. Can be any ``datetime`` property (day, hour, minute...). :param start: A datetime expression, the start of the range. :param end: (optional) A datetime expression, the end of the range. :param tz: (optional) A :ref:`timezone expression `. Defaults to ``start``'s timezone, or UTC if ``start`` is naive. :param limit: (optional) A maximum number of tuples to return. :param bounds: (optional) a ``str`` of either '()', '(]', '[)', or '[]' that specifies whether to include or exclude the start and end values in each span in the range. '(' excludes the start, '[' includes the start, ')' excludes the end, and ']' includes the end. If the bounds are not specified, the default bound '[)' is used. :param exact: (optional) whether to have the first timespan start exactly at the time specified by ``start`` and the final span truncated so as not to extend beyond ``end``. **NOTE**: The ``end`` or ``limit`` must be provided. Call with ``end`` alone to return the entire range. Call with ``limit`` alone to return a maximum # of results from the start. Call with both to cap a range at a maximum # of results. **NOTE**: ``tz`` internally **replaces** the timezones of both ``start`` and ``end`` before iterating. As such, either call with naive objects and ``tz``, or aware objects from the same timezone and no ``tz``. Supported frame values: year, quarter, month, week, day, hour, minute, second, microsecond. Recognized datetime expressions: - An :class:`Arrow ` object. - A ``datetime`` object. **NOTE**: Unlike Python's ``range``, ``end`` will *always* be included in the returned iterator of timespans. Usage: >>> start = datetime(2013, 5, 5, 12, 30) >>> end = datetime(2013, 5, 5, 17, 15) >>> for r in arrow.Arrow.span_range('hour', start, end): ... print(r) ... (, ) (, ) (, ) (, ) (, ) (, ) N)rrrrrrrr)rr rzrrr) rjrrrrrrrr _rangerrrs rD span_rangezArrow.span_rangezse|DD  //44U%4HHKsF++5%b%88 @ @ @ffU6f??????  A&&vU&CCKE4czz!9##Mr::::D||B77773>>+      rFintervalc #JK|dkrtdt|||||||} t|\} } t |dz D]%} t|\} } #t $rY"wxYw| | fVn#t $rYdSwxYwd)anReturns an iterator of tuples, each :class:`Arrow ` objects, representing a series of intervals between two inputs. :param frame: The timeframe. Can be any ``datetime`` property (day, hour, minute...). :param start: A datetime expression, the start of the range. :param end: (optional) A datetime expression, the end of the range. :param interval: (optional) Time interval for the given time frame. :param tz: (optional) A timezone expression. Defaults to UTC. :param bounds: (optional) a ``str`` of either '()', '(]', '[)', or '[]' that specifies whether to include or exclude the start and end values in the intervals. '(' excludes the start, '[' includes the start, ')' excludes the end, and ']' includes the end. If the bounds are not specified, the default bound '[)' is used. :param exact: (optional) whether to have the first timespan start exactly at the time specified by ``start`` and the final interval truncated so as not to extend beyond ``end``. Supported frame values: year, quarter, month, week, day, hour, minute, second Recognized datetime expressions: - An :class:`Arrow ` object. - A ``datetime`` object. Recognized timezone expressions: - A ``tzinfo`` object. - A ``str`` describing a timezone, similar to 'US/Pacific', or 'Europe/Berlin'. - A ``str`` in ISO 8601 style, as in '+07:00'. - A ``str``, one of the following: 'local', 'utc', 'UTC'. Usage: >>> start = datetime(2013, 5, 5, 12, 30) >>> end = datetime(2013, 5, 5, 17, 15) >>> for r in arrow.Arrow.interval('hour', start, end, 2): ... print(r) ... (, ) (, ) (, ) rz%interval has to be a positive integerrTN)rsiterrnextr StopIteration) rjrrrrrrr spanRange intvlStartintvlEndrs rDrzArrow.intervalsh a<<DEE E NN5%buN M M    '+I$ Hx!|,,!!A!&*9oo 88(!!! ! (*****      s6&B)A<;B< B BB  B B! B!cLd|jjd|dS)N)r__name____str__rds rD__repr__zArrow.__repr__s(@4>*@@dllnn@@@@rFc4|jSNrR isoformatrs rDrz Arrow.__str__s~'')))rF formatstrcpt|dkr||St|S)Nr)rformatra)rdrs rD __format__zArrow.__format__s1 y>>A  ;;y)) )4yyrFc4|jSr)rR__hash__rs rDrzArrow.__hash__ s~&&(((rFnamecL|dkr|dS|dkr"t|jdz |jz dzS|dst |j|d}||Sttt ||S)Nr2rr4r) isocalendarintr&rH startswithrirRrobject__getattribute__)rdrvalues rD __getattr__zArrow.__getattr__%s 6>>##%%a( ( 9   Q$*BBCCaG Gs## #*4>4#F#FE  C00t<<===rFc@tt|jjS)zGets the ``tzinfo`` of the :class:`Arrow ` object. Usage:: >>> arw=arrow.utcnow() >>> arw.tzinfo tzutc() )rr]rRr rs rDr z Arrow.tzinfo4sIt~4555rFc|jS)zReturns a datetime representation of the :class:`Arrow ` object. Usage:: >>> arw=arrow.utcnow() >>> arw.datetime datetime.datetime(2019, 1, 24, 16, 35, 27, 276649, tzinfo=tzutc()) )rRrs rDrzArrow.datetimeCs ~rFc8|jdS)a_Returns a naive datetime representation of the :class:`Arrow ` object. Usage:: >>> nairobi = arrow.now('Africa/Nairobi') >>> nairobi >>> nairobi.naive datetime.datetime(2019, 1, 23, 19, 27, 12, 297999) Nr)rRrrs rDnaivez Arrow.naiveQs~%%T%222rFc4|jS)zReturns a timestamp representation of the :class:`Arrow ` object, in UTC time. Usage:: >>> arrow.utcnow().timestamp() 1616882340.256501 )rRrnrs rDrnzArrow.timestampb~'')))rFcDt|S)zReturns an integer timestamp representation of the :class:`Arrow ` object, in UTC time. Usage:: >>> arrow.utcnow().int_timestamp 1548260567 )rrnrs rD int_timestampzArrow.int_timestampos4>>##$$$rFc*|S)zReturns a floating-point timestamp representation of the :class:`Arrow ` object, in UTC time. Usage:: >>> arrow.utcnow().float_timestamp 1548260516.830896 )rnrs rDfloat_timestampzArrow.float_timestamp}s~~rFc|jjS)zLReturns the ``fold`` value of the :class:`Arrow ` object.)rRrXrs rDrXz Arrow.folds~""rFc4tj|jS)zIndicates whether the :class:`Arrow ` object is a repeated wall time in the current timezone. )rZdatetime_ambiguousrRrs rD ambiguouszArrow.ambiguouss-dn===rFc6tj|j S)z`Indicates whether the :class: `Arrow ` object exists in the current timezone.)rZdatetime_existsrRrs rD imaginaryzArrow.imaginarys.t~>>>>rFc6||jS)zReturns a new :class:`Arrow ` object, cloned from the current one. Usage: >>> arw = arrow.utcnow() >>> cloned = arw.clone() )rzrRrs rDclonez Arrow.clones  000rFc i}|D]B\}}||jvr|||<|dvrtd|d|dvrtd|dC|jjd i|}|d}|+||}|| }|d }||| }||S) aReturns a new :class:`Arrow ` object with attributes updated according to inputs. Use property names to set their value absolutely:: >>> import arrow >>> arw = arrow.utcnow() >>> arw >>> arw.replace(year=2014, month=6) You can also replace the timezone without conversion, using a :ref:`timezone expression `:: >>> arw.replace(tzinfo=tz.tzlocal()) )r2r4zSetting absolute z is not supported.)r rXzUnknown attribute: .r NrrXrYrA)itemsr>rsrRrrbrrz)rdrSabsolute_kwargskeyrrr rXs rDrz Arrow.replaces(* ,,.. A AJCdk!!',$$+++ !LS!L!L!LMMM... !?s!?!?!?@@@/)$.(;;?;;H%%  %%f--FooVo44Gzz&!!  oo4o00G  )))rFc i}gd}|D]G\}}||jvs||vr|||<d|j|z}td|d|dd|dxx|dd|jzz cc<|jtdi|z}tj |stj |}| |S) aReturns a new :class:`Arrow ` object with attributes updated according to inputs. Use pluralized property names to relatively shift their current value: >>> import arrow >>> arw = arrow.utcnow() >>> arw >>> arw.shift(years=1, months=-1) Day-of-the-week relative shifting can use either Python's weekday numbers (Monday = 0, Tuesday = 1 .. Sunday = 6) or using dateutil.relativedelta's day instances (MO, TU .. SU). When using weekday numbers, the returned date will always be greater than or equal to the starting date. Using the above code (which is a Saturday) and asking it to shift to Saturday: >>> arw.shift(weekday=5) While asking for a Monday: >>> arw.shift(weekday=0) )r3r5weekday, z>Invalid shift time frame. Please select one of the following: rr'rr5rA) rrGjoinrs setdefaultpoprHrRrrZrresolve_imaginaryrz)rdrSrelative_kwargsadditional_attrsrrsupported_attrrs rDrz Arrow.shifts3<;;; ,,..  JCd(((C3C,C,C',$$!%4+=@P+P!Q!Q fUcfff ""8Q///!!!    A . .1I I !!!.=#C#C?#C#CC*733 =!3G<` object, converted to the target timezone. :param tz: A :ref:`timezone expression `. Usage:: >>> utc = arrow.utcnow() >>> utc >>> utc.to('US/Pacific') >>> utc.to(tz.tzlocal()) >>> utc.to('-07:00') >>> utc.to('local') >>> utc.to('local').to('utc') rXrrY)r\r]rr_r`rR astimezonerr$r&r(r*r,r.r0r ri)rdrrks rDtozArrow.tos:"i(( /$**2..B ^ & &r * *~~ G H F G I I N IVQ''   rFzYYYY-MM-DD HH:mm:ssZZlocalec\tj||j|S)aPReturns a string representation of the :class:`Arrow ` object, formatted according to the provided format string. :param fmt: the format string. :param locale: the locale to format. Usage:: >>> arrow.utcnow().format('YYYY-MM-DD HH:mm:ss ZZ') '2013-05-09 03:56:47 -00:00' >>> arrow.utcnow().format('X') '1368071882' >>> arrow.utcnow().format('MMMM DD, YYYY') 'May 09, 2013' >>> arrow.utcnow().format() '2013-05-09 03:56:47 -00:00' )rDateTimeFormatterrrR)rdr~rs rDrz Arrow.formatCs'2*62299$.#NNNrFr8other only_distance granularityc |}tj|}|Xtjt j}|jj }nt|tr|j}nt|trH|j !|jj }nE|jj }n%tdt|jdttrt!dkrdt#t%j|z }|dkrdndt)|x} } dkr| d kr|d | S| jkr| z} |d | | S| jd zkr|d| S| jkr3t1| jzd z} |d| | S| jd zkr|d| S| jkr3t1| jzd z} |d| | S| jd zkr|d| S| jkr3t1| jzd z}|d|| S| jd zkr|d| S| jkr3t1| jzd z}|d|| S| jd zkr|d| S| jkrijjdzjjz}|jdz|jz}t1t)||z d z}|d|| S| jd zkr|d| St1| jzd z}|d|| Stt>r0tAtBdkr=tE| z}t)|d kr|d | Sndkr| zjz }ndkr| zjz }nsdkr| zjz }n_dkr| zjz }nKdkr| zjz }n7dkr| zj#z }n#dkr| zjz }ntIdtKt)|dkrdz ||| SstIdgd tDd!tBd"tDffd# }tE| }d$}|D]}|||}t!t!krtId|&| S#tN$r}tId%|d&|d'd}~wwxYw)(aReturns a localized, humanized representation of a relative difference in time. :param other: (optional) an :class:`Arrow ` or ``datetime`` object. Defaults to now in the current :class:`Arrow ` object's timezone. :param locale: (optional) a ``str`` specifying a locale. Defaults to 'en-us'. :param only_distance: (optional) returns only time difference eg: "11 seconds" without "in" or "ago" part. :param granularity: (optional) defines the precision of the output. Set it to strings 'second', 'minute', 'hour', 'day', 'week', 'month' or 'year' or a list of any combination of these strings Usage:: >>> earlier = arrow.utcnow().shift(hours=-2) >>> earlier.humanize() '2 hours ago' >>> later = earlier.shift(hours=4) >>> later.humanize(earlier) 'in 4 hours' Nrz!Invalid 'other' argument of type z4. Argument must be of type None, Arrow, or datetime.rrrr8 rh)r r/r,r-r*r+r(r)r2r3r& r'r$r%r.r4z|Invalid level of granularity. Please select between 'second', 'minute', 'hour', 'day', 'week', 'month', 'quarter' or 'year'.r@zEmpty granularity list provided. Please select one or more from 'second', 'minute', 'hour', 'day', 'week', 'month', 'quarter', 'year'._delta_framerTc |vr|zj|z }|j|z}tt|dkr.t t |dz|fn||f|S)Nrr@)rQr absrrr)rrrr rdsign timeframess rDgather_timeframesz)Arrow.humanize..gather_timeframess,, $v v0F F$."88 U,,11&--!%&6 !E!Eu M'--vuo>>>!MrF)r$r4r&r2r(r*r,r.zHumanization of the z0 granularity is not currently translated in the z> locale. Please consider making a contribution to this locale.)(r get_localercrmrrZr[rrRr r\r: TypeErrortyperlistrrround total_secondsrdescriberJrKr=rLrMrNrPr$r&rarrrurOrsr describe_multiKeyError)rdr rr r  locale_nameutcrkr delta_seconddiffr/r-r+r)r3 self_months other_monthsr'r%rrrrerrs` ` @@rDhumanizezArrow.humanize^s8 #F++ =$&&..k6G6I6I.JJC 566BB u % % BB { + + |#]]$.*?]@@%%dn&;<<EDKK4HEEE  k4 ( ( )S-=-=-B-B%a.KUDNR/>>@@AABBaZZrrQ!&kk) tE f$$"99!??5 ?NNN$///"\1G!??!7-+D1A555!??8T?WWWD///"S9N)NPQ%R%RRG!??!7-+D/!333!??64}?UUUD... 3|t7J'JA#N#NNE!??7E?WWWD.222!??5$m?TTTD///#ld6H&H!"L"LLD!??64}?UUUD/!333!??64}?UUUD000 3|t7J'JA#N#NNE!??7E?WWWD01444!??7D ?VVVD///"&."5":T^=Q"QK#%7R<"(#:L!CL;,F(G(G$K$KKF!?? & +D/!333!??64}?UUU 3|t7J'JA#N#NNE!??7E?WWWK--H V"#3[AA (** 5#6#66E5zzA~~%uMRRR& H,, </$2GGEE F** </$2EEEE E)) </$2DDEE F** </$2EEEE G++ </$2FFEE I-- </$2HHEE F** </$2EEEE$y U$$))3&K{EWWW#$@ DF  "e "=M "RW " " " " " " " " "l++ 8$<` object, that represents the time difference relative to the attributes of the :class:`Arrow ` object. :param timestring: a ``str`` representing a humanized relative time. :param locale: (optional) a ``str`` specifying a locale. Defaults to 'en-us'. Usage:: >>> arw = arrow.utcnow() >>> arw >>> earlier = arw.dehumanize("2 days ago") >>> earlier >>> arw = arrow.utcnow() >>> arw >>> later = arw.dehumanize("in a month") >>> later r-z*Dehumanize does not currently support the zN locale, please consider making a contribution to add support for this locale.)r/r-r+r)r3r'r%r)rhr/r-r+r)r3r'r%Fz\d+z (^|\b|\d)rrhTrr@cg|] \}}|d S)TrA)rBkvs rDrEz$Arrow.dehumanize..s!???TQQ?D???rFzInput string not valid. Note: Some locales do not support the week granularity in Arrow. If you are attempting to use the week granularity on an unsupported locale, this could be the cause of this error.z.*^$zInvalid input String. String does not contain any relative time information. String should either represent a time in the future or a time in the past. Ex: 'in 5 seconds' or '5 seconds ago'.c"i|] \}}||z SrArA)rBr.r/sign_vals rD z$Arrow.dehumanize..s#MMMDAq8a<MMMrFrA)rrlowerrrrsrzrRdictfromkeysrecompilerrr\rrarsearchgroup isnumericrranyfuturefindallpastr)rdr)r locale_objnormalized_locale_name current_timetime_object_info unit_visited num_patternunit unit_objectstrings_to_search time_delta time_string search_stringpatternmatch match_string num_match change_valuetime_unit_to_change future_stringfuture_patternfuture_pattern_match past_string past_patternpast_pattern_match time_changesr3s @rD dehumanizezArrow.dehumanizes6'// "(!7!7S!A!A !); ; ;TVTTT ((88  == O O OQR   }} V V V   j(( ",!6!!>. 9. 9 D++w// =$/!!%)3{+;+;$<! ,=+B+B+D+D$ 9$ 9' K #K 0 0 - 4 4V < < *%A-%A%ABB|44${{}} '..|<< !:!+!5!5!7!7QSZ=Q=Q!L$'y'8'8#9#9L5==)-L&'*$ii## 344R8C??CCb#9E !4548 011I$ 9N??\%7%7%9%9???@@ E  #) %,,T22 $9$9$9$9::-55lCC o !((.. z"5{"5"5"566 )11,??  HH ! HH %  HH9  NMMM4D4J4J4L4LMMM !|!11L111rFr7ctj|t|ts t dt |dt|ts t dt |d|ddk}|ddk}|j}|j}|j}||cxko|knco|p||ko|p||kS)aReturns a boolean denoting whether the :class:`Arrow ` object is between the start and end limits. :param start: an :class:`Arrow ` object. :param end: an :class:`Arrow ` object. :param bounds: (optional) a ``str`` of either '()', '(]', '[)', or '[]' that specifies whether to include or exclude the start and end values in the range. '(' excludes the start, '[' includes the start, ')' excludes the end, and ']' includes the end. If the bounds are not specified, the default bound '()' is used. Usage:: >>> start = arrow.get(datetime(2013, 5, 5, 12, 30, 10)) >>> end = arrow.get(datetime(2013, 5, 5, 12, 30, 36)) >>> arrow.get(datetime(2013, 5, 5, 12, 30, 27)).is_between(start, end) True >>> start = arrow.get(datetime(2013, 5, 5)) >>> end = arrow.get(datetime(2013, 5, 8)) >>> arrow.get(datetime(2013, 5, 8)).is_between(start, end, '[]') True >>> start = arrow.get(datetime(2013, 5, 5)) >>> end = arrow.get(datetime(2013, 5, 8)) >>> arrow.get(datetime(2013, 5, 8)).is_between(start, end, '[)') False z)Cannot parse start date argument type of rz'Cannot parse end date argument type of r[r])rrr\r:rrr) rdrrr include_start include_end target_tsstart_tsend_tss rD is_betweenzArrow.is_betweensF V$$$%'' LDKKLLL #u%% XVd5kkVVVWW Wq S( Qi3& ( ($ , , , ,f , , , , 46(Y"6 42 F 2 rFc4|jS)zReturns a ``date`` object with the same year, month and day. Usage:: >>> arrow.utcnow().date() datetime.date(2019, 1, 23) )rRrrs rDrz Arrow.date~""$$$rFc4|jS)zReturns a ``time`` object with the same hour, minute, second, microsecond. Usage:: >>> arrow.utcnow().time() datetime.time(12, 15, 34, 68352) )rRrrs rDrz Arrow.timererFc4|jS)zReturns a ``time`` object with the same hour, minute, second, microsecond and tzinfo. Usage:: >>> arrow.utcnow().timetz() datetime.time(12, 5, 18, 298893, tzinfo=tzutc()) )rRtimetzrs rDrhz Arrow.timetzs~$$&&&rFc6|j|S)aReturns a ``datetime`` object, converted to the specified timezone. :param tz: a ``tzinfo`` object. Usage:: >>> pacific=arrow.now('US/Pacific') >>> nyc=arrow.now('America/New_York').tzinfo >>> pacific.astimezone(nyc) datetime.datetime(2019, 1, 20, 10, 24, 22, 328172, tzinfo=tzfile('/usr/share/zoneinfo/America/New_York')) )rRr)rdrs rDrzArrow.astimezone s~((,,,rFc4|jS)zReturns a ``timedelta`` object representing the whole number of minutes difference from UTC time. Usage:: >>> arrow.now('US/Pacific').utcoffset() datetime.timedelta(-1, 57600) )rR utcoffsetrs rDrkzArrow.utcoffsetrrFc4|jS)zReturns the daylight savings time adjustment. Usage:: >>> arrow.utcnow().dst() datetime.timedelta(0) )rRdstrs rDrmz Arrow.dst)s~!!###rFc4|jS)aReturns a ``time.struct_time``, in the current timezone. Usage:: >>> arrow.utcnow().timetuple() time.struct_time(tm_year=2019, tm_mon=1, tm_mday=20, tm_hour=15, tm_min=17, tm_sec=8, tm_wday=6, tm_yday=20, tm_isdst=0) )rR timetuplers rDrozArrow.timetuple5~'')))rFc4|jS)zReturns a ``time.struct_time``, in UTC time. Usage:: >>> arrow.utcnow().utctimetuple() time.struct_time(tm_year=2019, tm_mon=1, tm_mday=19, tm_hour=21, tm_min=41, tm_sec=7, tm_wday=5, tm_yday=19, tm_isdst=0) )rR utctimetuplers rDrrzArrow.utctimetupleAs~**,,,rFc4|jS)zReturns the proleptic Gregorian ordinal of the date. Usage:: >>> arrow.utcnow().toordinal() 737078 )rR toordinalrs rDrtzArrow.toordinalMrprFc4|jS)zReturns the day of the week as an integer (0-6). Usage:: >>> arrow.utcnow().weekday() 5 )rRrrs rDrz Arrow.weekdayYs~%%'''rFc4|jS)zReturns the ISO day of the week as an integer (1-7). Usage:: >>> arrow.utcnow().isoweekday() 6 )rRrrs rDrzArrow.isoweekdayes~((***rFc4|jS)zReturns a 3-tuple, (ISO year, ISO week number, ISO weekday). Usage:: >>> arrow.utcnow().isocalendar() (2019, 3, 6) )rRrrs rDrzArrow.isocalendarqs~))+++rFTseptimespecc8|j||S)zReturns an ISO 8601 formatted representation of the date and time. Usage:: >>> arrow.utcnow().isoformat() '2019-01-19T18:30:52.442118+00:00' r)rdryrzs rDrzArrow.isoformat}s~''X666rFc4|jS)zReturns a ctime formatted representation of the date and time. Usage:: >>> arrow.utcnow().ctime() 'Sat Jan 19 18:26:50 2019' )rRctimers rDr}z Arrow.ctimes~##%%%rFrc6|j|S)zFormats in the style of ``datetime.strftime``. :param format: the format string. Usage:: >>> arrow.utcnow().strftime('%d-%m-%Y %H:%M:%S') '23-01-2019 12:28:17' )rRstrftime)rdrs rDrzArrow.strftimes~&&v...rFc*|S)zSerializes for the ``for_json`` protocol of simplejson. Usage:: >>> arrow.utcnow().for_json() '2019-01-19T18:25:36.760079+00:00' )rrs rDfor_jsonzArrow.for_jsons~~rFct|ttfr(||j|z|jjSt Sr)r\rrrzrRr NotImplementedrdr s rD__add__z Arrow.__add__sB ei7 8 8 T$$T^e%;T^=RSS SrFc,||Sr)rrs rD__radd__zArrow.__radd__s||E"""rFcdSrrArs rD__sub__z Arrow.__sub__ rFcdSrrArs rDrz Arrow.__sub__rrFct|ttfr(||j|z |jjSt|t r |j|z St|tr|j|jz StSr) r\rrrzrRr rcr:rrs rDrz Arrow.__sub__s ei7 8 8 4$$T^e%;T^=RSS S { + + 4>E) ) u % % 4>EO3 3rFcNt|tr ||jz StSr)r\rcrRrrs rD__rsub__zArrow.__rsub__s' e[ ) ) *4>) )rFczt|ttfsdS|j||kS)NF)r\r:rcrRrrs rD__eq__z Arrow.__eq__s9%%!566 5~!3!3E!:!:::rFcjt|ttfsdS|| S)NT)r\r:rcrrs rD__ne__z Arrow.__ne__s3%%!566 4;;u%%%%rFct|ttfstS|j||kSrr\r:rcrrRrrs rD__gt__z Arrow.__gt__:%%!566 "! !~ 2 25 9 999rFct|ttfstS|j||kSrrrs rD__ge__z Arrow.__ge__:%%!566 "! !~!3!3E!:!:::rFct|ttfstS|j||kSrrrs rD__lt__z Arrow.__lt__rrFct|ttfstS|j||kSrrrs rD__le__z Arrow.__le__rrFtz_exprc|tjSt|tr|S tj|S#tj$rt|dwxYw)z1Get normalized tzinfo object from various inputs.Nz not recognized as a timezone.) rZr[r\r]rr_r` ParserErrorrs)rs rDrzArrow._get_tzinfos ?$&& & gy ) ) ON O*00999% O O O G!M!M!MNNN Os A "A/exprct|tr|jSt|tr|St j|r)t |}||jSt|d)z0Get datetime object from a specified expression.z+ not recognized as a datetime or timestamp.) r\r:rrcrrrrurxrs)rjrrns rDrzArrow._get_datetimes dE " " U= k * * UK  t $ $ Ud I'' 22; ;SSSTT TrFc||jvr||ddfS|ddkr|dd|jvr |dd|dfS|dvrdS|dvrdSd gd }td |d |d )zFinds relevant timeframe and steps for use in range and span methods. Returns a 3 element tuple in the form (frame, plural frame, step), for example ("day", "days", 1) r@rrN)r2r3)r2r3r)r4r5)r4r'r r) zyear(s)zmonth(s)zday(s)zhour(s)z minute(s)z second(s)zmicrosecond(s)zweek(s)z quarter(s)zRange or span over frame z" not supported. Supported frames: r)r>rrs)rjr supporteds rDrzArrow._get_framess 3:  DQ& & "X__crccj!8!89dA% % & & &%% , , ,))      I`D``T]``` rFcb||td|j|fS||tjfS||fS)z3Sets default end and limit values for range method.Nz$One of 'end' or 'limit' is required.)rsr=sysmaxsize)rjrrs rDrzArrow._get_iteration_params8sG ;} !GHHH7E> !}CK'': rFc^|jtj|j|jdkS)zOReturns a boolean indicating whether the datetime is the last day of the month.r)r(calendar monthranger$r&rs rDrzArrow._is_last_day_of_monthFs'x8.ty$*EEaHHHrF)rrrrNr)rTr:)NNN)rr6Fr)NNr6F)rNr6F)r()r7)rxr8)sr __module__ __qualname____doc__rcr;r r__annotations__r>r"rrarGrHrrJrKrLrMrNrurOrPrQrrrTZ_EXPRr re classmethodr]rhrmrrvrxrzrr|rr _T_FRAMESrr_BOUNDSboolrrrrrrrrrrrrpropertyr rrrnrrrXrrrrrrrr _GRANULARITYr'rZrcdt_timerrhrrkrmr rorrrtrrrrr}rrrrrrrrrrrrrr staticmethodrrrrrrArFrDr:r:SsS@'2& > > > > > 6 6 6 6X 6 +   X 3{333X3 *5 * * * * %s % % %X %      X  #c###X# >4>>>X>?4???X? 1 1 1 1,*,*,*,*,*,*\5*c5*g5*5*5*5*n, W, , , , , b1OOO:=O OOOO:48$#?E ~~Wk4/0~~ ~ <l);;< ~ ~~~~@I2I2sI2CI2gI2I2I2I2b 8 8 8 8  8  8 8 8 8 x %d % % % % %g % % % % ' ' ' ' '-Xi0-[---- *8I. * * * * $Xi( $ $ $ $ *; * * * * -k - - - - *3 * * * * ( ( ( ( ( +C + + + + ,U3S=1 , , , , 7 7S 7# 73 7 7 7 7 &s & & & & /s /s / / / /  #     SW #eI}$<=#'#### U9m#;<    X  U;#78 Y   X  S U9g+=%>    ci;C;D;;;; &C&D&&&& :C:D:::: ;C;D;;;; :C:D:::: ;C;D;;;; OXg. O9 O O O\ O U+sE3>? U  U U U[ UyU3S=-A[@  HSM eCQTHo   [ IGIIII\IIIrFr:)7rrr8rrrrcrrrr r]mathr r typingr r rrrrrrrrrdateutilrrZdateutil.relativedeltararrowrrrrarrow.constantsrr arrow.localesr version_infotyping_extensionsr"r#rarrrrr:rzr<r=rArFrDrs ,,,,,,$$$$$$((((((                          '&&&&&000000222222222222>>>>>>>>******f000000000%%%%%%%%  3    * ( )   vIvIvIvIvIvIvIvIr7   { / /   { / / rF