a )jd@sddlmZddlmZddlmZddlmZddlm Z m Z m Z m Z m Z mZmZmZmZmZddlmZmZmZmZmZddlmZmZdd lmZe rdd lmZm Z m!Z!Gd d d eZ"eee"ee"ee#e$ffee"e#e#ffZ%eGd dde Z&GdddZ'GdddZ(e)dkrddl*mZddl+m,Z,ddl-m.Z.dZ/e.0dZ1eZe2de3de3de3e,e/ddde3e3de4e5e1Z6e3e6e3e3d e3e1e3d!d"S)#)IntEnum) lru_cache) filterfalse) attrgetter) TYPE_CHECKINGDictIterableList NamedTupleOptionalSequenceTupleTypeUnion)_is_single_cell_widthscached_cell_lencell_lenget_character_cell_size set_cell_size)Result rich_repr)Style)ConsoleConsoleOptions RenderResultc@sPeZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d Zd ZdZdZdZdZdS) ControlTypezDNon-printable control codes which typically translate to ANSI codes.r N)__name__ __module__ __qualname____doc__BELLCARRIAGE_RETURNHOMECLEAR SHOW_CURSOR HIDE_CURSORENABLE_ALT_SCREENDISABLE_ALT_SCREEN CURSOR_UP CURSOR_DOWNCURSOR_FORWARDCURSOR_BACKWARDCURSOR_MOVE_TO_COLUMNCURSOR_MOVE_TO ERASE_IN_LINESET_WINDOW_TITLEr@r@2E:\soccer\ml_env\Lib\site-packages\rich/segment.pyr s"rc @sReZdZUdZeed<dZeeed<dZ ee e ed<e e dddZedd d Zedd d Ze edd dZeedde eddddZe eddddZeddddZedGedeeeeeddddZedHedeeddddZeedeedd d!d"Zeedeeedefd d#d$ZedIede eeeeeedd&d'd(Z edJede eeeedd)d*d+Z!eede d,d-d.Z"eeedee e fd/d0d1Z#edKeede ee eeeeedd2d3d4Z$edLe%deede e eeeedd5d6d7Z&edMe%deede e eeeedd5d8d9Z'edNe%deede e eeeedd5d:d;Z(eededd dd?Z*eededd d@dAZ+eededd dBdCZ,eedee eeddDdEdFZ-dS)OSegmentaA piece of text with associated style. Segments are produced by the Console render process and are ultimately converted in to strings to be written to the terminal. Args: text (str): A piece of text. style (:class:`~rich.style.Style`, optional): An optional style to apply to the text. control (Tuple[ControlCode], optional): Optional sequence of control codes. Attributes: cell_length (int): The cell length of this Segment. textNstylecontrol)returncCs|\}}}|rdSt|S)zzThe number of terminal cells required to display self.text. Returns: int: A number of cells. r)r)selfrC_stylerEr@r@rA cell_lengthNs zSegment.cell_lengthccs:|jV|jdur&|jdur6|jVn|jV|jVdSN)rCrErDrGr@r@rA __rich_repr__Xs    zSegment.__rich_repr__cCs t|jS)z#Check if the segment contains text.)boolrCrKr@r@rA__bool__aszSegment.__bool__cCs |jduS)z,Check if the segment contains control codes.N)rErKr@r@rA is_controleszSegment.is_controli@)rBrB)segmentcutrFc CsF|\}}}t}|j}||kr,||d||fSt}t||t|} |d| } t| } | |} | s|| ||||| d||fS| dkr||| dkr||d| d|||d|| dd||fS| dkr$||| ddkr$||d| dd|||d|| d||fS| |kr8| d7} qD| d8} qDdS)a\Split a segment in to two at a given cell position. Note that splitting a double-width character, may result in that character turning into two spaces. Args: segment (Segment): A segment to split. cut (int): A cell position to cut on. Returns: A tuple of two segments. Nr r)rBrIrintlenr) clsrPrQrCrDrE_SegmentrI cell_sizeposbeforecell_posout_byr@r@rA _split_cellsjs2      zSegment._split_cells)rQrFcCsn|\}}}|dksJt|rb|t|kr:|td||fSt|d|||t||d||fS|||S)axSplit segment in to two segments at the specified column. If the cut point falls in the middle of a 2-cell wide character then it is replaced by two spaces, to preserve the display width of the parent segment. Args: cut (int): Offset within the segment to cut. Returns: Tuple[Segment, Segment]: Two segments. rrRN)rrVrBr^)rGrQrCrDrEr@r@rA split_cellss   zSegment.split_cellscCs|dS)zMake a new line segment. r@)rWr@r@rAlinesz Segment.line)segmentsrD post_stylerFcs>|}|r"|jfdd|D}r:fdd|D}|S)aApply style(s) to an iterable of segments. Returns an iterable of segments where the style is replaced by ``style + segment.style + post_style``. Args: segments (Iterable[Segment]): Segments to process. style (Style, optional): Base style. Defaults to None. post_style (Style, optional): Style to apply on top of segment style. Defaults to None. Returns: Iterable[Segments]: A new iterable of segments (possibly the same iterable). c3s,|]$\}}}||rdn||VqdSrJr@.0rCrHrE)applyrWr@rA sz&Segment.apply_style..c3s4|],\}}}||rdn|r$|n|VqdSrJr@rd)rWrcr@rArgs )__add__)rWrbrDrcresult_segmentsr@)rfrWrcrA apply_styles   zSegment.apply_styleF)rbrOrFcCs$|rttd|Sttd|SdS)a2Filter segments by ``is_control`` attribute. Args: segments (Iterable[Segment]): An iterable of Segment instances. is_control (bool, optional): is_control flag to match in search. Returns: Iterable[Segment]: And iterable of Segment instances. rEN)filterrr)rWrbrOr@r@rAfilter_controlszSegment.filter_control)rbrFc csg}|j}|D]d}d|jvrj|jsj|\}}}|rr|d\}} }|rR||||| r,|Vg}|j}q,q||q|r~|VdS)aSplit a sequence of segments in to a list of lines. Args: segments (Iterable[Segment]): Segments potentially containing line feeds. Yields: Iterable[List[Segment]]: Iterable of segment lists, one per line. r`NappendrCrE partition rWrbrarnrPrCrD__textnew_liner@r@rA split_liness    zSegment.split_linesc csg}|j}|D]h}d|jvrn|jsn|\}}}|rv|d\}} }|rR||||| r,|dfVg}|j}q,q||q|r|dfVdS)a2Split a sequence of segments in to a list of lines and a boolean to indicate if there was a new line. Args: segments (Iterable[Segment]): Segments potentially containing line feeds. Yields: Iterable[List[Segment]]: Iterable of segment lists, one per line. r`TFNrmrpr@r@rAsplit_lines_terminators     zSegment.split_lines_terminatorT)rblengthrDpadinclude_new_linesrFccsg}|j}|j}|d} |D]} d| jvr| js| \} } } | r| d\}}} |r`|||| |r:|||||d}|r|| |V|q:q|| q|r|||||dVdS)aSplit segments in to lines, and crop lines greater than a given length. Args: segments (Iterable[Segment]): An iterable of segments, probably generated from console.render. length (int): Desired line length. style (Style, optional): Style to use for any padding. pad (bool): Enable padding of lines that are less than `length`. Returns: Iterable[List[Segment]]: An iterable of lines of segments. r`)rDrwN)rnadjust_line_lengthrCrEroclear)rWrbrvrDrwrxrarnrynew_line_segmentrPrC segment_stylerqrrrs cropped_liner@r@rAsplit_and_crop_lines2s,    zSegment.split_and_crop_lines)rarvrDrwrFc Cstdd|D}||krF|r8||d|||g}q|dd}n||krg}|j}d}|D]X}|j} || |ks||jr|||| 7}q`|\} } } t| ||} ||| | qq`n |dd}|S)aAdjust a line to a given width (cropping or padding as required). Args: segments (Iterable[Segment]): A list of segments in a single line. length (int): The desired width of the line. style (Style, optional): The style of padding if used (space on the end). Defaults to None. pad (bool, optional): Pad lines with spaces if they are shorter than `length`. Defaults to True. Returns: List[Segment]: A line of segments with the desired length. css|] }|jVqdSrJ)rI)rerPr@r@rArgtz-Segment.adjust_line_length..rTNr)sumrnrIrEr) rWrarvrDrw line_lengthrsrnrPsegment_lengthrCr|rqr@r@rAryas(   zSegment.adjust_line_length)rarFcsttfdd|DS)zGet the length of list of segments. Args: line (List[Segment]): A line encoded as a list of Segments (assumes no '\\n' characters), Returns: int: The length of the line. c3s |]\}}}|s|VqdSrJr@)rerCrDrE _cell_lenr@rArgrz*Segment.get_line_length..)rr)rWrar@rrAget_line_lengths zSegment.get_line_length)linesrFcs0|j|r tfdd|Dnd}|t|fS)zGet the shape (enclosing rectangle) of a list of lines. Args: lines (List[List[Segment]]): A list of lines (no '\\n' characters). Returns: Tuple[int, int]: Width and height in characters. c3s|]}|VqdSrJr@rerarr@rArgrz$Segment.get_shape..r)rmaxrV)rWr max_widthr@rrA get_shapes zSegment.get_shape)rwidthheightrD new_linesrFc s|p t|}|r$|ddgn|dg}|j|d|}fdd|D|dd<t||kr||g|t||S)aSet the shape of a list of lines (enclosing rectangle). Args: lines (List[List[Segment]]): A list of lines. width (int): Desired width. height (int, optional): Desired height or None for no change. style (Style, optional): Style of any padding added. new_lines (bool, optional): Padded lines should include " ". Defaults to False. Returns: List[List[Segment]]: New list of lines. rTr`Ncsg|]}|dqS))rDr@rryrDrr@rA sz%Segment.set_shape..)rVryextend) rWrrrrDr_heightblank shaped_linesr@rrA set_shapes &  zSegment.set_shape)rWrrrrDrrFcCs`|t|}|s|ddS|d|}|r>|d|d|n |d||}||gg|}|S)aAligns lines to top (adds extra lines to bottom as required). Args: lines (List[List[Segment]]): A list of lines. width (int): Desired width. height (int, optional): Desired height or None for no change. style (Style): Style of any padding added. new_lines (bool, optional): Padded lines should include " ". Defaults to False. Returns: List[List[Segment]]: New list of lines. NrTr`rVrWrrrrDr extra_linesrr@r@rA align_tops   $zSegment.align_topcCs`|t|}|s|ddS|d|}|r>|d|d|n |d||}|gg||}|S)aAligns render to bottom (adds extra lines above as required). Args: lines (List[List[Segment]]): A list of lines. width (int): Desired width. height (int, optional): Desired height or None for no change. style (Style): Style of any padding added. Defaults to None. new_lines (bool, optional): Padded lines should include " ". Defaults to False. Returns: List[List[Segment]]: New list of lines. NrTr`rrr@r@rA align_bottoms   $zSegment.align_bottomc Cs||t|}|s|ddS|d|}|r>|d|d|n |d||}|d}||} |gg|||gg| }|S)aAligns lines to middle (adds extra lines to above and below as required). Args: lines (List[List[Segment]]): A list of lines. width (int): Desired width. height (int, optional): Desired height or None for no change. style (Style): Style of any padding added. new_lines (bool, optional): Padded lines should include " ". Defaults to False. Returns: List[List[Segment]]: New list of lines. NrTr`rr) rWrrrrDrrr top_lines bottom_linesr@r@rA align_middles   $zSegment.align_middleccstt|}z t|}Wnty(YdS0t}|D]6}|j|jkr^|js^||j|j|j}q2|V|}q2|VdS)a)Simplify an iterable of segments by combining contiguous segments with the same style. Args: segments (Iterable[Segment]): An iterable of segments. Returns: Iterable[Segment]: A possibly smaller iterable of segments that will render the same way. N)iternext StopIterationrBrDrErC)rWrb iter_segments last_segmentrXrPr@r@rAsimplify&s   zSegment.simplifyccsJ|D]@}|js|jdur |Vq|\}}}|||r<|dndVqdS)zRemove all links from an iterable of styles. Args: segments (Iterable[Segment]): An iterable segments. Yields: Segment: Segments with link removed. N)rErD update_link)rWrbrPrCrD_controlr@r@rA strip_linksAs  zSegment.strip_linksccs"|D]\}}}||d|VqdS)zRemove all styles from an iterable of segments. Args: segments (Iterable[Segment]): An iterable segments. Yields: Segment: Segments with styles replace with None Nr@)rWrbrCrHrEr@r@rA strip_stylesRs zSegment.strip_stylesccsZi}|D]L\}}}|rF||}|dur6|j}|||<||||Vq||d|VqdS)zRemove all color from an iterable of segments. Args: segments (Iterable[Segment]): An iterable segments. Yields: Segment: Segments with colorless style. N)get without_color)rWrbcacherCrDrEcolorless_styler@r@rA remove_color_s  zSegment.remove_color)rbcutsrFccsDg}|j}t|}t|d}|dkr(dS|dkr2q:gVqd}|j}|j} t} |D]} | \} } }| rR|rl|n || | }||kr|| |}qR||kr|| | V||}t|d}|dkr|r| VdSqRn6| ||\}} | \} } }||| V||}t|d}|dkr`|r.| VdSq`qR| VdS)zDivides an iterable of segments in to portions. Args: cuts (Iterable[int]): Cell positions where to divide. Yields: [Iterable[List[Segment]]]: An iterable of Segments in List. rSNr)rnrrrzcopyrr_)rWrbrsplit_segments add_segment iter_cutsrQrZsegments_clear segments_copyrrPrCrHrEend_posr[r@r@rAdivideusX       zSegment.divide)NN)F)NTT)NT)NNF)F)F)F).r,r-r.r/str__annotations__rDr rrEr ControlCodepropertyrUrIrrLrMrNrO classmethodrr r^r_rarrjrlr rtrur~ryrrrrrrrrrrrrr@r@r@rArB<s    /( ., "   #         rBc@s:eZdZdZd eeeddddZddd d d d ZdS)Segmentsa=A simple renderable to render an iterable of segments. This class may be useful if you want to print segments outside of a __rich_console__ method. Args: segments (Iterable[Segment]): An iterable of segments. new_lines (bool, optional): Add new lines between segments. Defaults to False. FN)rbrrFcCst||_||_dSrJ)listrbr)rGrbrr@r@rA__init__s zSegments.__init__rrrconsoleoptionsrFccs8|jr(t}|jD]}|V|Vqn |jEdHdSrJ)rrBrarb)rGrrrarPr@r@rA__rich_console__s   zSegments.__rich_console__)F) r,r-r.r/rrBrMrrr@r@r@rArs rc@s:eZdZd eeeeddddZdddd d d ZdS) SegmentLinesFN)rrrFcCst||_||_dS)a=A simple renderable containing a number of lines of segments. May be used as an intermediate in rendering process. Args: lines (Iterable[List[Segment]]): Lists of segments forming lines. new_lines (bool, optional): Insert new lines after each line. Defaults to False. N)rrr)rGrrr@r@rArs zSegmentLines.__init__rrrrccsF|jr,t}|jD]}|EdH|Vqn|jD]}|EdHq2dSrJ)rrBrar)rGrrrsrar@r@rArs    zSegmentLines.__rich_console__)F) r,r-r.rr rBrMrrr@r@r@rArs r__main__)r)Syntax)Textzfrom rich.console import Console console = Console() text = Text.from_markup("Hello, [bold magenta]World[/]!") console.print(text)zHello, [bold magenta]World[/]!z rich.Segmentz]A Segment is the last step in the Rich render process before generating text with ANSI codes.z Consider the following code: pythonT) line_numberszRWhen you call [b]print()[/b], Rich [i]renders[/i] the object in to the following: zAThe Segments are then processed to produce the following output: zS You will only need to know this if you are implementing your own Rich renderables.N)7enumr functoolsr itertoolsroperatorrtypingrrrr r r r r rrcellsrrrrrreprrrrDrrrrrrrUrrrBrrr,Z rich.consoleZ rich.syntaxrZ rich.textrcode from_markuprCruleprintrrender fragmentsr@r@r@rAsd    0