.Ph1dZddlZddlmZgdZejdZdZdZdZ d Z d Z e d e Dd e DzZ ee d <dZddZGddZeZGddZdS)aG`PEP 3101`_ introduced the :meth:`str.format` method, and what would later be called "new-style" string formatting. For the sake of explicit correctness, it is probably best to refer to Python's dual string formatting capabilities as *bracket-style* and *percent-style*. There is overlap, but one does not replace the other. * Bracket-style is more pluggable, slower, and uses a method. * Percent-style is simpler, faster, and uses an operator. Bracket-style formatting brought with it a much more powerful toolbox, but it was far from a full one. :meth:`str.format` uses `more powerful syntax`_, but `the tools and idioms`_ for working with that syntax are not well-developed nor well-advertised. ``formatutils`` adds several functions for working with bracket-style format strings: * :class:`DeferredValue`: Defer fetching or calculating a value until format time. * :func:`get_format_args`: Parse the positional and keyword arguments out of a format string. * :func:`tokenize_format_str`: Tokenize a format string into literals and :class:`BaseFormatField` objects. * :func:`construct_format_field_str`: Assists in programmatic construction of format strings. * :func:`infer_positional_format_args`: Converts anonymous references in 2.7+ format strings to explicit positional arguments suitable for usage with Python 2.6. .. _more powerful syntax: https://docs.python.org/2/library/string.html#format-string-syntax .. _the tools and idioms: https://docs.python.org/2/library/string.html#string-formatting .. _PEP 3101: https://www.python.org/dev/peps/pep-3101/ N) Formatter) DeferredValueget_format_argstokenize_format_strconstruct_format_field_strinfer_positional_format_argsBaseFormatFieldz({{)|(}})|({[:!.\[}])cJ|dSd|z}|r|d|zz }|r|d|zz }|dz }|S)z Constructs a format field string from the field name, spec, and conversion character (``fname``, ``fspec``, ``conv``). See Python String Formatting for more info. N{!:})fnamefspecconvrets S/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/boltons/formatutils.pyrrRsQ  }r +C  sTz  sU{3JC Jcg}t|D]I\}}}}|||df!t|||}|||fJ|S)zDoes very basic splitting of a format string, returns a list of strings. For full tokenization, see :func:`tokenize_format_str`. N)rparseappendr)fstrrlitrrr field_strs rsplit_format_strrcs C#,;;#4#4T#:#:%%UE4 = JJT{ # # # .ueTBB  C#$$$$ Jrcdd\}}d\}}}t|D]|}|||}}}||kr ||||z }|}|dks|dkr||z }e|d||ddz }|dz }}|||dz }|S)zTakes format strings with anonymous positional arguments, (e.g., "{}" and {:d}), and converts them into numbered ones for explicitness and compatibility with 2.6. Returns a string with the inferred positional arguments. )r r)rrrz{{z}}r N) _pos_farg_refinditerstartendgroup)rrmax_anonr"r#prev_endmatchr$s rrrssMC"E3&&t,,  !KKMM599;; Es e   4' 'C D==ETMM 5LC  )H)eABBi)))A 4 ?C JrbcdoxXnzeEfFgGn%c g|] }|tf Sr)int.0xs r r.s...q1c(...rc g|] }|tf Sr)floatr+s rr.r.s2221e*222rsc t}ggtc d fd }||D]\}}}}||dd}tjd|}t |dkrt d|z |d} | sJn$#ttf$rt d wxYw|||||D]\} } } } | || fS) a Turn a format string into two lists of arguments referenced by the format string. One is positional arguments, and the other is named arguments. Each element of the list includes the name and the nominal type of the field. # >>> get_format_args("{noun} is {1:d} years old{punct}") # ([(1, )], [('noun', ), ('punct', )]) # XXX: Py3k >>> get_format_args("{noun} is {1:d} years old{punct}") == ([(1, int)], [('noun', str), ('punct', str)]) True r1c|vr|t|t} t ||fdS#t $r||fYdSwxYwdSN)add _TYPE_MAPgetstrrr* ValueError)argname type_charargtype_dedupfargsfkwargss r_add_argz!get_format_args.._add_args & JJw   mmIs33G 3 c'llG455555 3 3 31222222 3 ! s$A""!BBN[.[]rz#encountered compound format arg: %rrz)encountered anonymous positional argument)r1) rsetrresplitlenr9 IndexErrorAssertionError)r formatterr@rrrrr; fname_list base_fnamesublitsubfname_r=r>r?s @@@rrrsd  ISUUE7F33333333$-??4#8#8''UE4  bcc I&%00J:"" !F!NOOO N'] !!!!!/ N N N !LMMM N HUI & & &*3//%*@*@ ' '&!Q'HX&&& '>s  B!B>Tcg}|rt|}t}||D]E\}}}}|r|||!|t |||F|S)a$Takes a format string, turns it into a list of alternating string literals and :class:`BaseFormatField` tokens. By default, also infers anonymous positional references into explicit, numbered positional references. To disable this behavior set *resolve_pos* to ``False``. )rrrrr )r resolve_posrrIrrrrs rrrs C2+D11 I#,??4#8#888UE4   JJsOOO =  ?5%667777 JrcNeZdZdZd dZdZdZdZedZ d Z d Z dS) r aA class representing a reference to an argument inside of a bracket-style format string. For instance, in ``"{greeting}, world!"``, there is a field named "greeting". These fields can have many options applied to them. See the Python docs on `Format String Syntax`_ for the full details. .. _Format String Syntax: https://docs.python.org/2/library/string.html#string-formatting r Nc||||||dSr4) set_fname set_fspecset_conv)selfrrrs r__init__zBaseFormatField.__init__s> u u drctjd|}|d|_||_|dd|_|j p|j|_dS)zSet the field name.rBrrN)rDrE base_namersubpathisdigit is_positional)rVr path_lists rrSzBaseFormatField.set_fnames\HVU++ "1  } !%/K4>3I3I3K3Krc |pd}g}t|D]\}}}}|||||_||_|dd|_t |jt|_ dS)zSet the field spec.r NrA) rrr subfieldsrr;r6r7r8 type_func)rVrr_rLrMrNs rrTzBaseFormatField.set_fspecs  &/kk&7&7&>&> + + "FHa#  ***" rss"t~s;;rc"||_d|_dS)zuThere are only two built-in converters: ``s`` and ``r``. They are somewhat rare and appearlike ``"{ref!r}"``.N)r conv_func)rVrs rrUzBaseFormatField.set_convs rcBt|j|j|jS)z0The current state of the field in string format.)rrrrrVs rrzBaseFormatField.fstrs*$*dj$)LLLrc|jj}|jg}|j"||j|jgn%|jdkr||jdd|D}|d|dS)Nr z, c,g|]}t|Sr)repr)r,as rr.z,BaseFormatField.__repr__..s5551tAww555r()) __class____name__rrextendrrjoin)rVcnargs args_reprs r__repr__zBaseFormatField.__repr__s ^ $ | 9 KKTY/ 0 0 0 0 Z2   KK # # #II5555566 ##y####rc|jSr4)rrds r__str__zBaseFormatField.__str__s yr)r N) rl __module__ __qualname____doc__rWrSrTrUpropertyrrrrtrrrr r s LLL < < <MMXM$$$rr cDeZdZdZd dZdZdZdZdZdZ d Z d Z d S) ra:class:`DeferredValue` is a wrapper type, used to defer computing values which would otherwise be expensive to stringify and format. This is most valuable in areas like logging, where one would not want to waste time formatting a value for a log message which will subsequently be filtered because the message's log level was DEBUG and the logger was set to only emit CRITICAL messages. The :class:``DeferredValue`` is initialized with a callable that takes no arguments and returns the value, which can be of any type. By default DeferredValue only calls that callable once, and future references will get a cached value. This behavior can be disabled by setting *cache_value* to ``False``. Args: func (function): A callable that takes no arguments and computes the value being represented. cache_value (bool): Whether subsequent usages will call *func* again. Defaults to ``True``. >>> import sys >>> dv = DeferredValue(lambda: len(sys._current_frames())) >>> output = "works great in all {0} threads!".format(dv) PROTIP: To keep lines shorter, use: ``from formatutils import DeferredValue as DV`` Tc:||_||_t|_dSr4)func cache_value_UNSET_value)rVr{r|s rrWzDeferredValue.__init__6s & rc|jtur|jr|j}n"|}|jr||_|S)zComputes, optionally caches, and returns the value of the *func*. If ``get_value()`` has been called before, a cached value may be returned depending on the *cache_value* option passed to the constructor. )r~r}r|r{)rVvalues r get_valuezDeferredValue.get_value;sF ;f $ $)9 $KEEIIKKE $#  rcDt|Sr4)r*rrds r__int__zDeferredValue.__int__I4>>##$$$rcDt|Sr4)r0rrds r __float__zDeferredValue.__float__LsT^^%%&&&rcDt|Sr4r8rrds rrtzDeferredValue.__str__OrrcDt|Sr4rrds r __unicode__zDeferredValue.__unicode__RrrcDt|Sr4)rgrrds rrrzDeferredValue.__repr__UsDNN$$%%%rc|}|dd}t|t} ||S#t t f$r!|||cYSwxYw)NrA)rr6r7r8 __format__r9 TypeError)rVfmtrpt type_convs rrzDeferredValue.__format__Xs   XMM"c**  4##C(( (I& 4 4 49U##..s33 3 3 3 4sA/BBNT) rlrurvrwrWrrrrtrrrrrrrrrs8   %%%'''%%%%%%&&& 4 4 4 4 4rrr)rwrDstringr__all__compiler rrr _INTCHARS _FLOATCHARSdictr6r8rrr objectr}rrrrrsh>!!L     rz)** "    4   D..I...22k2223 4 4  #,,,^(<<<<<<<<~ I4I4I4I4I4I4I4I4I4I4r