File: //usr/local/lib/python3.10/dist-packages/pip/_vendor/rich/__pycache__/segment.cpython-310.pyc
o
��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__�BELL�CARRIAGE_RETURN�HOME�CLEAR� SHOW_CURSOR� HIDE_CURSOR�ENABLE_ALT_SCREEN�DISABLE_ALT_SCREEN� CURSOR_UP� CURSOR_DOWN�CURSOR_FORWARD�CURSOR_BACKWARD�CURSOR_MOVE_TO_COLUMN�CURSOR_MOVE_TO�
ERASE_IN_LINE�SET_WINDOW_TITLE� rB rB �C/usr/local/lib/python3.10/dist-packages/pip/_vendor/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 )�selfrE �_stylerG rB rB rC � 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)rE rG rF �rI rB rB rC �
__rich_repr__[ s �
� zSegment.__rich_repr__c C s
t | j�S )z#Check if the segment contains text.)�boolrE rM rB rB rC �__bool__d s
zSegment.__bool__c C s
| j duS )z,Check if the segment contains control codes.N)rG rM rB rB rC �
is_controlh s
zSegment.is_controli @ �segment�cut)rD rD 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 )rD rK r �int�lenr )
�clsrR rS rE rF rG �_SegmentrK � cell_size�pos�before�cell_pos�out_byrB rB rC � _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 rT N)r rX rD r` )rI rS rE rF rG rB rB rC � split_cells� s
� zSegment.split_cellsc C s | d�S )zMake a new line segment.�
rB )rY rB rB rC �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 rL rB ��.0rE rJ rG )�applyrY rB rC � <genexpr>� s
� �
�z&Segment.apply_style.<locals>.<genexpr>c 3 s6 � | ]\}}}� ||r
d 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_styleFrQ 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.
rG )�filterr r )rY rd rQ rB rB rC �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.
rb N)�appendrE rG � partition)
rY rd rc ro rR rE rF �_�_text�new_linerB rB rC � 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.
rb )rF rv N)ro �adjust_line_lengthrE rG rp �clear)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 s4 �
�
��
�z Segment.split_and_crop_linesrc 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 rL )rK )rg rR rB rB rC ri X s � z-Segment.adjust_line_length.<locals>.<genexpr>rV Nr )�sumro rK rG r )
rY rc ru rF rv � line_lengthrs ro rR �segment_lengthrE r{ rq rB rB rC rx 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 rL rB )rg rE rF rG �� _cell_lenrB rC ri } s � z*Segment.get_line_length.<locals>.<genexpr>)r r~ )rY rc rB r� rC �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 rL rB �rg rc �r� rB rC ri � s � z$Segment.get_shape.<locals>.<genexpr>r )r� �maxrX )rY r� � max_widthrB r� rC � 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.
rV rb Nc s g | ] }� |��d ��qS ))rF rB r� �rx rF r� rB rC �
<listcomp>� s �z%Segment.set_shape.<locals>.<listcomp>)rX rx �extend) rY r� r� r� rF r� �_height�blank� shaped_linesrB r� rC � set_shape� s &� � zSegment.set_shaperY 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.
NrV rb �rX �rY r� r� r� rF r� � extra_linesr� rB rB rC � 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.
NrV rb r� r� rB rB rC � 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.
NrV 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 |�}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�
StopIterationrD rF rG rE )rY rd �
iter_segments� last_segmentrZ rR rB rB rC �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)rG rF � update_link)rY rd rR rE rF �_controlrB rB rC � 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
NrB )rY rd rE rJ rG rB rB rC � 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)rY rd �cacherE rF rG �colorless_stylerB rB rC � 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.
TrU Nr )ro r� r� ry �copyr ra )rY rd r� �split_segments� add_segment� iter_cutsrS r\ �segments_clear�
segments_copyr� rR rE rJ rG �end_posr] rB rB rC �divideY sb �
�
�� #zSegment.divide)rH rD )NN�F)NTT)NT)NNF)-r. r/ r0 r1 �str�__annotations__rF r r rG r
� ControlCode�propertyrW 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 @ 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.
Frd r� rH Nc C s t |�| _|| _d S rL )�listrd r� )rI rd r� rB rB rC �__init__� s
zSegments.__init__�consoler �optionsr r c c s< � | j rt�� }| jD ]}|V |V q d S | jE d H d S rL )r� rD rc rd )rI r� r� rc rR rB rB rC �__rich_console__� s �
�zSegments.__rich_console__r� �r� r r� r rH r ) r. r/ r0 r1 r rD rO r� r� rB rB rB rC r� � s ���r� c @ sB e Zd Zddeee deddfdd�Z
dd
d�ZdS )� SegmentLinesFr� r� rH 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� r� r� )rI r� r� rB rB rC 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 rL )r� rD rc r� )rI r� r� rs rc rB rB rC r� � s �
�
�z SegmentLines.__rich_console__r� r� ) r. r/ r0 r r
rD rO r� r� rB rB rB rC 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)� 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 rF r r� r r r �logr rW r� r� rD r� r� r. �pip._vendor.rich.console�pip._vendor.rich.syntaxr� �pip._vendor.rich.textr� �code� from_markuprE �rule�printr� �render� fragmentsrB rB rB rC �<module> sj 0
�� c
�
�
��