U
ʗRe^ @ s d dl mZ d dlmZ d dlmZ d dlmZ d dlm Z d dl
m Z m Z m
Z
mZmZmZmZmZmZmZ ddlmZmZmZmZmZ dd lm Z m Z dd
l m Z e rdd l m!Z!m"Z"m#Z# ed Z$G d
d deZ%eee% ee%ee&e'f f ee%e&e&f f Z(e G dd deZ)G dd dZ*G dd dZ+e,dkrd dl-m!Z! d dl.m/Z/ d dl0m1Z1 dZ2e13dZ4e! Z e 5d e 6d e 6d e 6e/e2d d d e 6 e 6d! e7e 8e4Z9e 6e9 e 6 e 6d" e 6e4 e 6d# d$S )% )IntEnum) lru_cache) filterfalse) getLogger)
attrgetter)
TYPE_CHECKINGDictIterableList
NamedTupleOptionalSequenceTupleTypeUnion )_is_single_cell_widthscached_cell_lencell_lenget_character_cell_size
set_cell_size)Result rich_repr)Style)ConsoleConsoleOptions RenderResultrichc @ sP e Zd ZdZdZdZdZdZdZdZ 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_TITLE rB rB /builddir/build/BUILDROOT/alt-python38-pip-22.2.1-2.el8.x86_64/opt/alt/python38/lib/python3.8/site-packages/pip/_vendor/rich/segment.pyr # s" r c @ s* e Zd ZU dZeed< dZee ed< dZ ee
e ed< e e
dddZedd d
Zedd d Ze edd
dZeedd e
ed dddZe
ed dddZed dddZedEed ee ee ed dddZedFed eed d d d Z eed ee d d d!d"Z edGed e
ee eeee d d$d%d&Z edHe d e
ee ee d d'd(d)Z ee d e
d*d+d,Z!ee e d ee
e
f d-d.d/Z"edIe e d e
ee
ee ee e d d0d1d2Z#edJe$d e e d e
e
eee e d d3d4d5Z%edKe$d e e d e
e
eee e d d3d6d7Z&edLe$d e e d e
e
eee e d d3d8d9Z'eed ed d d:d;Z(eed ed d dd?Z*eed ed d d@dAZ+eed ee
ee d dBdCdDZ,dS )MSegmenta A 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)returnc C s | \}}}|rdS t |S )zzThe number of terminal cells required to display self.text.
Returns:
int: A number of cells.
r )r )selfrE _stylerG rB rB rC cell_lengthQ s
zSegment.cell_lengthc c s: | j V | jd kr&| jd k r6| jV n| jV | jV d S N)rE rG rF rI rB rB rC
__rich_repr__[ s
zSegment.__rich_repr__c C s
t | jS )z#Check if the segment contains text.)boolrE rM rB rB rC __bool__d s zSegment.__bool__c C s
| j dk S )z,Check if the segment contains control codes.N)rG rM rB rB rC
is_controlh s zSegment.is_controli @ )rD rD )segmentcutrH c
C s( |\}}}t }|j}||kr,||d||fS t}t|| t| } |d | }
t|
} | |kr||
||||| d ||fS | t|k r || } | d7 } | || 7 } |d | }
| |kr||
||||| d ||fS | |kr||
d | d d |||d|| d ||fS qtdd S )N r zWill never reach here)rD rK r intlenr AssertionError)
clsrR rS rE rF rG _SegmentrK cell_sizeposbeforecell_poscharrB rB rC _split_cellsm s6
zSegment._split_cells)rS rH c C sb | \}}}t |rV|t|kr.| td||fS t|d| ||t||d ||fS | | |S )a0 Split 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.
Returns:
Tuple[Segment, Segment]: Two segments.
rT N)r rW rD r` )rI rS rE rF rG rB rB rC split_cells s
zSegment.split_cellsc C s | dS )zMake a new line segment.
rB )rY rB rB rC line s z Segment.line)segmentsrF
post_stylerH c s> |}|r"|j fdd|D }r:fdd|D }|S )a Apply 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).
c 3 s, | ]$\}}}||rd n ||V qd S rL rB .0rE rJ rG )applyrY rB rC s z&Segment.apply_style..c 3 s4 | ],\}}} ||rd n|r$| n|V qd S rL rB rf )rY re rB rC ri s
)__add__)rY rd rF re result_segmentsrB )rh rY re rC apply_style s
zSegment.apply_styleF)rd rQ rH c C s$ |rt td|S ttd|S dS )a2 Filter 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.
rG N)filterr r )rY rd rQ rB rB rC filter_control s zSegment.filter_control)rd rH c
c s g }|j }|D ]d}d|jkrj|jsj|\}}}|rr|d\}} }|rR|| || | r,|V g }|j }q,q|| q|r~|V dS )a Split 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.
rb N)appendrE rG partition)
rY rd rc ro rR rE rF __textnew_linerB rB rC split_lines s
zSegment.split_linesT)rd lengthrF padinclude_new_linesrH c c s g }|j }| j}| d} |D ]}
d|
jkr|
js|
\} } }
| r| d\}}} |r`|| || |r:|||||d}|r| | |V |dd= q:q ||
q |r|||||dV dS )a Split 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.
rb )rF rv N)ro adjust_line_lengthrE rG rp )rY rd ru rF rv rw rc ro rx new_line_segmentrR rE
segment_stylerq rr rs cropped_linerB rB rC split_and_crop_lines s2
z Segment.split_and_crop_lines)rc ru rF rv rH c
C s t dd |D }||k rF|r8|| d|| |g }q|dd }n||krg }|j}d}|D ]X}|j} || |k s||jr|| || 7 }q`|\}
} } t|
|| }
|| |
| qq`n |dd }|S )a Adjust 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.
c s s | ] }|j V qd S rL )rK rg rR rB rB rC ri K s z-Segment.adjust_line_length..rU Nr )sumro rK rG r )
rY rc ru rF rv line_lengthrs ro rR segment_lengthrE rz rq rB rB rC rx 8 s(
zSegment.adjust_line_length)rc rH c s t t fdd|D S )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.
c 3 s | ]} |j V qd S rL )rE r} _cell_lenrB rC ri p s z*Segment.get_line_length..)r r~ )rY rc rB r rC get_line_lengthe s
zSegment.get_line_length)linesrH c s0 | j |r t fdd|D nd}|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.
c 3 s | ]} |V qd S rL rB rg rc r rB rC ri } s z$Segment.get_shape..r )r maxrW )rY r max_widthrB r rC get_shaper s
zSegment.get_shape)r widthheightrF new_linesrH c s |p
t |}|r$| d d gn| d g}| j |d| } fdd|D |dd< t ||k r||g|t | |S )a Set 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.
rU rb Nc s g | ]} |d qS ))rF rB r rx rF r rB rC
s z%Segment.set_shape..)rW rx extend) rY r r r rF r _heightblank shaped_linesrB r rC set_shape s & zSegment.set_shape)rY r r r rF r rH c C s` |t | }|s |dd S |d| }|r>| d| d |n | d| |}||gg| }|S )a Aligns 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.
NrU rb rW rY r r r rF r extra_linesr rB rB rC align_top s $zSegment.align_topc C s` |t | }|s |dd S |d| }|r>| d| d |n | d| |}|gg| | }|S )a Aligns 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.
NrU rb r r rB rB rC align_bottom s $zSegment.align_bottomc
C s| |t | }|s |dd S |d| }|r>| d| d |n | d| |}|d }|| } |gg| | |gg| }|S )a Aligns 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.
NrU rb r r )
rY r r r rF r r r top_lines bottom_linesrB rB rC align_middle s $ zSegment.align_middlec c sv t |}z t|}W n tk
r* Y dS X t}|D ]6}|j|jkr`|js`||j|j |j}q4|V |}q4|V dS )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
StopIterationrD rF rG rE )rY rd
iter_segments last_segmentrZ rR rB rB rC simplify s
zSegment.simplifyc c sJ |D ]@}|j s|jdkr |V q|\}}}| ||r<|dndV qdS )zRemove all links from an iterable of styles.
Args:
segments (Iterable[Segment]): An iterable segments.
Yields:
Segment: Segments with link removed.
N)rG rF update_link)rY rd rR rE rF _controlrB rB rC strip_links s
zSegment.strip_linksc c s" |D ]\}}}| |d|V qdS )zRemove all styles from an iterable of segments.
Args:
segments (Iterable[Segment]): An iterable segments.
Yields:
Segment: Segments with styles replace with None
NrB )rY rd rE rJ rG rB rB rC strip_styles) s
zSegment.strip_stylesc c sZ i }|D ]L\}}}|rF| |}|dkr6|j}|||< | |||V q| |d|V qdS )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)rY rd cacherE rF rG colorless_stylerB rB rC remove_color6 s
zSegment.remove_color)rd cutsrH c c sD g }|j }t|}t|d}|dkr(g S |dkr2q:g V qd}|j}|j} t}
|D ]} | \} }
}| rR|rl|n
||
| }||k r|| |}qR||kr|| | V | |}t|d}|dkr|r| V dS qRn6| || \}} | \} }
}|| | V | |}t|d}|dkr`|r.| V dS q`qR| V dS )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.
r N)ro r r clearcopyr ra )rY rd r split_segments add_segment iter_cutsrS r\ segments_clear
segments_copyr rR rE rJ rG end_posr] rB rB rC divideL sX
zSegment.divide)NN)F)NTT)NT)NNF)F)F)F)-r. r/ r0 r1 str__annotations__rF r r rG r
ControlCodepropertyrV rK r rN rO rP rQ classmethodr r r` ra rc r rl rn r
rt r| rx r r r r r r r r r r r r rB rB rB rC rD ? s
& (
. , "
#
rD c @ s: e Zd ZdZd
ee eddddZddd 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)rd r rH c C s t || _|| _d S rL )listrd r )rI rd r rB rB rC __init__ s
zSegments.__init__r r r consoleoptionsrH c c s8 | j r(t }| jD ]}|V |V qn | jE d H d S rL )r rD rc rd )rI r r rc rR rB rB rC __rich_console__ s
zSegments.__rich_console__)F) r. r/ r0 r1 r rD rO r r rB rB rB rC r s r c @ s: e Zd Zd eee eddddZdddd d
d ZdS )
SegmentLinesFN)r r rH c C s t || _|| _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)r r r )rI r r rB rB rC r s
zSegmentLines.__init__r r r r c c sF | j r,t }| jD ]}|E d H |V qn| jD ]}|E d H q2d S rL )r rD rc r )rI r r rs rc rB rB rC r s
z SegmentLines.__rich_console__)F) r. r/ r0 r r
rD rO r r rB rB rB rC r s
r __main__)r )Syntax)Textzfrom rich.console import Console
console = Console()
text = Text.from_markup("Hello, [bold magenta]World[/]!")
console.print(text)z Hello, [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_numberszVWhen you call [b]print()[/b], Rich [i]renders[/i] the object in to the 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):enumr functoolsr itertoolsr loggingr operatorr typingr r r r
r r r
r r r cellsr r r r r reprr r rF r r r r r logr rV r r rD r r r. pip._vendor.rich.consoleZpip._vendor.rich.syntaxr pip._vendor.rich.textr code from_markuprE ruleprintr render fragmentsrB rB rB rC sf 0
V