o
�J�h�` � @ 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 r^dd l m!Z!m"Z"m#Z# ed �Z$G d
d� de�Z%eee% ee%ee&e'f f ee%e&e&f f Z(e � G dd� de��Z)G dd� d�Z*G dd� d�Z+e,dkr�d dl-m!Z! d dl.m/Z/ d dl0m1Z1 dZ2e1�3d�Z4e!� Z e �5d� e �6d � e �6d � e �6e/e2d d d �� e �6� e �6d!� e7e �8e4��Z9e �6e9� e �6� e �6d"� e �6e4� e �6d#� d$S d$S )%� )�IntEnum)� lru_cache)� filterfalse)� getLogger)�
attrgetter)
�
TYPE_CHECKING�Dict�Iterable�List�
NamedTuple�Optional�Sequence�Tuple�Type�Union� )�_is_single_cell_widths�cached_cell_len�cell_len�get_character_cell_size�
set_cell_size)�Result� rich_repr)�Style)�Console�ConsoleOptions� RenderResult�richc @ 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__ZBELLZCARRIAGE_RETURN�HOMEZCLEARZ SHOW_CURSORZ HIDE_CURSORZENABLE_ALT_SCREENZDISABLE_ALT_SCREENZ CURSOR_UPZ CURSOR_DOWNZCURSOR_FORWARDZCURSOR_BACKWARDZCURSOR_MOVE_TO_COLUMNZCURSOR_MOVE_TOZ
ERASE_IN_LINEZSET_WINDOW_TITLE� r3 r3 �JC:\pinokio\api\whisper-webui.git\app\env\lib\site-packages\rich\segment.pyr # s$ r c @ s� e Zd ZU dZeed< dZee ed< dZ ee
e ed< e de
fdd��Zdefd d
�Zdefd d �Ze defd
d��Zeed�dd de
ded fdd���Zde
ded fdd�ZedHdd��Ze dIded dee dee ded fdd ��Ze dJded d eded fd d ��Z eded dee d fd!d"��Z e # #dKded d$e
dee d%ed&edee d f d'd(��Z e #dLd)e d d$e
dee d%ede d f
d*d+��Z ed)e d de
fd,d-��Z!ed.e e d dee
e
f fd/d0��Z"e dMd.e e d d1e
d2ee
dee d3ede e d f d4d5��Z#e dJd6e$d d.e e d d1e
d2e
ded3ede e d fd7d8��Z%e dJd6e$d d.e e d d1e
d2e
ded3ede e d fd9d:��Z&e dJd6e$d d.e e d d1e
d2e
ded3ede e d fd;d<��Z'eded ded fd=d>��Z(eded ded fd?d@��Z)eded ded fdAdB��Z*eded ded fdCdD��Z+eded dEee
dee d fdFdG��Z,dS )N�Segmenta� 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.
�textN�style�control�returnc C s | \}}}|r dS t |�S )zzThe number of terminal cells required to display self.text.
Returns:
int: A number of cells.
r )r )�selfr6 �_styler8 r3 r3 r4 � cell_lengthQ s
zSegment.cell_lengthc c sB � | j V | jd u r| jd ur| jV d S d S | jV | jV d S �N)r6 r8 r7 �r: r3 r3 r4 �
__rich_repr__[ s �
� zSegment.__rich_repr__c C s
t | j�S )z#Check if the segment contains text.)�boolr6 r> r3 r3 r4 �__bool__d s
zSegment.__bool__c C s
| j duS )z,Check if the segment contains control codes.N)r8 r> r3 r3 r4 �
is_controlh s
zSegment.is_controli @ �segment�cut)r5 r5 c
C s> |\}}}t }|j}||kr||d||�fS t}t|| t|� �} |d| � }
t|
�} | | } | sC||
||�||| d� ||�fS | dkri||| �dkri||d| � d ||�|d|| d d� ||�fS | dkr�||| d �dkr�||d| d � d ||�|d|| d� ||�fS | |k r�| d7 } n| d8 } q#)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.
� TN�����r � r )r5 r< r �int�lenr )
�clsrC rD r6 r7 r8 �_Segmentr< � cell_size�pos�beforeZcell_posZout_byr3 r3 r4 � _split_cellsm s6
�� �
�zSegment._split_cellsc C sn | \}}}|dks J �t |�r1|t|�kr | td||�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 rE N)r rI r5 rO )r: rD r6 r7 r8 r3 r3 r4 � split_cells� s
� zSegment.split_cellsc C s | d�S )zMake a new line segment.�
r3 )rJ r3 r3 r4 �line� s z Segment.line�segments�
post_stylec 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. � | ]\}}}�||r
d n� |�|�V qd S r= r3 ��.0r6 r; r8 )�applyrJ r3 r4 � <genexpr>� s
� �
�z&Segment.apply_style.<locals>.<genexpr>c 3 s6 � | ]\}}}� ||r
d n|r|� n�|�V qd S r= r3 rU )rJ rT r3 r4 rX � s �
���
�)�__add__)rJ rS r7 rT Zresult_segmentsr3 )rW rJ rT r4 � apply_style� s �
� zSegment.apply_styleFrB c C s |r t td�|�S ttd�|�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.
r8 )�filterr r )rJ rS rB r3 r3 r4 �filter_control� s zSegment.filter_controlc
c s� � g }|j }|D ]3}d|jv r7|js7|\}}}|r6|�d�\}} }|r*|| ||�� | r4|V g }|j }|sq||� q|rC|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.
rQ N)�appendr6 r8 � partition)
rJ rS rR r] rC r6 r7 �_�_text�new_liner3 r3 r4 � split_lines� s( �
��
�zSegment.split_linesT�length�pad�include_new_linesc c s� � g }|j }| j}| d�} |D ]A}
d|
jv rL|
jsL|
\} } }
| rK| �d�\}}} |r1|| || �� |rI|||||d�}|rB|� | � |V |�� | s q||
� q|r^|||||d�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.
rQ )r7 rd N)r] �adjust_line_lengthr6 r8 r^ �clear)rJ rS rc r7 rd re rR r] rf Znew_line_segmentrC r6 �
segment_styler_ r` ra Z cropped_liner3 r3 r4 �split_and_crop_lines s4 �
�
��
�z Segment.split_and_crop_linesrR c
C s� t dd� |D ��}||k r%|r || d|| |�g }|S |dd� }|S ||krag }|j}d}|D ],}|j} || |k s@|jrI||� || 7 }q2|\}
} } t|
|| �}
|| |
| �� |S |S |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 r= )r< )rV rC r3 r3 r4 rX X s � z-Segment.adjust_line_length.<locals>.<genexpr>rG Nr )�sumr] r< r8 r )
rJ rR rc r7 rd Z line_lengthra r] rC Zsegment_lengthr6 rh r_ r3 r3 r4 rf E s. ��
�zSegment.adjust_line_lengthc s t � t� fdd�|D ��S )z�Get 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" � | ] \}}}|s� |�V qd S r= r3 )rV r6 r7 r8 �� _cell_lenr3 r4 rX } s � z*Segment.get_line_length.<locals>.<genexpr>)r rj )rJ rR r3 rk r4 �get_line_lengthr s
zSegment.get_line_length�linesc s0 | j � |rt� fdd�|D ��nd}|t|�fS )z�Get 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 r= r3 �rV rR �rm r3 r4 rX � s � z$Segment.get_shape.<locals>.<genexpr>r )rm �maxrI )rJ rn � max_widthr3 rp r4 � get_shape s
zSegment.get_shape�width�height� new_linesc s� |pt |�}|r| d� d ��gn| d� ��g}| j� |d|� }� ��fdd�|D �|dd�< t |�|k rD|�|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.
rG rQ Nc s g | ] }� |��d ��qS ))r7 r3 ro �rf r7 rt r3 r4 �
<listcomp>� s �z%Segment.set_shape.<locals>.<listcomp>)rI rf �extend) rJ rn rt ru r7 rv �_height�blankZ shaped_linesr3 rw r4 � set_shape� s &� � zSegment.set_shaperJ 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.
NrG rQ �rI �rJ rn rt ru r7 rv � extra_linesr{ r3 r3 r4 � align_top� � $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.
NrG rQ r} r~ r3 r3 r4 � align_bottom� r� 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.
NrG rQ r r} )
rJ rn rt ru r7 rv r r{ Z top_linesZ bottom_linesr3 r3 r4 � align_middle� s $ zSegment.align_middlec c sv � t |�}zt|�}W n
ty Y dS w t}|D ]}|j|jkr0|js0||j|j |j�}q|V |}q|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)�iter�next�
StopIterationr5 r7 r8 r6 )rJ rS �
iter_segmentsZ last_segmentrK rC r3 r3 r4 �simplify
s �
��
zSegment.simplifyc c sL � |D ] }|j s
|jdu r|V q|\}}}| ||r |�d�nd�V qdS )z�Remove all links from an iterable of styles.
Args:
segments (Iterable[Segment]): An iterable segments.
Yields:
Segment: Segments with link removed.
N)r8 r7 � update_link)rJ rS rC r6 r7 �_controlr3 r3 r4 � strip_links% s �
�zSegment.strip_linksc c s$ � |D ] \}}}| |d|�V qdS )z�Remove all styles from an iterable of segments.
Args:
segments (Iterable[Segment]): An iterable segments.
Yields:
Segment: Segments with styles replace with None
Nr3 )rJ rS r6 r; r8 r3 r3 r4 � strip_styles6 s �
�zSegment.strip_stylesc c s\ � i }|D ]&\}}}|r$|� |�}|du r |j}|||< | |||�V q| |d|�V qdS )z�Remove all color from an iterable of segments.
Args:
segments (Iterable[Segment]): An iterable segments.
Yields:
Segment: Segments with colorless style.
N)�get�
without_color)rJ rS �cacher6 r7 r8 Zcolorless_styler3 r3 r4 � remove_colorC s �
�zSegment.remove_color�cutsc c sF � g }|j }t|�} t|d�}|dkrdS |dkrng V q d}|j}|j} t}
|D ]q} | \} }
}| r�|r8|n||
| � }||k rI|| � |}nS||krm|| � | � V |� |}t|d�}|dkrl|ri| � V dS n/| �|| �\}} | \} }
}||� | � V |� |}t|d�}|dkr�|r�| � V dS | s4q+| � V dS )z�Divides 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.
TrF Nr )r] r� r� rg �copyr rP )rJ rS r� Zsplit_segmentsZ add_segmentZ iter_cutsrD rM Zsegments_clearZ
segments_copyrl rC r6 r; r8 Zend_posrN r3 r3 r4 �divideY sb �
�
�� #zSegment.divide)r9 r5 )NN�F)NTT)NT)NNF)-r. r/ r0 r1 �str�__annotations__r7 r r r8 r
� ControlCode�propertyrH r< r r? r@ rA rB � classmethodr r rO rP rR r rZ r\ r
rb ri rf rm rs r| r r� r� r� r� r� r� r� r� r3 r3 r3 r4 r5 ? s>
/ ���� �(��� � ������
�.����� �, $
�
�����
�#��
�����
� ��
�����
� ��
�����
� ��
�r5 c @ sB e Zd ZdZddee deddfdd�Z
ddd�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.
FrS rv r9 Nc C s t |�| _|| _d S r= )�listrS rv )r: rS rv r3 r3 r4 �__init__� s
zSegments.__init__�consoler �optionsr r c c s< � | j rt�� }| jD ]}|V |V q d S | jE d H d S r= )rv r5 rR rS )r: r� r� rR rC r3 r3 r4 �__rich_console__� s �
�zSegments.__rich_console__r� �r� r r� r r9 r ) r. r/ r0 r1 r r5 r@ r� r� r3 r3 r3 r4 r� � s ���r� c @ sB e Zd Zddeee deddfdd�Z
dd
d�ZdS )� SegmentLinesFrn rv r9 Nc 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� rn rv )r: rn rv r3 r3 r4 r� � s
zSegmentLines.__init__r� r r� r r c c sJ � | j rt�� }| jD ]
}|E d H |V q d S | jD ]}|E d H qd S r= )rv r5 rR rn )r: r� r� ra rR r3 r3 r4 r� � s �
�
�z SegmentLines.__rich_console__r� r� ) r. r/ r0 r r
r5 r@ r� r� r3 r3 r3 r4 r� � s ���r� �__main__)r )�Syntax)�Textz�from 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)Z 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 r7 r r� r r r �logr rH r� r� r5 r� r� r. � rich.console� rich.syntaxr� � rich.textr� �code� from_markupr6 �rule�printr� �render� fragmentsr3 r3 r3 r4 �<module> sj 0
�� c
�
�
��