관리-도구
편집 파일: segment.cpython-38.pyc
U &?�f�^ � @ 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,dk�r�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 )%� )�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 �F/opt/hc_python/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 d�dd��Zed�d d �Zed�d d �Ze ed�d d��Zeed�d e ed d�dd���Ze ed d�dd�Zed d�dd��ZedEed ee ee ed d�dd��ZedFed 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 d0�d1d2��Z#edJe$d e e d e e eee e d d3�d4d5��Z%edKe$d e e d e e eee e d d3�d6d7��Z&edLe$d e e d e e eee e d d3�d8d9��Z'eed ed d �d:d;��Z(eed ed d �d<d=��Z)eed ed d �d>d?��Z*eed ed d �d@dA��Z+eed ee ee d dB�dCdD��Z,dS )M�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 | \}}}|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 | j�S )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 )�segment�cutrH c C s, |\}}}t }|j}||kr,||d||�fS t}t|| t|�d �} |d | � } t| �} | |kr�|| ||�||| d � ||�fS | t|�k �r || } | d7 } | || �7 } |d | � } | |kr�|| ||�||| d � ||�fS | |kr�|| d | d � d ||�|d|| d � ||�fS q�td��d S )N� r � zWill never reach here)rD rK r �int�lenr �AssertionError) �clsrR rS rE rF rG �_SegmentrK � cell_size�pos�before�cell_pos�charrB 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 | d�S )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 � <genexpr>� s �z&Segment.apply_style.<locals>.<genexpr>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 �_�_text�new_linerB rB rC � split_lines� s zSegment.split_linesT)rd �lengthrF �pad�include_new_linesrH c c s� g }|j }| j}| d�} |D ]�} d| jkr�| js�| \} } } | r�| �d�\}}} |r`|| || �� |r:|||||d�}|r�|� | � |V |�� q:q || � q |r�|||||d�V 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 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�||kr�g }|j}d}|D ]X}|j} || |k s||jr�||� || 7 }q`|\} } } t| || �} || | | �� q�q`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 J s z-Segment.adjust_line_length.<locals>.<genexpr>rU Nr )�sumro rK rG r ) rY rc ru rF rv � line_lengthrs ro rR �segment_lengthrE r{ rq rB rB rC rx 7 s( zSegment.adjust_line_length)rc rH c 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 o s z*Segment.get_line_length.<locals>.<genexpr>)r r~ )rY rc rB r� rC �get_line_lengthd s zSegment.get_line_length)�linesrH c s0 | j � |r t� 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� �maxrW )rY r� � max_widthrB r� rC � get_shapeq s zSegment.get_shape)r� �width�heightrF � 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 � <listcomp>� s z%Segment.set_shape.<locals>.<listcomp>)rW rx �extend) rY r� r� r� rF r� �_height�blank� 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)�iter�next� 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<|�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_styles( s zSegment.strip_stylesc c sZ i }|D ]L\}}}|rF|� |�}|dkr6|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_color5 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 )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. ���r N)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 �divideK sX zSegment.divide)NN)F)NTT)NT)NNF)F)F)F)-r. r/ r0 r1 �str�__annotations__rF r r rG r � ControlCode�propertyrV 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 edd�dd�Zddd 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 ��console�optionsrH 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 edd�dd�Zdddd �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)�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 rV r� r� rD r� r� r. �pip._vendor.rich.consoleZpip._vendor.rich.syntaxr� �pip._vendor.rich.textr� �code� from_markuprE �rule�printr� �render� fragmentsrB rB rB rC �<module> sf 0 �� U � � �