}xifLdZddlZddlZddlZddlZddlZddlZddlZddlZddl m Z m Z ddl m Z ddlmZmZmZmZdZdZej*dd Zej*d d Zeed d dedddeedddedddeedddedddeeddd ed!d"d#eed$d%d&ed'd(d)eed*d+d,ed-d.d/eed0d1d2ed3d4d5eed6d7d8ed9d:d;fZeded?d@d?d?>edAdBdAdA>edCdDdEdF>edGd dGdG>fZed=dHdIdJgKedLdMdNdOgKed@dPdQdRgKedDdSdTgdUKedVdWdXgdYKedZd[d\d]gKed^d_d`dagKedbdcdddegKedfdgdhdigKf ZdjZddkZdlZddmZddnZ ddoZ!dpZ"ddqZ#ddrZ$ddsZ%dtZ&duZ'dvZ(dwZ)Gdxdye*Z+Gdzd{e,Z-Gd|d}e,Z.Gd~de,Z/Gdde,Z0e dide1ddddddddddddddddddddddddddddddddy)z/The main module of the `humanfriendly` package.N) is_string monotonic)define_aliases) concatenateformat pluralizetokenize) CombinedUnit InvalidDate InvalidLength InvalidSizeInvalidTimespanSizeUnitTimer __version__coerce_booleancoerce_patterncoerce_secondsdisk_size_units format_length format_number format_path format_sizeformat_timespanlength_size_units parse_date parse_length parse_path parse_sizeparse_timespan round_number time_unitsz10.0rzdivider, symbol, namer zdecimal, binaryiKBkilobyteiKiBkibibytei@BMBmegabyteiMiBmebibyteiʚ;GBgigabytei@GiBgibibytelJ)TBterabytelTiBtebibytelI5PBpetabytel PiBpebibytelNZoEBexabytelEiBexbibytel@=7M.cZB zettabytelZiBzebibytelB3v^!<YB yottabytel YiByobibytenmg& .>)prefixdividersingularpluralmmgMbP?cmg{Gz?mmetremetreskm nanosecond nanosecondsns)rErFrG abbreviationsgư> microsecond microsecondsus millisecond millisecondsmssecondseconds)ssecsecs<minuteminutes)rJminminsihourhourshiQdaydaysdi: weekweekswiyearyearsyct|r?|jj}|dvry|dvryd}tt ||t |S)a8 Coerce any value to a boolean. :param value: Any Python value. If the value is a string: - The strings '1', 'yes', 'true' and 'on' are coerced to :data:`True`. - The strings '0', 'no', 'false' and 'off' are coerced to :data:`False`. - Other strings raise an exception. Other Python values are coerced using :class:`bool`. :returns: A proper boolean value. :raises: :exc:`exceptions.ValueError` when the value is a string but cannot be coerced with certainty. )1yestrueonT)0nofalseoffFz(Failed to coerce string to boolean! (%r))rstriplower ValueErrorrbool)value normalizedmsgs ;/usr/lib/python3.12/site-packages/humanfriendly/__init__.pyrr[sY[[]((* 3 3 : :>> from humanfriendly import format_size >>> format_size(0) '0 bytes' >>> format_size(1) '1 byte' >>> format_size(5) '5 bytes' > format_size(1000) '1 KB' > format_size(1024, binary=True) '1 KiB' >>> format_size(1000 ** 3 * 4) '4 GB'  keep_widthbyte) reversedrbinaryrEr!floatrsymboldecimal) num_bytesrrunitnumbers rrrs8)  ++ +!% "2T[[5H5H"HU_`FVT[[%7%79K9KL L $,,.. .v!% "2T\\5I5I"IV`aFVT\\%8%8$,,:M:MN N * Y ''rct|}|rt|dtjrt |dk(r!t |dr|dj nd}t |dk(s|jdrt|dS|rM|jd}tD]2}||jjj |jjj fvr't|d|jjzcS||jjj |jjj fvs7|j|jjdj st|d|r|jjn|jjzcSd}t!t#|||)a Parse a human readable data size and return the number of bytes. :param size: The human readable file size to parse (a string). :param binary: :data:`True` to use binary multiples of bytes (base-2) for ambiguous unit symbols and names, :data:`False` to use decimal multiples of bytes (base-10). :returns: The corresponding size in bytes (an integer). :raises: :exc:`InvalidSize` when the input can't be parsed. This function knows how to parse sizes in bytes, kilobytes, megabytes, gigabytes, terabytes and petabytes. Some examples: >>> from humanfriendly import parse_size >>> parse_size('42') 42 >>> parse_size('13b') 13 >>> parse_size('5 bytes') 5 >>> parse_size('1 KB') 1000 >>> parse_size('1 kilobyte') 1000 >>> parse_size('1 KiB') 1024 >>> parse_size('1 KB', binary=True) 1024 >>> parse_size('1.5 GB') 1500000000 >>> parse_size('1.5 GB', binary=True) 1610612736 rrKrxbr[z4Failed to parse size! (input %r was tokenized as %r))r rrrlenrrz startswithintrstriprrrnamerErr r)sizertokensnormalized_unitrrs rrrsDd^F *VAY7/26{a/?IfUViDX&)//+^` v;! 99#>vay> ! .44S9O'#t{{'9'9'?'?'A4;;CSCSCYCYC[&\\vay4;;+>+>>??$ (;(;(A(A(CT\\EVEVE\E\E^'__'224<<3F3Fq3I3O3O3QRvay6DKK,?,?t||OcOcdee( AC fS$/ 00rcttD];}||dk\s tt||dz |}t ||d|dcSt |dS)a Format a metre count as a human readable length. :param num_metres: The length to format in metres (float / integer). :param keep_width: :data:`True` if trailing zeros should not be stripped, :data:`False` if they can be stripped. :returns: The corresponding human readable length (a string). This function supports ranges from nanometres to kilometres. Some examples: >>> from humanfriendly import format_length >>> format_length(0) '0 metres' >>> format_length(1) '1 metre' >>> format_length(5) '5 metres' >>> format_length(1000) '1 km' >>> format_length(0.004) '4 mm' rErrFrGrL)rrr!rr) num_metresrrrs rrrsb2*+ i (!% "3d9o"ER\]FVT*%5tH~F F, Z ))rcbt|}|rt|dtjrnt |dk(r|dSt |dk(rMt |dr?|dj }tD]#}|j|ds|d|dzcSd}tt|||)a Parse a human readable length and return the number of metres. :param length: The human readable length to parse (a string). :returns: The corresponding length in metres (a float). :raises: :exc:`InvalidLength` when the input can't be parsed. Some examples: >>> from humanfriendly import parse_length >>> parse_length('42') 42 >>> parse_length('1 km') 1000 >>> parse_length('5mm') 0.005 >>> parse_length('15.3cm') 0.153 rrKrrDrEz6Failed to parse length! (input %r was tokenized as %r)) r rrrrrrzrrr r)lengthrrrrs rrr&s(f F *VAY7 v;! !9  v;!  &) 4$Qioo/O)"--d8n=!!9tI66* CC sFF3 44rctt|jd\}}}|jd}dj t |j d}g}|r|j|dd|dd}|rdj t dj |}|d|jd} | r|d| zz }|rd|z}|S)aU Format a number as a string including thousands separators. :param number: The number to format (a number like an :class:`int`, :class:`long` or :class:`float`). :param num_decimals: The number of decimals to render (2 by default). If no decimal places are required to represent the number they will be omitted regardless of this argument. :returns: The formatted number (a string). This function is intended to make it easier to recognize the order of size of the number being formatted. Here's an example: >>> from humanfriendly import format_number >>> print(format_number(6000000)) 6,000,000 > print(format_number(6000000000.42)) 6,000,000,000.42 > print(format_number(6000000000.42, num_decimals=0)) 6,000,000,000 .-rxN,rt) strr partitionrjoinrlstripappendr) r num_decimals integer_part_ decimal_part negative_signreversed_digitspartsformatted_numberdecimals_to_adds rrrKs0%(f $6$@$@$E!L!\ ++C0Mggh|':':3'?@AO E  _Ra())!"- wwx89"=L188=OC/11!11 rcdt|z}|s.tjdd|}tjdd|}|S)a Round a floating point number to two decimal places in a human friendly format. :param count: The number to format. :param keep_width: :data:`True` if trailing zeros should not be stripped, :data:`False` if they can be stripped. :returns: The formatted number as a string. If no decimal places are required to represent the number, they will be omitted. The main purpose of this function is to be used by functions like :func:`format_length()`, :func:`format_size()` and :func:`format_timespan()`. Here are some examples: >>> from humanfriendly import round_number >>> round_number(1) '1' >>> round_number(math.pi) '3.14' >>> round_number(5.001) '5' z%.2fz0+$rxz\.$)rrsub)countrtexts rr!r!ss>0 E%L D vveR&vvfb$' Krc t|}|dkr|stt|dSg}tjt |}t tt|rdndd}|D]s}tjt |d}||z }||z}||dk7r t|}n t|}|dvsR|jt||d |d ut|d k(r|dS|s|d|}t|S) a Format a timespan in seconds as a human readable string. :param num_seconds: Any value accepted by :func:`coerce_seconds()`. :param detailed: If :data:`True` milliseconds are represented separately instead of being represented as fractional seconds (defaults to :data:`False`). :param max_units: The maximum number of units to show in the formatted time span (an integer, defaults to three). :returns: The formatted timespan as a string. :raise: See :func:`coerce_seconds()`. Some examples: >>> from humanfriendly import format_timespan >>> format_timespan(0) '0 seconds' >>> format_timespan(1) '1 second' >>> import math >>> format_timespan(math.pi) '3.14 seconds' >>> hour = 60 * 60 >>> day = hour * 24 >>> week = day * 7 >>> format_timespan(week * 52 + day * 2 + hour * 3) '1 year, 2 days and 3 hours' r^rYrrNrE)rrtrFrGrK) rrr!rDecimalrlistrr"rrrr) num_secondsdetailed max_unitsresultrelevant_unitsrrErs rrrs:!-KRk2H==ooc+&67 hzx!Q2G'HIJ"Dooc$y/&:;G')E 7 "K~b))E %U+H$ itJ/?hPQ# v;! !9  +v& &rct|}|rt|dtjrt |dk(rt |dSt |dk(rYt |drK|dj}tD]/}||dk(s||dk(s||dvst |d|dzcSd}tt|||) a Parse a "human friendly" timespan into the number of seconds. :param value: A string like ``5h`` (5 hours), ``10m`` (10 minutes) or ``42s`` (42 seconds). :returns: The number of seconds as a floating point number. :raises: :exc:`InvalidTimespan` when the input can't be parsed. Note that the :func:`parse_timespan()` function is not meant to be the "mirror image" of the :func:`format_timespan()` function. Instead it's meant to allow humans to easily and succinctly specify a timespan with a minimal amount of typing. It's very useful to accept easy to write time spans as e.g. command line arguments to programs. The time units (and abbreviations) supported by this function are: - ms, millisecond, milliseconds - s, sec, secs, second, seconds - m, min, mins, minute, minutes - h, hour, hours - d, day, days - w, week, weeks - y, year, years Some examples: >>> from humanfriendly import parse_timespan >>> parse_timespan('42') 42.0 >>> parse_timespan('42s') 42.0 >>> parse_timespan('1m') 60.0 >>> parse_timespan('1h') 3600.0 >>> parse_timespan('1d') 86400.0 rrKrrFrGrRrEz8Failed to parse timespan! (input %r was tokenized as %r)) r rrrrrrrzr"rr)timespanrrrrs rr r sNh F *VAY7 v;! # # v;!  &) 4$Qioo/O"#tJ'77'4>9'4+@@ +d9o== # EC &h7 88rc( |jDcgc]}|j}}t|dk\rttt t |djdddgz}tt t |djdgdz}t |dd|ddzStt t |jdddgzdd\}}}|||dddfScc}w#t$rd}tt||wxYw) a3 Parse a date/time string into a tuple of integers. :param datestring: The date/time string to parse. :returns: A tuple with the numbers ``(year, month, day, hour, minute, second)`` (all numbers are integers). :raises: :exc:`InvalidDate` when the date cannot be parsed. Supported date/time formats: - ``YYYY-MM-DD`` - ``YYYY-MM-DD HH:MM:SS`` .. note:: If you want to parse date/time strings with a fixed, known format and :func:`parse_date()` isn't useful to you, consider :func:`time.strptime()` or :meth:`datetime.datetime.strptime()`, both of which are included in the Python standard library. Alternatively for more complex tasks consider using the date/time parsing module in the dateutil_ package. Examples: >>> from humanfriendly import parse_date >>> parse_date('2013-06-17') (2013, 6, 17, 0, 0, 0) >>> parse_date('2013-06-17 02:47:42') (2013, 6, 17, 2, 47, 42) Here's how you convert the result to a number (`Unix time`_): >>> from humanfriendly import parse_date >>> from time import mktime >>> mktime(parse_date('2013-06-17 02:47:42') + (-1, -1, -1)) 1371430062.0 And here's how you convert it to a :class:`datetime.datetime` object: >>> from humanfriendly import parse_date >>> from datetime import datetime >>> datetime(*parse_date('2013-06-17 02:47:42')) datetime.datetime(2013, 6, 17, 2, 47, 42) Here's an example that combines :func:`format_timespan()` and :func:`parse_date()` to calculate a human friendly timespan since a given date: >>> from humanfriendly import format_timespan, parse_date >>> from time import mktime, time >>> unix_time = mktime(parse_date('2013-06-17 02:47:42') + (-1, -1, -1)) >>> seconds_since_then = time() - unix_time >>> print(format_timespan(seconds_since_then)) 1 year, 43 weeks and 1 day .. _dateutil: https://dateutil.readthedocs.io/en/latest/parser.html .. _Unix time: http://en.wikipedia.org/wiki/Unix_time rrrrK:)rrrrzJInvalid date! (expected 'YYYY-MM-DD' or 'YYYY-MM-DD HH:MM:SS' but got: %r)) splitryrrmaprtuple Exceptionr r) datestringtr date_parts time_partsrlmonthrfrs rrr sr 3%/%5%5%78%7!'')%78 v;! c#vays';<=AFJc#vays';<= IJAa:a?:; ; $Sj.>.>s.C%D EA NPQRST D%%aA. .9 3Z&j1223s"C0C+BC0/;C0+C00!Dcbtjj|}tjj d}|rntjj|}|j |r>tjj dtjj||}|S)a Shorten a pathname to make it more human friendly. :param pathname: An absolute pathname (a string). :returns: The pathname with the user's home directory abbreviated. Given an absolute pathname, this function abbreviates the user's home directory to ``~/`` in order to shorten the pathname without losing information. It is not an error if the pathname is not relative to the current user's home directory. Here's an example of its usage: >>> from os import environ >>> from os.path import join >>> vimrc = join(environ['HOME'], '.vimrc') >>> vimrc '/home/peter/.vimrc' >>> from humanfriendly import format_path >>> format_path(vimrc) '~/.vimrc' HOME~)ospathabspathenvirongetrrrelpath)pathnamehomes rrrRss.wwx(H ::>>& !D wwt$   t $ww||C4)HIH Orctjjtjjtjj |S)a~ Convert a human friendly pathname to an absolute pathname. Expands leading tildes using :func:`os.path.expanduser()` and environment variables using :func:`os.path.expandvars()` and makes the resulting pathname absolute using :func:`os.path.abspath()`. :param pathname: A human friendly pathname (a string). :returns: An absolute pathname (a string). )rrr expanduser expandvars)rs rrrrs5 77??277--bgg.@.@.JK LLrcReZdZdZd dZdZd dZdZedZ edZ d Z y) rzD Easy to use timer to keep track of long during operations. Nc|rd|_d|_d|_d|_y|rd|_d|_||_yd|_d|_t|_y)a Remember the time when the :class:`Timer` was created. :param start_time: The start time (a float, defaults to the current time). :param resumable: Create a resumable timer (defaults to :data:`False`). When `start_time` is given :class:`Timer` uses :func:`time.time()` as a clock source, otherwise it uses :func:`humanfriendly.compat.monotonic()`. TFN)r resumable start_time total_time)selfrrs r__init__zTimer.__init__sR !DN!DN!DO!DO "DN"DN(DO!DN"DN'kDOrcR|js tdt|_|S)z Start or resume counting elapsed time. :returns: The :class:`Timer` object. :raises: :exc:`~exceptions.ValueError` when the timer isn't resumable. Timer is not resumable!)rr{rrrs r __enter__zTimer.__enter__s%~~67 7#+ rc|js td|jr2|xjt |jz z c_d|_yy)z} Stop counting elapsed time. :raises: :exc:`~exceptions.ValueError` when the timer isn't resumable. rrN)rr{rrr)rexc_type exc_value tracebacks r__exit__zTimer.__exit__sC ~~67 7 ?? OOy{T__< > DOO +L ??*...9;diikL L4??: :Lrc>tt|jS)z6Human readable timespan rounded to seconds (a string).)rroundrrs rroundedz Timer.roundedsuT%6%6788rc,t|jS)z;Show the elapsed time since the :class:`Timer` was created.)rrrs r__str__z Timer.__str__st0011r)NF)NNN) __name__ __module__ __qualname____doc__rrrrpropertyrrrrrrrsH*0  "84  992rrceZdZdZy)r a Raised when a string cannot be parsed into a date. For example: >>> from humanfriendly import parse_date >>> parse_date('2013-06-XY') Traceback (most recent call last): File "humanfriendly.py", line 206, in parse_date raise InvalidDate(format(msg, datestring)) humanfriendly.InvalidDate: Invalid date! (expected 'YYYY-MM-DD' or 'YYYY-MM-DD HH:MM:SS' but got: '2013-06-XY') Nrrrrrrrr r  rr ceZdZdZy)r a Raised when a string cannot be parsed into a file size. For example: >>> from humanfriendly import parse_size >>> parse_size('5 Z') Traceback (most recent call last): File "humanfriendly/__init__.py", line 267, in parse_size raise InvalidSize(format(msg, size, tokens)) humanfriendly.InvalidSize: Failed to parse size! (input '5 Z' was tokenized as [5, 'Z']) Nr rrrr r r rr ceZdZdZy)r a Raised when a string cannot be parsed into a length. For example: >>> from humanfriendly import parse_length >>> parse_length('5 Z') Traceback (most recent call last): File "humanfriendly/__init__.py", line 267, in parse_length raise InvalidLength(format(msg, length, tokens)) humanfriendly.InvalidLength: Failed to parse length! (input '5 Z' was tokenized as [5, 'Z']) Nr rrrr r r rr ceZdZdZy)ra Raised when a string cannot be parsed into a timespan. For example: >>> from humanfriendly import parse_timespan >>> parse_timespan('1 age') Traceback (most recent call last): File "humanfriendly/__init__.py", line 419, in parse_timespan raise InvalidTimespan(format(msg, timespan, tokens)) humanfriendly.InvalidTimespan: Failed to parse timespan! (input '1 age' was tokenized as [1, 'age']) Nr rrrrrr rr module_name format_tablez(humanfriendly.tables.format_pretty_tablecompactzhumanfriendly.text.compactrzhumanfriendly.text.concatenatededentzhumanfriendly.text.dedentrzhumanfriendly.text.format is_empty_linez humanfriendly.text.is_empty_linerzhumanfriendly.text.pluralizer zhumanfriendly.text.tokenizetrim_empty_linesz#humanfriendly.text.trim_empty_linesprompt_for_choicez'humanfriendly.prompts.prompt_for_choiceAutomaticSpinnerz0humanfriendly.terminal.spinners.AutomaticSpinnerSpinnerz'humanfriendly.terminal.spinners.Spinnererase_line_codez&humanfriendly.terminal.ANSI_ERASE_LINEhide_cursor_codez'humanfriendly.terminal.ANSI_SHOW_CURSORminimum_spinner_intervalz0humanfriendly.terminal.spinners.MINIMUM_INTERVALshow_cursor_codez'humanfriendly.terminal.ANSI_HIDE_CURSOR)r)FF)F)r)Frr)2r collectionsrrrros.pathrrhumanfriendly.compatrrhumanfriendly.deprecationrhumanfriendly.textrrrr __all__r namedtuplerr rdictrr"rrrrrrrrr!rr rrrobjectrrr r r rrrrrr%s6  64GG :  "; ! !*.E F%{%%n6GH '44hwz6Z['44hwz6Z['44hwz6Z['44hwz6Z['44hwz6Z['43Xguj5YZ'45xPZ7[\'45xPZ7[\ utDQutDQutDQa'(Std4P R4,}]a\bc4-_c^de4-_c^de1x Qef2Rfg7VGTWSXY<%WZV[\+fW]`\ab06'beafgi 8,&#(L=1@*@"5J%P>='@69rD3N@ Md2Fd2N )  )  I  i " <  )1 ' '5- +!";#(@)0H12 634=56?78P9:?;r