$&x| D 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 r
dd l m!Z!m"Z"m#Z# ed Z$ G d
de Z%eee% ee%ee&e'f f ee%e&e&f f Z( e G d de Z) G d d Z* G d d Z+e,dk r?d dl-m!Z! d dl.m/Z/ d dl0m1Z1 dZ2 e1j3 d Z4 e! Z e 5 d e 6 d e 6 d e 6 e/e2d d e 6 e 6 d! e7e 8 e4 Z9e 6 e9 e 6 e 6 d" e 6 e4 e 6 d# d$S 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 R 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 x/builddir/build/BUILD/imunify360-venv-2.6.2/opt/imunify360/venv/lib/python3.11/site-packages/pip/_vendor/rich/segment.pyr r # sj NN DO D
EKKIKNO NMrE r c X e Zd ZU dZeed< dZee ed< dZ ee
e ed< e de
fd ZdefdZdefd Ze defd
Ze ed d d d
e
ded fd Zd
e
ded fdZed1d Ze d2ded dee dee ded fd Ze d3ded deded fd Z eded dee d fd Z e d4ded de
dee ded edee d f d Z e d5d e d de
dee dede d f
d Z ed e d de
fd Z!ed!e e d dee
e
f fd" Z"e d6d!e e d d#e
d$ee
dee d%ede e d f d& Z#e d3d'e$d d!e e d d#e
d$e
ded%ede e d fd( Z%e d3d'e$d d!e e d d#e
d$e
ded%ede e d fd) Z&e d3d'e$d d!e e d d#e
d$e
ded%ede e d fd* Z'eded ded fd+ Z(eded ded fd, Z)eded ded fd- Z*eded ded fd. Z+eded d/ee
dee d fd0 Z,dS )7Segmenta 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.
textNstylecontrolreturnc 4 | \ }}}|rdnt | S )zzThe number of terminal cells required to display self.text.
Returns:
int: A number of cells.
r )r )selfrI _stylerK s rF cell_lengthzSegment.cell_lengthQ s% !% fg/qq$ /rE c # v K | j V | j | j | j V d S d S | j V | j V d S N)rI rK rJ rN s rF
__rich_repr__zSegment.__rich_repr__[ sa i < z%j &% * , rE c * t | j S )z#Check if the segment contains text.)boolrI rS s rF __bool__zSegment.__bool__d s DI rE c | j duS )z,Check if the segment contains control codes.N)rK rS s rF
is_controlzSegment.is_controlh s |4''rE i @ segmentcut)rH rH c |\ }}}t }|j }||k r| |d|| fS t }t ||z t | z } |d| }
t |
} | |z
} | s" ||
|| ||| d || fS | dk rH ||| dk r3 ||d| dz || |d|| dz d z || fS | dk rK ||| dz
dk r3 ||d| dz
dz || |d|| d z || fS | |k r| dz
} n| dz } )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.
TNr! r )rH rP r intlenr )
clsrZ r[ rI rJ rK _SegmentrP cell_sizeposbeforecell_posout_bys
rF _split_cellszSegment._split_cellsm s ' eW ) + HHR 8 88 8+ 3$D 122 $3$ZF ''H ^F
HVUG44 HT#$$Z88 || $s) 4 4 9 9 HT$3$Z# -ug>> HS4a ? 2E7CC || $sQw- 8 8A = = HT)C!G)_s 2E7CC HS4: -ug>> #~~qq- rE c | \ }}}|dk sJ t | rX|t | k r| t d|| fS t |d| || t ||d || fS | | | S )ax 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.
Args:
cut (int): Offset within the segment to cut.
Returns:
Tuple[Segment, Segment]: Two segments.
r r] N)r ra rH ri )rN r[ rI rJ rK s rF split_cellszSegment.split_cells s $ eWaxxxx !$ ' ' c$ii WR 8 888TcT
E733STT
E733
s+++rE c | d S )zMake a new line segment.
rD )rb s rF linez Segment.line s s4yyrE segments
post_stylec b |}|r|j fd|D }r fd|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 T K | ]"\ }}} ||rd n
| | V #d S rR rD ).0rI rO rK applyrb s rF z&Segment.apply_style.. s\ )D&' D'<$$uuV}}gFF rE c 3 P K | ] \ }}} ||rd n|r|z n| V !d S rR rD )rs rI rO rK rb rp s rF ru z&Segment.apply_style.. sr *D&' #M5; Kfz 1 1 rE )__add__)rb ro rJ rp result_segmentsrt s ` ` @rF apply_stylezSegment.apply_style s & # ME -< O .= O rE FrY c z |r t t d | S t t d | S )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.
rK )filterr r )rb ro rY s rF filter_controlzSegment.filter_control s= @*Y//:: : z) 4 4h?? ?rE c # K g }|j }|D ]g}d|j v rQ|j sJ|\ }}}|rA| d \ }} }|r | | || | r
|V g }|j }|A\ || h|r|V dS 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.
rm N)appendrI rK partition)
rb ro rn r~ rZ rI rJ __textnew_lines
rF split_lineszSegment.split_lines s ! Gw|##GO#!(eQ -,0NN4,@,@)E8T 2 ss5% 0 0111 - "
!!% - w JJJJJ rE Tlengthpadinclude_new_linesc # K g }|j }| j } | d } |D ]}
d|
j v r|
j s{|
\ } } }
| rr| d \ }}} |r | | || |r> ||||| }|r| | |V | | r ||
|r ||||| V dS 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.
rm )rJ r N)r~ adjust_line_lengthrI rK r clear)rb ro r rJ r r rn r~ r new_line_segmentrZ rI
segment_styler r r cropped_lines rF split_and_crop_linesz Segment.split_and_crop_lines sV * ! 3 3t99 Gw|##GO#)0&mQ %,0NN4,@,@)E8T : ss5- 8 8999 %'9'9 &3( ( ( - B ( / /0@ A A A ****
% w I$$T6CHHH H H H H H I IrE rn c z t d |D }||k r$|r| | d||z
z | gz }n|dd }nw||k rgg }|j }d}|D ]X}|j } || z |k s|j r || || z
}*|\ }
} } t |
||z
}
| | |
| 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 3 $ K | ] }|j V d S rR )rP )rs rZ s rF ru z-Segment.adjust_line_length..X s% BB''-BBBBBBrE r_ Nr )sumr~ rP rK r )
rb rn r rJ r line_lengthr r~ rZ segment_lengthrI r r s
rF r zSegment.adjust_line_lengthE s & BBTBBBBB
# 33sf{.B'CU#K#K"LL 7
6
!
!H _FK
!(!4 /&88GO8F7OOO >1KK-4*D-(v /CDDDF33t]33444AAAwHrE c H t t fd|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 : K | ]\ }}}| | V d S rR rD )rs rI rJ rK _cell_lens rF ru z*Segment.get_line_length..} s7 SS';tUG7S99T??SSSSSSrE )r r )rb rn r s @rF get_line_lengthzSegment.get_line_lengthr s- SSSStSSSSSSrE linesc r | j |rt fd|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 . K | ]} | V d S rR rD )rs rn r s rF ru z$Segment.get_shape.. s- @@$--@@@@@@rE r )r maxra )rb r max_widthr s @rF get_shapezSegment.get_shape sJ -DIPC@@@@%@@@@@@q 3u::&&rE widthheight new_linesc < |pt | }|r | dz dz gn | dz g}| j |d| } fd|D |dd< t | |k r)| |g|t | z
z |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.
r_ rm Nc , g | ]} | S ))rJ rD )rs rn r rJ r s rF
z%Segment.set_shape.. s9
=A tU% 8 8 8
rE )ra r extend)
rb r r r rJ r _heightblank shaped_linesr s
` ` @rF set_shapezSegment.set_shape s * &CJJ 1: XSSut#U
+
+ , ,C%KQV@W@W?X ! 3 XgX
EJ
QQQ | w & & 7S 5F5F+F G H H HrE rb c |t | z
}|s
|dd S |d| }|r | d|z dz | n | d|z | }||gg|z z }|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.
Nr_ rm ra rb r r r rJ r extra_linesr s rF align_topzSegment.align_top s * s5zz) 8Ogvg2;XC%K$&...S5[RWAXAX% K// rE c |t | z
}|s
|dd S |d| }|r | d|z dz | n | d|z | }|gg|z |z }|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.
Nr_ rm r r s rF align_bottomzSegment.align_bottom s * s5zz) 8Ogvg2;XC%K$&...S5[RWAXAX K'%/ rE c |t | z
}|s
|dd S |d| }|r | d|z dz | n | d|z | }|dz }||z
} |gg|z |z |gg| z z }|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.
Nr_ rm r! r )
rb r r r rJ r r r top_lines bottom_liness
rF align_middlezSegment.align_middle s * s5zz) 8Ogvg2;XC%K$&...S5[RWAXAX 1$ "Y. I%-% L0HH rE c # K t | } t | }n# t $ r Y dS w xY wt }|D ]>}|j |j k r&|j s ||j |j z |j }8|V |}?|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
StopIterationrH rJ rK rI )rb ro
iter_segments last_segmentrc rZ s rF simplifyzSegment.simplify
s X
..LL FF $ ' 'G!W]227?2 'x % 4l6H #""" & s #
11c # K |D ]@}|j s|j |V |\ }}} | ||r| d nd V AdS )zRemove all links from an iterable of styles.
Args:
segments (Iterable[Segment]): An iterable segments.
Yields:
Segment: Segments with link removed.
N)rK rJ update_link)rb ro rZ rI rJ _controls rF strip_linkszSegment.strip_links% s L LG
L'-"7
(/%eXc$5 J 1 1$ 7 7 7dKKKKKK L LrE c # : K |D ]\ }}} | |d| V dS )zRemove all styles from an iterable of segments.
Args:
segments (Iterable[Segment]): An iterable segments.
Yields:
Segment: Segments with styles replace with None
NrD )rb ro rI rO rK s rF strip_styleszSegment.strip_styles6 sE &. + + !D&'#dD'** * * * * + +rE c # K i }|D ]J\ }}}|r3| | }| |j }|||< | ||| V ; | |d| V KdS )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)rb ro cacherI rJ rK colorless_styles rF remove_colorzSegment.remove_colorC s %'$, / / D%
/"'))E"2"2"*&+&9O#2E%Lc$999999c$g...... / /rE cutsc # K g }|j }t | } t |d }|dk rdS |dk rng V $d}|j }|j } t
}
|D ]} | \ } }
}| r|r|n
| |
| z }||k r || |}n||k rK || | V | |}t |d }|dk r|r | V dS nm| ||z
\ }} | \ } }
} || | V | |}t |d }|dk r|r | V dS | | 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.
Tr^ Nr )r~ r r r copyr rk )rb ro r split_segments add_segment iter_cutsr[ re segments_clear
segments_copyr rZ rI rO rK end_posrf s rF dividezSegment.divideY s +-$+ JJ y"%%CbyyaxxHHH
'-&+
# # # G$+ !D&' !
!(C##cIIdOO.CS== K(((!Cc>> K((('-//)))"N$$$!C y"--Cbyy) 2"/-// 1 1 1 '.&9&9#)&D&DOFG,3)D&' K''''-//)))"N$$$ C9b))"99% . +moo---FFC !
F moo rE )rL rH )NNF)NTT)NT)NNF)-r0 r1 r2 r3 str__annotations__rJ r
r rK r ControlCodepropertyr` rP r rT rV rW rY classmethodr r ri rk rn r
ry r| r r r r r r r r r r r r r r r r rD rE rF rH rH ? s
III !E8E?!!!/3GXh{+
,333
0S 0 0 0 X0 v $ (D ( ( ( X( Yy-9 -3 -5AU;V - - - [-^,s ,u-A'B , , , ,4 [ "&&* & & 9%& & UO &
) & & & [& P ?D@ @ *@8<@ ) @ @ @ [@$ 8I#6 8DO;T [8
"&"&
,I ,I9%,I ,I ,I
,I
,I
$y/ ",I ,I ,I [,I\
"& * *9o* * *
*
i
* * * [*X
T4 ?
Ts
T
T
T [
T 'd4 ? 3 'c3h ' ' ' [ '
!%!%
! ! DO$! !
!
!
!
d9o ! ! ! [! F
)_DO$
d9o [8
)_DO$
d9o [8
)_ DO$
d9o [ < 3 8K [4 L8I#6 L8I;N L L L [L
+HY$7
+HY %<<>>D =
} $ $ $ $ $ $ $ $ $rE r r r r r rL r ) r0 r1 r2 r3 r
rH rV r r rD rE rF r r s~ # #'!2 #t #PT # # # # % %+; % % % % % % %rE r c P e Zd Zd
deee deddfdZ dd ZdS ) SegmentLinesFr r rL Nc < 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 )rN r r s rF r zSegmentLines.__init__ s %[[
"rE r r r r r c # K | j r1t }| j D ]}|E d {V |V d S | j D ]
}|E d {V d S rR )r rH rn r )rN r r r rn s rF r z SegmentLines.__rich_console__ s > ||~~H
rE r r ) r0 r1 r2 r
r rH rV r r rD rE rF r r sx # #htG} 5 #$ #SW # # # #
+;
rE 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_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):enumr functoolsr itertoolsr loggingr operatorr typingr r r
r r r
r r r r cellsr r r r r reprr r rJ r r r r r logr r` r r rH r r r0 pip._vendor.rich.consolepip._vendor.rich.syntaxr pip._vendor.rich.textr code from_markuprI ruleprintr render fragmentsrD rE rF r s ! ! ! ! ! ! $ # # # # # # # ?>>>>>>>>>>i ' * + +uS#X
&' +sC
" \ \ \ \ \ j \ \
\ ~% % % % % % % %2 2 z000000......****** D
4 < = =DgiiG LL MMg MM4555 MM&&xd;;;<<< MMOOO MM] W^^D))**I MM) MMOOO MMVWWW MM$ MM^ ; rE