o Ph$F@sdZddlZddlZddlZddlmZddlmZddlmZdZ Gddde Z Gd d d ej Z ej je _Gd d d eZd dZddZdS)z&Module providing 'sequence awareness'.N)wcwidth)TextType)CAPABILITIES_CAUSE_MOVEMENT)SequenceSequenceTextWrapper iter_parsemeasure_lengthc@s`eZdZdZddZddZeddZedd Zed d Z d d Z e   dddZ dS)Termcapz7Terminal capability of given variable name and pattern.cCs||_||_||_d|_dS)z Class initializer. :arg str name: name describing capability. :arg str pattern: regular expression string. :arg str attribute: :class:`~.Terminal` attribute used to build this terminal capability. N)namepattern attribute _re_compiled)selfr r r rL/var/www/html/env_mimamsha/lib/python3.10/site-packages/blessed/sequences.py__init__s  zTermcap.__init__cC dj|dS)Nz&rformatrrrr__repr__%s zTermcap.__repr__cCr)z;Regular expression pattern for capability with named group.z(?P<{self.name}>{self.pattern})rrrrrr named_pattern)s zTermcap.named_patterncCs|jdur t|j|_|jS)z3Compiled regular expression pattern for capability.N)r recompiler rrrr re_compiled/s zTermcap.re_compiledcCs |jtvS)z*Whether capability causes cursor movement.)r rrrrr will_move6s zTermcap.will_movecCs`dddddd|j}|dur|Sddd|j}|dur.t|j|d}||SdS)a4 Horizontal carriage adjusted by capability, may be negative. :rtype: int :arg str text: for capabilities *parm_left_cursor*, *parm_right_cursor*, provide the matching sequence text, its interpreted distance is returned. :returns: 0 except for matching ' ) cursor_left backspace cursor_righttab ascii_tabN)parm_left_cursorparm_right_cursorr)getr intrmatchgroup)rtextvalueunitrrrhorizontal_distance;s& zTermcap.horizontal_distancercFc sd|rd|r d|durdn|}|dkr||t||St||f|} |sMt|d|dD]} t| | vrL| t| } ||| |Sq4|r[tdfd d | } n tdfd d | } ||| |S) ak Class factory builder for given capability definition. :arg str name: Variable name given for this pattern. :arg str capability: A unicode string representing a terminal capability to build for. When ``nparams`` is non-zero, it must be a callable unicode string (such as the result from ``getattr(term, 'bold')``. :arg str attribute: The terminfo(5) capability name by which this pattern is known. :arg int nparams: number of positional arguments for callable. :arg int numeric: Value to substitute into capability to when generating pattern :arg bool match_grouped: If the numeric pattern should be grouped, ``(\d+)`` when ``True``, ``\d+`` default. :arg bool match_any: When keyword argument ``nparams`` is given, *any* numeric found in output is suitable for building as pattern ``(\d+)``. Otherwise, only the first matching value of range *(numeric - 1)* through *(numeric + 1)* will be replaced by pattern ``(\d+)`` in builder. :arg bool match_optional: When ``True``, building of numeric patterns containing ``(\d+)`` will be built as optional, ``(\d+)?``. :rtype: blessed.sequences.Termcap :returns: Terminal capability instance for given capability definition z\d+z(\d+)z(\d+)?Nr.rrcSNrx_numeric_regexrrzTermcap.build..cr0r1rr2r4rrr6r7)rescaperangestrreplacesub) clsr capabilityr nparamsnumeric match_grouped match_anymatch_optional_outpnumr rr4rbuildYs&  z Termcap.buildN)rr.FFF) __name__ __module__ __qualname____doc__rrpropertyrrrr- classmethodrFrrrrr s    r c@s(eZdZdZddZddZddZdS) rzDocstring overridden.cKs ||_tjj||fi|dS)ze Class initializer. This class supports the :meth:`~.Terminal.wrap` method. N)termtextwrap TextWrapperr)rwidthrMkwargsrrrrszSequenceTextWrapper.__init__c Cs:g}|jdks t|jtstd|jt|j|j}t|d p$|j}| |rg}d}|r4|j n|j }|jt |}|rPt |d|dkrP|rP|d=|r{t |d|} || |krn| |krm|||||n |||| 7}|sR|r|rt |d|dkr|d=|r||d||s+|S)a4 Sequence-aware variant of :meth:`textwrap.TextWrapper._wrap_chunks`. :raises ValueError: ``self.width`` is not a positive integer :rtype: list :returns: text chunks adjusted for width This simply ensures that word boundaries are not broken mid-sequence, as standard python textwrap would incorrectly determine the length of a string containing sequences, and may also break consider sequences part of a "word" that may be broken by hyphen (``-``), where this implementation corrects both. rz0invalid width {0!r}({1!r}) (must be integer > 0)drop_whitespacer)rP isinstancer' ValueErrorrtyperMhasattrrRreversesubsequent_indentinitial_indentlenrstriplength_handle_long_wordappendpopjoin) rchunkslinesrMrRcur_linecur_lenindentrP chunk_lenrrr _wrap_chunkssJ   z SequenceTextWrapper._wrap_chunksc Cs|dkrdn||}|jr_|j}|d}d}} t||D].\} } | t| 7} t|d| |} | |krI|dkrG|dkrG| dkrG| dkrGnn| }q||d|||d|d<dS|sj||dSdS)a Sequence-aware :meth:`textwrap.TextWrapper._handle_long_word`. This method ensures that word boundaries are not broken mid-sequence, as standard python textwrap would incorrectly determine the length of a string containing sequences and wide characters it would also break these "words" that would be broken by hyphen (``-``), this implementation corrects both. This is done by mutating the passed arguments, removing items from 'reversed_chunks' and appending them to 'cur_line'. However, some characters (east-asian, emoji, etc.) cannot be split any less than 2 cells, so in the case of a width of 1, we have no choice but to allow those characters to flow outside of the given cell. rrrNr/)break_long_wordsrMrr[rr]r_r`) rreversed_chunksrdrerP space_leftrMchunkidxnxtr*_ seq_lengthrrrr^s$  z%SequenceTextWrapper._handle_long_wordN)rGrHrIrJrrhr^rrrrrs  .rc@sveZdZdZddZdddZdddZdd d Zd d Zd dZ dddZ dddZ dddZ ddZ dddZdS)ra A "sequence-aware" version of the base :class:`str` class. This unicode-derived class understands the effect of escape sequences of printable length, allowing a properly implemented :meth:`rjust`, :meth:`ljust`, :meth:`center`, and :meth:`length`. cCst||}||_|S)z Class constructor. :arg str sequence_text: A string that may contain sequences. :arg blessed.Terminal term: :class:`~.Terminal` instance. )r__new___term)r= sequence_textrMnewrrrrq s zSequence.__new__ cCs<|ttdt||tt|}d||fS)aq Return string containing sequences, left-adjusted. :arg int width: Total width given to left-adjust ``text``. If unspecified, the width of the attached terminal is used (default). :arg str fillchar: String for padding right-of ``text``. :returns: String of ``text``, left-aligned by ``width``. :rtype: str rSr'maxfloat __index__r]r[ra)rrPfillchar rightsiderrrljust $zSequence.ljustcCs<|ttdt||tt|}d||fS)as Return string containing sequences, right-adjusted. :arg int width: Total width given to right-adjust ``text``. If unspecified, the width of the attached terminal is used (default). :arg str fillchar: String for padding left-of ``text``. :returns: String of ``text``, right-aligned by ``width``. :rtype: str rvrSrw)rrPr{leftsiderrrrjust&r~zSequence.rjustcCsvtdt||d}|ttdt|tt|}|ttdt|tt|}d |||fS)al Return string containing sequences, centered. :arg int width: Total width given to center ``text``. If unspecified, the width of the attached terminal is used (default). :arg str fillchar: String for padding left and right-of ``text``. :returns: String of ``text``, centered by ``width``. :rtype: str rvr/rS) rxryrzr]r'mathfloorr[ceilra)rrPr{splitrr|rrrcenter4s zSequence.centercCspd}d}|}t|j|}|D]\}}|s'|tt|d7}||kr'n||7}q|ddd|DS)a Truncate a string in a sequence-aware manner. Any printable characters beyond ``width`` are removed, while all sequences remain in place. Horizontal Sequences are first expanded by :meth:`padd`. :arg int width: The printable width to truncate the string to. :rtype: str :returns: String truncated to at most ``width`` printable characters. rSrcss|] \}}|r|VqdSr1r).0r*caprrr `sz$Sequence.truncate..)rzrrrpaddrxrra)rrPoutput current_width target_width parsed_seqr*rrrrtruncateEs   zSequence.truncatecCstdd|jddDS)u Return the printable length of string containing sequences. Strings containing ``term.left`` or ``\b`` will cause "overstrike", but a length less than 0 is not ever returned. So ``_\b+`` is a length of 1 (displays as ``+``), but ``\b`` alone is simply a length of 0. Some characters may consume more than one cell, mainly those CJK Unified Ideographs (Chinese, Japanese, Korean) defined by Unicode as half or full-width characters. For example: >>> from blessed import Terminal >>> from blessed.sequences import Sequence >>> term = Terminal() >>> msg = term.clear + term.red(u'コンニチハ') >>> Sequence(msg, term).length() 10 .. note:: Although accounted for, strings containing sequences such as ``term.clear`` will not give accurate returns, it is not considered lengthy (a length of 0). css|] }tt|dVqdS)rN)rxr)rw_charrrrr}sz"Sequence.length..Tr\)sumrrrrrr]bszSequence.lengthNcC||S)a  Return string of sequences, leading and trailing whitespace removed. :arg str chars: Remove characters in chars instead of whitespace. :rtype: str :returns: string of sequences with leading and trailing whitespace removed. ) strip_seqsr\rcharsrrrr\zSequence.stripcCr)z Return string of all sequences and leading whitespace removed. :arg str chars: Remove characters in chars instead of whitespace. :rtype: str :returns: string of sequences with leading removed. )rlstriprrrrrrzSequence.lstripcCr)z Return string of all sequences and trailing whitespace removed. :arg str chars: Remove characters in chars instead of whitespace. :rtype: str :returns: string of sequences with trailing removed. )rrstriprrrrrrzSequence.rstripcCs |jddS)z Return ``text`` stripped of only its terminal sequences. :rtype: str :returns: Text with terminal sequences removed Tr)rrrrrrs zSequence.strip_seqsFcCsnd}t|j|D],\}}|s||7}q||}|dkr#|d|7}q|dkr.|d|}q|s4||7}q|S)z Return non-destructive horizontal movement as destructive spacing. :arg bool strip: Strip terminal sequences :rtype: str :returns: Text adjusted for horizontal movement rSrruN)rrrr-)rr\outpr*rr+rrrrs z Sequence.padd)rur1)F)rGrHrIrJrqr}rrrr]r\rrrrrrrrrs      rccsL|j|D]}|j}||}|dkr|dfVq||j|fVqdS)z Generator yields (text, capability) for characters of ``text``. value for ``capability`` may be ``None``, where ``text`` is :class:`str` of length 1. Otherwise, ``text`` is a full matching sequence of given capability. MISMATCHN)_caps_compiled_anyfinditer lastgroupr)caps)rMr*r(r r+rrrrs  rcCs<ztt||\}}|rt|WSWdStyYdSw)zk .. deprecated:: 1.12.0. :rtype: int :returns: Length of the first sequence in the string r)nextrr[ StopIteration)r*rMr>rrrrs  r)rJrrrNrblessed._compatrblessed._capabilitiesr__all__objectr rOrrrrrrrrs   { q<