o aĎiEq@sdZddlmZddlZddlZddlZddlmZmZddl m Z ddl m Z ddl mZdd lmZdd lmZerDdd lmZmZGd d d eZedZd=ddZd>ddZd?ddZGdddejZd@dd d!d!dd"d"d#d!d!d!dd$d!d%dAd;d<ZdS)Bz Sequence-aware text wrapping functions. This module provides functions for wrapping text that may contain terminal escape sequences, with proper handling of Unicode grapheme clusters and character display widths. ) annotationsN) TYPE_CHECKING NamedTuple)width)iter_sequences)iter_graphemes) propagate_sgr)ZERO_WIDTH_PATTERN)AnyLiteralc@s*eZdZUdZded<ded<ded<dS)_HyperlinkStatez>State for tracking an open OSC 8 hyperlink across line breaks.strurlparams terminatorN)__name__ __module__ __qualname____doc____annotations__rrL/home/jeff/fluffinator/venv/lib/python3.10/site-packages/wcwidth/textwrap.pyr s  r z*\x1b]8;([^;]*);([^\x07\x1b]*)(\x07|\x1b\\)seqrreturn_HyperlinkState | NonecCs2t|}rt|d|d|ddSdS)z0Parse OSC 8 open sequence, return state or None.rrrrN)_HYPERLINK_OPEN_REmatchr group)rmrrr_parse_hyperlink_open's r#rrrcCsd|d||S)zGenerate OSC 8 open sequence.z]8;;rrrrr_make_hyperlink_open.sr%cCs d|S)zGenerate OSC 8 close sequence.z]8;;r)rrrr_make_hyperlink_close3s r&cseZdZdZd6ddddd7fddZed8ddZd9ddZd:ddZd:ddZ d;ddZ dd*d+Z d?d-d.Zd@d0d1Zd9d2d3Zd:d4d5ZZS)ASequenceTextWrappera Sequence-aware text wrapper extending :class:`textwrap.TextWrapper`. This wrapper properly handles terminal escape sequences and Unicode grapheme clusters when calculating text width for wrapping. This implementation is based on the SequenceTextWrapper from the 'blessed' library, with contributions from Avram Lubkin and grayjk. The key difference from the blessed implementation is the addition of grapheme cluster support via :func:`~.iter_graphemes`, providing width calculation for ZWJ emoji sequences, VS-16 emojis and variations, regional indicator flags, and combining characters. OSC 8 hyperlinks are handled specially: when a hyperlink must span multiple lines, each line receives complete open/close sequences with a shared ``id`` parameter, ensuring terminals treat the fragments as a single hyperlink for hover underlining. If the original hyperlink already has an ``id`` parameter, it is preserved; otherwise, one is generated. Fparser control_codestabsizeambiguous_widthrintr,$Literal['parse', 'strict', 'ignore']r-r.kwargsr rNonec s,tjdd|i|||_||_||_dS)a Initialize the wrapper. :param width: Maximum line width in display cells. :param control_codes: How to handle control sequences (see :func:`~.width`). :param tabsize: Tab stop width for tab expansion. :param ambiguous_width: Width to use for East Asian Ambiguous (A) characters. :param kwargs: Additional arguments passed to :class:`textwrap.TextWrapper`. rNr)super__init__r,r-r.)selfrr,r-r.r1 __class__rrr4Ls zSequenceTextWrapper.__init__rcCs tdS)z7Generate unique hyperlink id as 8-character hex string.)secrets token_hexrrrr_next_hyperlink_id_s z&SequenceTextWrapper._next_hyperlink_idtextcCst||j|j|jdS)z,Measure text width accounting for sequences.r+)_widthr,r-r.r5r<rrrr=ds zSequenceTextWrapper._widthcCs.g}t|D] \}}|s||qd|S)z'Strip all terminal sequences from text.rappendjoinr5r<resultsegmentis_seqrrr_strip_sequencesi   z$SequenceTextWrapper._strip_sequencescCs.g}t|D] \}}|r||qd|S)z*Extract only terminal sequences from text.r?r@rCrrr_extract_sequencesqrHz&SequenceTextWrapper._extract_sequences list[str]cCstg}d}d}d}t|D]S\}}|s:|r%|r%|ds%|d7}|||D]}|d7}||||7}q'd}q |d} |drW|rW|dsW| sW|d7}|||t|7}| }q ||tj||} | ss|rs|gSg} d} t| } t| D]8\}}t|}| dkrdn|| d}|| dkr|d}n|| |d}||kr| |||| |7} q| S) a Sequence-aware variant of :meth:`textwrap.TextWrapper._split`. This method ensures that terminal escape sequences don't interfere with the text splitting logic, particularly for hyphen-based word breaking. It builds a position mapping from stripped text to original text, calls the parent's _split on stripped text, then maps chunks back. OSC hyperlink sequences are treated as word boundaries:: >>> wrap('foo \x1b]8;;https://example.com\x07link\x1b]8;;\x07 bar', 6) ['foo', '\x1b]8;;https://example.com\x07link\x1b]8;;\x07', 'bar'] Both BEL (``\x07``) and ST (``\x1b\\``) terminators are supported. r?rF rz]8;;\z]8;;z]) risspacerA startswithlentextwrap TextWrapper_split enumerate)r5r<char_end stripped_text original_posprev_was_hyperlink_closerErFcharis_hyperlink_closestripped_chunksrD stripped_pos num_chunksidxchunk chunk_len start_origend_origrrrrSysP           zSequenceTextWrapper._splitchunkscCs||sgS|jdur)|jdkr|j}n|j}||||j|jkr)tdg}d}d}d}tt |}|rsz8SequenceTextWrapper._handle_long_word..NT) break_long_wordsbreak_on_hyphensrGrPrfindany_map_stripped_pos_to_original_find_break_position_find_first_grapheme_endrAro) r5rrrr space_leftr_break_at_hyphen hyphen_endr~ hyphen_pos actual_endrrrrps0   "   z%SequenceTextWrapper._handle_long_wordr\cCshd}d}t|D])\}}|r|t|7}q|t||kr%|||S|t|7}|t|7}q|S)z?Map a position in stripped text back to original text position.r)rrP)r5r<r\ stripped_idx original_idxrErFrrrrs z1SequenceTextWrapper._map_stripped_pos_to_original max_widthc Csd}d}|t|krD||}|dkrt||}|r|}qtt||d}||}|||kr4|S||7}|t|7}|t|ks |S)z;Find string index in text that fits within max_width cells.r)start)rPr r endnextrr=) r5r<rr^ width_so_farrYr graphemegrapheme_widthrrrrs"      z(SequenceTextWrapper._find_break_positioncCsttt|S)z,Find the end position of the first grapheme.)rPrrr>rrrrsz,SequenceTextWrapper._find_first_grapheme_endcCstt|}d}t|D]\}\}}|s|r|}q |dkr!dSg}t|D]#\}\}}||kr7||q'||krC||q'|rJ||q'd|S)zAStrip trailing visible whitespace, preserving trailing sequences.rMr?)rkrrTrsrArB)r5r<segmentslast_visirErFrDrrrrts$     z#SequenceTextWrapper._rstrip_visibler() rr/r,r0r-r/r.r/r1r rr2)rr)r<rrr/)r<rrr)r<rrrJ)rcrJrrJ)r<rrrrr) rrJrrJrr/rr/rr2)r<rr\r/rr/)r<rrr/rr/)rrrrr4 staticmethodr;r=rGrIrSrrqrprrrrt __classcell__rrr6rr'8s*      ^ 6  1  r'r(r)r*Tr?Fz [...])r,r- expand_tabsreplace_whitespacer.rgrffix_sentence_endingsrrrmrerhr r<rr/r,r0r-rboolrr.rgrfrrrrmre int | Nonerhr rJcCs>t||||||||| | | | | |d}||}|rt|}|S)u Wrap text to fit within given width, returning a list of wrapped lines. Like :func:`textwrap.wrap`, but measures width in display cells rather than characters, correctly handling wide characters, combining marks, and terminal escape sequences. :param text: Text to wrap, may contain terminal sequences. :param width: Maximum line width in display cells. :param control_codes: How to handle terminal sequences (see :func:`~.width`). :param tabsize: Tab stop width for tab expansion. :param expand_tabs: If True (default), tab characters are expanded to spaces using ``tabsize``. :param replace_whitespace: If True (default), each whitespace character is replaced with a single space after tab expansion. When False, control whitespace like ``\n`` has zero display width (unlike :func:`textwrap.wrap` which counts ``len()``), so wrap points may differ from stdlib for non-space whitespace characters. :param ambiguous_width: Width to use for East Asian Ambiguous (A) characters. Default is ``1`` (narrow). Set to ``2`` for CJK contexts. :param initial_indent: String prepended to first line. :param subsequent_indent: String prepended to subsequent lines. :param fix_sentence_endings: If True, ensure sentences are always separated by exactly two spaces. :param break_long_words: If True, break words longer than width. :param break_on_hyphens: If True, allow breaking at hyphens. :param drop_whitespace: If True (default), whitespace at the beginning and end of each line (after wrapping but before indenting) is dropped. Set to False to preserve whitespace. :param max_lines: If set, output contains at most this many lines, with ``placeholder`` appended to the last line if the text was truncated. :param placeholder: String appended to the last line when text is truncated by ``max_lines``. Default is ``' [...]'``. :param propagate_sgr: If True (default), SGR (terminal styling) sequences are propagated across wrapped lines. Each line ends with a reset sequence and the next line begins with the active style restored. :returns: List of wrapped lines without trailing newlines. SGR (terminal styling) sequences are propagated across wrapped lines by default. Each line ends with a reset sequence and the next line begins with the active style restored:: >>> wrap('\x1b[1;34mHello world\x1b[0m', width=6) ['\x1b[1;34mHello\x1b[0m', '\x1b[1;34mworld\x1b[0m'] Set ``propagate_sgr=False`` to disable this behavior. Like :func:`textwrap.wrap`, newlines in the input text are treated as whitespace and collapsed. To preserve paragraph breaks, wrap each paragraph separately:: >>> text = 'First line.\nSecond line.' >>> wrap(text, 40) # newline collapsed to space ['First line. Second line.'] >>> [line for para in text.split('\n') ... for line in (wrap(para, 40) if para else [''])] ['First line.', 'Second line.'] .. seealso:: :func:`textwrap.wrap`, :class:`textwrap.TextWrapper` Standard library text wrapping (character-based). :class:`.SequenceTextWrapper` Class interface for advanced wrapping options. .. versionadded:: 0.3.0 .. versionchanged:: 0.5.0 Added ``propagate_sgr`` parameter (default True). .. versionchanged:: 0.6.0 Added ``expand_tabs``, ``replace_whitespace``, ``fix_sentence_endings``, ``drop_whitespace``, ``max_lines``, and ``placeholder`` parameters. Example:: >>> from wcwidth import wrap >>> wrap('hello world', 5) ['hello', 'world'] >>> wrap('中文字符', 4) # CJK characters (2 cells each) ['中文', '字符'] )rr,r-rrr.rgrfrrrrmrerh)r'wrap_propagate_sgr)r<rr,r-rrr.rgrfrrrrmrerhr wrapperrvrrrrs(c r)rrrr)rrrrrrrr)rrrrr)"r<rrr/r,r0r-r/rrrrr.r/rgrrfrrrrrrrrmrrerrhrr rrrJ)r __future__rrer9rQtypingrrwcwidthrr=rrr sgr_stater rescape_sequencesr r r r compilerr#r%r&rRr'rrrrrsL         c