U dSG@sdZddlmZddlZddlZddlZddlZddl m Z ddl m Z ddl mZddl mZdd lmZd d d d dgZe Gddde ZddddZdddddZddddddddZdGd"d#d$d$d%d&d ZdHd(d#d#d$dd$d)d*d ZdId,d$d$d-d.d Zd,d$d/d0d Zd1d1ddd2d3d4d5d6Zd1d1d1ddd7d3d8d9d:Zdd7dd;dd;d?d@ZdJdCd$dDd$d$dEdFdZ dS)KzYTime humanizing functions. These are largely borrowed from Django's `contrib.humanize`. ) annotationsN)Enum)total_ordering)_gettext) _ngettext)intcomma naturaldelta naturaltime naturalday naturaldate precisedeltac@s<eZdZdZdZdZdZdZdZdZ dZ d d d d d Z d S)Unitrr typing.Any)otherreturncCs|j|jkr|j|jkStSN) __class__valueNotImplemented)selfrr1/tmp/pip-unpacked-wheel-kd4adnh7/humanize/time.py__lt__(s  z Unit.__lt__N) __name__ __module__ __qualname__ MICROSECONDS MILLISECONDSSECONDSMINUTESHOURSDAYSMONTHSYEARSrrrrrrsrz dt.datetime)rcCs tjSr)dtdatetimenowrrrr_now.sr.z dt.timedelta)deltarcCs |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.)r/r-rrr_abs_timedelta2s  r1r-rzdt.datetime | Noneztuple[typing.Any, typing.Any])rr-rc Cs|s t}t|tjr$|}||}n\t|tjr>||}|}nBz t|}tj|d}||}Wn ttfk r~d|fYSX|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)`. secondsN) r. isinstancer+r, timedeltaint ValueError TypeErrorr1)rr-dater/rrr_date_and_deltaAs     r;Tr4zdt.timedelta | floatboolstr)rmonths minimum_unitrc Cst|}|tjtjtjfkr4d|d}t||}t|tjrJ|}n:zt |}tj|d}Wn tt fk rt |YSX|}t |j }t |j} | d} | d} t | d} | s"| dkr"|dkrV|tjkr|jdkrtd d |j|jS|tjks0|tjkrNd|jkr,d krNnn|jd} td d t | | StdS|dkrhtdS|dkrtdd||Sd|krdkrnntdSd|krdkrnn|d} tdd| | Sd|krdkrnntdSd|kr|d}tdd||Sn| dkr| dkr>tdS|sTtdd| | S| sjtdd| | S| dkr|tdStd d!| | S| dkr| s| std"S| std#d$| | S|r| dkrtd%Std&d'| | Std#d$| | Std(d)| d*d+t| S),aTReturn a natural representation of a timedelta or number of seconds. This is similar to `naturaltime`, but does not add tense to the result. 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. 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:: 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" zMinimum unit 'z' not supportedr3m>@rr%d microsecond%d microsecondsi@B%d millisecond%d millisecondsa momentza second< %d second %d secondsxza minute %d minute %d minutesi zan hour%d hour%d hoursza day%d day%d daysza month%d month %d monthsza yearz1 year, %d dayz1 year, %d daysz1 year, 1 monthz1 year, %d monthz1 year, %d months%d year%d years%d%s)rupperr%r$r#r8r5r+r6r7r9r=absr4r0 microsecondsr_replacer)rr>r?tmpmsgmin_unitr/Z use_monthsr4r0yearsZ num_monthsZ millisecondsminuteshoursrrrr Zs#                      Fz"dt.datetime | dt.timedelta | float)rfuturer>r?whenrc Cs|pt}t||d\}}|dkr*t|St|tjtjfrD||k}|rPtdntd}t|||}|tdkrxtdSt||S)aReturn a natural representation of a time in a resolution that makes sense. This is more or less compatible with Django's `naturaltime` filter. 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. r2Nz %s from nowz%s agorGr-) r.r;r=r5r+r,r6r\r ) rrdr>r?rer-r:r/Zagorrrr s   %b %dzdt.date | dt.datetime)rformatrc Cszt|j|j|j}Wn:tk r4t|YSttfk rRt|YSX|tj }|j dkrtt dS|j dkrt dS|j dkrt dS| |S)zReturn a natural day. For date values that are tomorrow, today or yesterday compared to present day return representing string. Otherwise, return a string formatted according to `format`. rtodayrZtomorrowZ yesterday) r+r:yearmonthdayAttributeErrorr= OverflowErrorr8rhr0r\strftime)rrgr/rrrr s    )rrc Cszt|j|j|j}Wn:tk r4t|YSttfk rRt|YSXt |tj }|j dkrzt |dSt |S)zKLike `naturalday`, but append a year for dates more than ~five months away.gc@z%b %d %Y) r+r:rjrkrlrmr=rnr8r1rhr0r )rr/rrrr 's   floatzcollections.abc.Iterable[Unit]ztuple[float, float])rdivisorunitr?suppressrcCs.||kr||dfS||kr$d|fSt||S)aDivide `value` by `divisor` returning the quotient and remainder. If `unit` is `minimum_unit`, makes the quotient a float number and the remainder will be zero. The rational is that if `unit` is the unit of the quotient, we cannot represent the remainder because it would require a unit smaller than the `minimum_unit`. >>> from humanize.time import _quotient_and_remainder, Unit >>> _quotient_and_remainder(36, 24, Unit.DAYS, Unit.DAYS, []) (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, 36) In other case return quotient and remainder as `divmod` would do it. >>> _quotient_and_remainder(36, 24, Unit.DAYS, Unit.HOURS, []) (1, 12) r)divmod)rrqrrr?rsrrr_quotient_and_remainder7s  ruztyping.Iterable[Unit])value1value2ratiorrr`rsrcCs8||kr|||dfS||kr0d|||fS||fS)aReturn a tuple with two values. If the unit is in `suppress`, multiply `value1` by `ratio` and add it to `value2` (carry to right). The idea is that if we cannot represent `value1` we need to represent it in a lower unit. >>> from humanize.time import _carry, Unit >>> _carry(2, 6, 24, Unit.DAYS, Unit.SECONDS, [Unit.DAYS]) (0, 54) If the unit is the minimum unit, `value2` is divided by `ratio` and added to `value1` (carry to left). We assume that `value2` has a lower unit so we need to carry it to `value1`. >>> _carry(2, 6, 24, Unit.DAYS, Unit.DAYS, []) (2.25, 0) Otherwise, just return the same input: >>> _carry(2, 6, 24, Unit.DAYS, Unit.SECONDS, []) (2, 6) rr)rvrwrxrrr`rsrrr_carry_s ry)r`rsrcCs:||kr6tD]}||kr ||kr |Sq d}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)rr8)r`rsrrr_rrr_suitable_minimum_units rzz set[Unit]cCs,t|}tD]}||krq(||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)r`rsrrrrr_suppress_lower_unitss  r}r%0.2fzdt.timedelta | int | Noneztyping.Iterable[str])rr?rsrgrc# Csdt|\}}|dkrt|Sdd|D}t|}t||}~t||}|j}|j} |j} t t\} } } }}}}}t |d|||\}}t |d|||\}}t || d|||\}} t | d|||\}} t | d|||\}} t | | d | ||\} } t | d | ||\}} t | d d | ||\} }d d|fdd|fdd|fdd|fdd|fdd| fdd|fdd| fg}g}t t t|D]\}}|\}}}|d ks|s||krt|||} ||krt|d d kr| d|} n,||kr| dd} || t|qr|| |||krrq$qrt|d kr:|d Sd|dd }!|d }"td!|!|"fS)"a%Return a precise representation of a timedelta. ```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' ``` NcSsh|]}t|qSr)rrY).0srrr szprecisedelta..r@rAiQrLrHg.ArBrrrUrVrSrTrQrRrOrPrMrNrIrJrErFrCrDrWrXz, riz %s and %s)r;r=rrYrzr}r0r4r[listruryzipreversedrmathmodfr]appendrlenjoinr\)#rr?rsrgr:r/Z suppress_setr`r0ZsecsZusecsr#r$r%r&r'r(r)r*rar>rcrbmsecsZ_unusedZfmtsZtextsrrfmtZ singular_txtZ plural_txtZ fmt_valueZfmt_txtheadtailrrrr spH           )Tr4)FTr4N)rf)r4rr~)!__doc__ __future__rcollections.abc collectionsr,r+rtypingenumr functoolsrZi18nrr\rnumberr__all__rr.r1r;r r r r ruryrzr}r rrrrsR       +('