o iP@s8dZddlmZddlmZddlmZddlmZ ddlm Z ddl m Z d Z e r:dd lZdd lmZdd lmZgd ZeGdddeZdPddZdQddZd d ddRd d!Z " #dSdTd(d)Z " # dUdVd-d.ZdWd0d1ZdXdYd5d6ZdZd7d8Zd[d?d@Zd\dBdCZd]dEdFZ # G Hd^d_dKdLZ!d`dNdOZ"d S)azYTime humanizing functions. These are largely borrowed from Django's `contrib.humanize`. ) annotations)Enum)total_ordering)_gettext) _ngettext)intcommaFN)Iterable)Any) naturaldate naturalday naturaldelta naturaltime precisedeltac@s6eZdZdZdZdZdZdZdZdZ dZ dd d Z dS)Unitrrotherr returncCs|j|jur |j|jkStS)N) __class__valueNotImplemented)selfrrA/home/ubuntu/.local/lib/python3.10/site-packages/humanize/time.py__lt__)s  z Unit.__lt__N)rr rr ) __name__ __module__ __qualname__ MICROSECONDS MILLISECONDSSECONDSMINUTESHOURSDAYSMONTHSYEARSrrrrrrsrr dt.datetimecCsddl}|jS)Nr)datetimenow)dtrrr_now/s r/delta dt.timedeltacCs |jdkrt}|||S|S)zReturn an "absolute" value for a timedelta, always representing a time distance. Args: delta (datetime.timedelta): Input timedelta. Returns: datetime.timedelta: Absolute timedelta. r)daysr/)r0r-rrr_abs_timedelta5s  r3)r-preciserr r-dt.datetime | Noner4booltuple[Any, Any]c Csddl}|s t}t||jr|}||}n1t||jr#||}|}n$z|r(|nt|}|j|d}||}WnttfyFd|fYSw|t|fS)zTurn a value into a date and a timedelta which represents how long ago it was. If that's not possible, return `(None, value)`. rNseconds)r,r/ isinstance timedeltaround ValueError TypeErrorr3)rr-r4r.dater0rrr_date_and_deltaDs"       r@Tr9dt.timedelta | floatmonths minimum_unitstrc Cslddl}t|}|tjtjtjfvrd|d}t||}t||jr)|}n zt |t |}|j|d}Wntt fyHt |YSw|}t |}|jd} |jd} t| d} | dkr| dkr|jdkr|tjkr|jd krtd d |j|jS|tjks|tjkrd |jkrd krntdS|jd } td dt | | StdS|jdkrtdS|jdkrtdd|j|jSd|jkrdkrnnt|jd} | dkrtdS| dkrtdStdd| | Sd|jkrt|jd}|dkr tdS|dkrtdStdd||Sn| dkr[| dkr)tdS|s4tdd| | S| dkrAtdd| | S| dkrJtdS| d krStd!Std"d#| | S| dkr| dkrn| dkrntd!S| dkr{td$d%| | S|r| dkrtd&S| d kr| d7} td'd(| | Std)d*| | Std$d%| | Std'd(| d+d,t| S)-aReturn a natural representation of a timedelta or number of seconds. This is similar to `naturaltime`, but does not add tense to the result. The timedelta will be rounded to the nearest unit that makes sense. Args: value (datetime.timedelta, int or float): A timedelta or a number of seconds. months (bool): If `True`, then a number of months (based on 30.5 days) will be used for fuzziness between years. minimum_unit (str): The lowest unit that can be used. Returns: str (str or `value`): A natural representation of the amount of time elapsed unless `value` is not datetime.timedelta or cannot be converted to int (cannot be float due to 'inf' or 'nan'). In that case, a `value` is returned unchanged. Raises: OverflowError: If `value` is too large to convert to datetime.timedelta. Examples: Compare two timestamps in a custom local timezone:: ```pycon >>> import datetime as dt >>> from dateutil.tz import gettz >>> berlin = gettz("Europe/Berlin") >>> now = dt.datetime.now(tz=berlin) >>> later = now + dt.timedelta(minutes=30) >>> assert naturaldelta(later - now) == "30 minutes" True ``` rNzMinimum unit 'z' not supportedr8m>@r%d microsecond%d microsecondsi@B%d millisecond%d millisecondsa momentza second< %d second %d secondsza minutezan hour %d minute %d minutesza day%d hour%d hours%d day%d daysza month za year%d month %d monthsz1 year, %d dayz1 year, %d daysz1 year, 1 month%d year%d yearsz1 year, %d monthz1 year, %d months%d%s)r,rupperr%r$r#r=r:r;intfloatr>rDabsr2r<r9 microsecondsr_replacer)rrBrCr.tmpmsgmin_unitr0 use_monthsyearsr2 num_months millisecondsminuteshoursrrrr _s*          "               r "dt.datetime | dt.timedelta | floatfuturewhenc Csddl}t|}t|}|pt}t||d\}}|dur!t|St||j|jfr.||k}|r4tdntd} t|||}|tdkrHtdSt| |S)a+Return a natural representation of a time in a resolution that makes sense. This is more or less compatible with Django's `naturaltime` filter. The time will be rounded to the nearest unit that makes sense. Args: value (datetime.datetime, datetime.timedelta, int or float): A `datetime`, a `timedelta`, or a number of seconds. future (bool): Ignored for `datetime`s and `timedelta`s, where the tense is always figured out based on the current time. For integers and floats, the return value will be past tense by default, unless future is `True`. months (bool): If `True`, then a number of months (based on 30.5 days) will be used for fuzziness between years. minimum_unit (str): The lowest unit that can be used. when (datetime.datetime): Point in time relative to which _value_ is interpreted. Defaults to the current time in the local timezone. Returns: str: A natural representation of the input in a resolution that makes sense. rN)r-z %s from nowz%s agorLr-) r,_convert_aware_datetimer/r@rDr:r;rdr ) rrprBrCrqr.r-r?r0agorrrrs    r)dt.datetime | dt.timedelta | float | NonecCs2ddl}t||jr|jdur|j|}|S)zIConvert aware datetime to naive datetime and pass through any other type.rN)r,r:tzinfo fromtimestamp timestamp)rr.rrrrr,srr%b %ddt.date | dt.datetimeformatc Csddl}z ||j|j|j}Wntyt|YSttfy+t|YSw||j }|j dkr>> from humanize.time import _quotient_and_remainder, Unit >>> _quotient_and_remainder(36, 24, Unit.DAYS, Unit.DAYS, [], "%0.2f") (1.5, 0) If `unit` is in `suppress`, the quotient will be zero and the remainder will be the initial value. The idea is that if we cannot use `unit`, we are forced to use a lower unit, so we cannot do the division. >>> _quotient_and_remainder(36, 24, Unit.DAYS, Unit.HOURS, [Unit.DAYS], "%0.2f") (0, 36) In other cases, return the quotient and remainder as `divmod` would do it. >>> _quotient_and_remainder(36, 24, Unit.DAYS, Unit.HOURS, [], "%0.2f") (1, 12) r)_rounding_by_fmtdivmodr`)rrrrCrrzqrrrr_quotient_and_remainderis   rrhcCs:||vrtD]}||kr||vr|Sqd}t||S)aReturn a minimum unit suitable that is not suppressed. If not suppressed, return the same unit: >>> from humanize.time import _suitable_minimum_unit, Unit >>> _suitable_minimum_unit(Unit.HOURS, []).name 'HOURS' But if suppressed, find a unit greater than the original one that is not suppressed: >>> _suitable_minimum_unit(Unit.HOURS, [Unit.HOURS]).name 'DAYS' >>> _suitable_minimum_unit(Unit.HOURS, [Unit.HOURS, Unit.DAYS]).name 'MONTHS' z@Minimum unit is suppressed and no suitable replacement was found)rr=)rhrrrgrrr_suitable_minimum_unitsr set[Unit]cCs.t|}tD]}||kr|S||q|S)aExtend suppressed units (if any) with all units lower than the minimum unit. >>> from humanize.time import _suppress_lower_units, Unit >>> [x.name for x in sorted(_suppress_lower_units(Unit.SECONDS, [Unit.DAYS]))] ['MICROSECONDS', 'MILLISECONDS', 'DAYS'] )setradd)rhrrrrr_suppress_lower_unitss rr%0.2fdt.timedelta | float | None Iterable[str]c$ Cst|dd\}}|durt|Sdd|D}t|}t||}~t||}|j}|j} |j} t t\} } } }}}}}t |d||||\}}t |d||||\}}|dd | } t | d ||||\}} t | d ||||\}} t | d ||||\}} | d | } t | d | |||\} } t | d | |||\}} |d kr| |vr|d 8}| d7} | d kr||vr| d 8} |d7}|d kr||vr|d 8}|d7}|dkr||vr|d8}|d7}|dkr||vr|d8}|d7}|dkr||vr|d8}|d7}dd|fdd|fdd|fdd|fdd|fdd| fdd|fdd | fg}g}t t t|D]}\}}|\}}}|d!ks9|s||krd|krEd"krInnd"nt |}t|||} d!dl}!||krm|!|d!d!krm| d#|} n$||kr|!|d!d!krt |}| d#d$} || t|q#|| |||krnq#t|dkr|d!Sd%|dd&}"|d&}#td'|"|#fS)(a:Return a precise representation of a timedelta or number of seconds. ```pycon >>> import datetime as dt >>> from humanize.time import precisedelta >>> delta = dt.timedelta(seconds=3633, days=2, microseconds=123000) >>> precisedelta(delta) '2 days, 1 hour and 33.12 seconds' ``` A custom `format` can be specified to control how the fractional part is represented: ```pycon >>> precisedelta(delta, format="%0.4f") '2 days, 1 hour and 33.1230 seconds' ``` Instead, the `minimum_unit` can be changed to have a better resolution; the function will still readjust the unit to use the greatest of the units that does not lose precision. For example setting microseconds but still representing the date with milliseconds: ```pycon >>> precisedelta(delta, minimum_unit="microseconds") '2 days, 1 hour, 33 seconds and 123 milliseconds' ``` If desired, some units can be suppressed: you will not see them represented and the time of the other units will be adjusted to keep representing the same timedelta: ```pycon >>> precisedelta(delta, suppress=['days']) '49 hours and 33.12 seconds' ``` Note that microseconds precision is lost if the seconds and all the units below are suppressed: ```pycon >>> delta = dt.timedelta(seconds=90, microseconds=100) >>> precisedelta(delta, suppress=['seconds', 'milliseconds', 'microseconds']) '1.50 minutes' ``` If the delta is too small to be represented with the minimum unit, a value of zero will be returned: ```pycon >>> delta = dt.timedelta(seconds=1) >>> precisedelta(delta, minimum_unit="minutes") '0.02 minutes' >>> delta = dt.timedelta(seconds=0.1) >>> precisedelta(delta, minimum_unit="minutes") '0 minutes' ``` T)r4NcSsh|]}t|qSr)rr_).0srrr szprecisedelta..rErFrSrPiQrMg.ArGrrXr[r\rYrZrVrWrTrUrQrRrNrOrJrKrHrIrrr]r^z, r}z %s and %s)r@rDrr_rrr2r9rclistrzipreversedr`rmathmodfreappendrlenjoinrd)$rrCrrzr?r0 suppress_setrhr2secsusecsr#r$r%r&r'r(r)r*rjrBrnrmmsecsfmtstextsrfmt singular_txt plural_txt fmt_value _fmt_valuefmt_txtrheadtailrrrrsH             (    r float | intcCs4||}zt|}W|Styt|}Y|Sw)alRound a number according to the string format provided. The string format is the old printf-style string formatting. If we are using a format which truncates the value, such as "%d" or "%i", the returned value will be of type `int`. If we are using a format which rounds the value, such as "%.2f" or even "%.0f", we will return a float. )r`r=ra)rzrresultrrrrs   r)rr+)r0r1rr1)rr r-r5r4r6rr7)Tr9)rrArBr6rCrDrrD)FTr9N) rrorpr6rBr6rCrDrqr5rrD)rrtrr )rx)rryrzrDrrD)rryrrD)rrarrarrrCrrrrzrDrr)rhrrrrr)rhrrrrr)r9rr) rrrCrDrrrzrDrrD)rzrDrrarr)#__doc__ __future__renumr functoolsri18nrrdrnumberr TYPE_CHECKINGr,r.collections.abcr typingr __all__rr/r3r@r rrrr r rrrrrrrrrsP             3  -  L