o ȕhJ@s6dZddlmZddlmZddlmZddlmZ ddlm Z ddl m Z d Z e r:dd lZdd lmZdd lmZgd ZeGdddeZdQddZdRddZd ddSddZ !dTdUd'd(Z ! dVdWd,d-ZdXd/d0ZdYdZd4d5Zd[d6d7Zd\d>d?Zd]dDdEZd^dFdGZ d_dIdJZ! ! K Ld`dadOdPZ"d S)bzYTime 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)selfrrJ/var/www/Befach/backend/venv/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  r3r-rr r-dt.datetime | Nonetuple[Any, Any]c Csddl}|s t}t||jr|}||}n-t||jr#||}|}n zt|}|j|d}||}WnttfyBd|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 timedeltaint ValueError TypeErrorr3)rr-r.dater0rrr_date_and_deltaDs"       r?Tr8dt.timedelta | floatmonthsbool minimum_unitstrc Csddl}t|}|tjtjtjfvrd|d}t||}t||jr)|}n zt |t |}|j|d}Wntt fyHt |YSw|}t |}|jd} |jd} t | d} | s| dkr|jdkr|tjkr|jd krtd d |j|jS|tjks|tjkrd |jkrd krntdS|jd } td dt | | StdS|jdkrtdS|jdkrtdd|j|jSd|jkrdkrtdSd|jkrdkrnn |jd} tdd| | Sd|jkrdkrtdSd|jkr|jd}tdd||Snk| dkrF| dkrtdS|s*tdd| | S| s5tdd| | S| dkr>td Std!d"| | S| dkr|| sU| sUtd#S| s`td$d%| | S|rt| dkrltd&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. 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 supportedr7m>@r%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)r,rupperr%r$r#r<r9r:r;floatr=rDabsr2r8 microsecondsr_replacer)rrArCr.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)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. rNr4z %s from nowz%s agorLr-) r,_convert_aware_datetimer/r?rDr9r:rbr ) rrnrArCror.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,r9tzinfo fromtimestamp timestamp)rr.rrrrpsrp%b %ddt.date | dt.datetimeformatc Csddl}z ||j|j|j}Wntyt|YSttfy+t|YSw||j }|j dkryearmonthdayAttributeErrorrD OverflowErrorr<ryr2rbstrftime)rrxr.r0rrrr $s        r c Csddl}z ||j|j|j}Wntyt|YSttfy+t|YSwt ||j }|j dkr?t |dSt |S)zKLike `naturalday`, but append a year for dates more than ~five months away.rNgc@z%b %d %Y) r,r>r}r~rrrDrr<r3ryr2r )rr.r0rrrr Ds     r r_divisorunitsuppressIterable[Unit]tuple[float, float]cCs.||kr ||dfS||vrd|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)rrrrCrrrr_quotient_and_remainderVs   rvalue1value2ratiorfcCs8||kr |||dfS||vrd|||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)rrrrrfrrrr_carry~s rcCs:||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<)rfrrrerrr_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)rfrrrrr_suppress_lower_unitss rr%0.2fdt.timedelta | int | None Iterable[str]c% Cst|\}}|durt|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]h\}}|\}}}|d ks|s||krd |krdkrnndnt|} t||| }!d dl}"||kr|"|d d kr|!d|}!n||kr|!dd}!||!t|q||!|||kr!nqt|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)rr^).0srrr szprecisedelta..rErFiQrQrMg.ArGrrrZr[rXrYrVrWrTrUrRrSrNrOrJrKrHrIrr\r]z, r{z %s and %s)r?rDrr^rrr2r8ralistrrzipreversedr;rmathmodfrcappendrlenjoinrb)%rrCrrxr>r0 suppress_setrfr2secsusecsr#r$r%r&r'r(r)r*rhrArlrkmsecs_unusedfmtstextsrfmt singular_txt plural_txt fmt_value _fmt_valuefmt_txtrheadtailrrrrsn H      $    r)rr+)r0r1rr1)rr r-r5rr6)Tr8)rr@rArBrCrDrrD)FTr8N) rrmrnrBrArBrCrDror5rrD)rrrrr )rv)rrwrxrDrrD)rrwrrD) rr_rr_rrrCrrrrr)rr_rr_rr_rrrfrrrrr)rfrrrrr)rfrrrrr)r8rr) rrrCrDrrrxrDrrD)#__doc__ __future__renumr functoolsri18nrrbrnumberr TYPE_CHECKINGr,r.collections.abcr typingr __all__rr/r3r?r rrpr r rrrrrrrrrsL             1  ( '