o
    lôjŒd  ã                   @   sè  d dl mZ d dlmZ d dlmZ d dlmZ d dlm	Z	m
Z
mZmZmZmZmZmZmZmZ ddlmZmZmZmZmZ ddlmZmZ dd	lmZ e	rXdd
lmZm Z m!Z! G dd„ deƒZ"eee" ee"ee#e$f f ee"e#e#f f Z%eƒ G dd„ deƒƒZ&G dd„ dƒZ'G dd„ dƒZ(e)dkròd dl*mZ d dl+m,Z, d dl-m.Z. dZ/e. 0d¡Z1eƒ Ze 2d¡ e 3d¡ e 3d¡ e 3e,e/ddd�¡ e 3¡  e 3d¡ e4e 5e1¡ƒZ6e 3e6¡ e 3¡  e 3d ¡ e 3e1¡ e 3d!¡ d"S d"S )#é    )ÚIntEnum)Ú	lru_cache)Úfilterfalse)Ú
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ÚRenderResultc                   @   sP   e Zd ZdZdZdZdZdZdZdZ	dZ
d	Zd
ZdZdZdZdZdZdZdZdS )ÚControlTypezDNon-printable control codes which typically translate to ANSI codes.r   é   é   é   é   é   é   é   é	   é
   é   é   é   é   é   é   N)Ú__name__Ú
__module__Ú__qualname__Ú__doc__ZBELLZCARRIAGE_RETURNÚHOMEZCLEARZSHOW_CURSORZHIDE_CURSORZENABLE_ALT_SCREENZDISABLE_ALT_SCREENZ	CURSOR_UPZCURSOR_DOWNZCURSOR_FORWARDZCURSOR_BACKWARDZCURSOR_MOVE_TO_COLUMNZCURSOR_MOVE_TOZERASE_IN_LINEZSET_WINDOW_TITLE© r1   r1   ú]/var/www/html/academy/tools/voices/clone/sv-venv/lib/python3.10/site-packages/rich/segment.pyr       s$    r   c                   @   sÎ  e Zd ZU dZeed< dZee ed< dZ	ee
e  ed< edefdd„ƒZdefd	d
„Zdefdd„Zedefdd„ƒZeedƒdd deded fdd„ƒƒZdeded fdd„ZedJdd„ƒZe		dKded  dee dee ded  fdd„ƒZe	dLded  deded  fdd „ƒZeded  deed   fd!d"„ƒZeded  deeed  ef  fd#d$„ƒZe		%	%dMded  d&edee d'ed(edeed   fd)d*„ƒZ e		%dNd+ed  d&edee d'eded  f
d,d-„ƒZ!ed+ed  defd.d/„ƒZ"ed0eed   deeef fd1d2„ƒZ#e			dOd0eed   d3ed4ee dee d5edeed   fd6d7„ƒZ$e	dLd8e%d  d0eed   d3ed4eded5edeed   fd9d:„ƒZ&e	dLd8e%d  d0eed   d3ed4eded5edeed   fd;d<„ƒZ'e	dLd8e%d  d0eed   d3ed4eded5edeed   fd=d>„ƒZ(eded  ded  fd?d@„ƒZ)eded  ded  fdAdB„ƒZ*eded  ded  fdCdD„ƒZ+eded  ded  fdEdF„ƒZ,eded  dGee deed   fdHdI„ƒZ-dS )PÚ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	dS t |ƒS )zzThe number of terminal cells required to display self.text.

        Returns:
            int: A number of cells.
        r   )r   )Úselfr4   Ú_styler6   r1   r1   r2   Úcell_lengthN   s   
zSegment.cell_lengthc                 c   sB   � | j V  | jd u r| jd ur| jV  d S d S | jV  | jV  d S ©N)r4   r6   r5   ©r8   r1   r1   r2   Ú__rich_repr__X   s   €

ÿzSegment.__rich_repr__c                 C   s
   t | jƒS )z#Check if the segment contains text.)Úboolr4   r<   r1   r1   r2   Ú__bool__a   s   
zSegment.__bool__c                 C   s
   | j duS )z,Check if the segment contains control codes.N)r6   r<   r1   r1   r2   Ú
is_controle   s   
zSegment.is_controli @  ÚsegmentÚcut)r3   r3   c                 C   s>  |\}}}t }|j}||kr||d||ƒfS t}t|| t|ƒ ƒ}		 |d|	… }
t|
ƒ}|| }|sC||
||ƒ|||	d… ||ƒfS |dkri|||	 ƒdkri||d|	… d ||ƒ|d||	d d…  ||ƒfS |dkr‘|||	d  ƒdkr‘||d|	d … d ||ƒ|d||	d…  ||ƒfS ||k rš|	d7 }	n|	d8 }	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   )r3   r:   r   ÚintÚlenr   )ÚclsrA   rB   r4   r5   r6   Ú_Segmentr:   Ú	cell_sizeÚposÚbeforeZcell_posZout_byr1   r1   r2   Ú_split_cellsj   s6   

þþþ
êzSegment._split_cellsc                 C   sn   | \}}}|dksJ ‚t |ƒr1|t|ƒkr| td||ƒfS t|d|… ||ƒt||d… ||ƒfS |  | |¡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   rC   N)r   rG   r3   rM   )r8   rB   r4   r5   r6   r1   r1   r2   Úsplit_cells›   s   
þzSegment.split_cellsc                 C   s   | dƒS )zMake a new line segment.Ú
r1   )rH   r1   r1   r2   Úlineµ   s   zSegment.lineÚsegmentsÚ
post_stylec                    s>   |}|r|j ‰ ‡ ‡fdd„|D ƒ}ˆr‡‡fdd„|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  qd S r;   r1   ©Ú.0r4   r9   r6   )ÚapplyrH   r1   r2   Ú	<genexpr>Ð   s
   € ÿ
ÿz&Segment.apply_style.<locals>.<genexpr>c                 3   s6   � | ]\}}}ˆ ||rd n|r|ˆ nˆ|ƒV  qd S r;   r1   rS   )rH   rR   r1   r2   rV   Õ   s   € 
÷ÿù
ÿ)Ú__add__)rH   rQ   r5   rR   Zresult_segmentsr1   )rU   rH   rR   r2   Úapply_styleº   s   þ
özSegment.apply_styleFr@   c                 C   s    |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.

        r6   )Úfilterr   r   )rH   rQ   r@   r1   r1   r2   Úfilter_controlã   s   zSegment.filter_controlc           
      c   sŠ   � g }|j }|D ]3}d|jv r7|js7|\}}}|r6| d¡\}}	}|r*|| ||ƒƒ |	r4|V  g }|j }|sq||ƒ q|rC|V  dS dS )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.
        rO   N©Úappendr4   r6   Ú	partition©
rH   rQ   rP   r\   rA   r4   r5   Ú_Ú_textÚnew_liner1   r1   r2   Úsplit_linesö   s(   €

ù€
	
ÿzSegment.split_linesc           
      c   s’   � g }|j }|D ]5}d|jv r9|js9|\}}}|r8| d¡\}}	}|r*|| ||ƒƒ |	r6|dfV  g }|j }|sq||ƒ q|rG|dfV  dS dS )a2  Split a sequence of segments in to a list of lines and a boolean to indicate if there was a new line.

        Args:
            segments (Iterable[Segment]): Segments potentially containing line feeds.

        Yields:
            Iterable[List[Segment]]: Iterable of segment lists, one per line.
        rO   TFNr[   r^   r1   r1   r2   Úsplit_lines_terminator  s(   €

ù€
	ÿzSegment.split_lines_terminatorTÚlengthÚpadÚinclude_new_linesc                 c   sÀ   � g }|j }| j}| dƒ}	|D ]A}
d|
jv rL|
jsL|
\}}}|rK| d¡\}}}|r1|| ||ƒƒ |rI|||||d�}|rB|  |	¡ |V  | ¡  |s q||
ƒ q|r^|||||d�V  dS dS )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.
        rO   )r5   re   N)r\   Úadjust_line_lengthr4   r6   r]   Úclear)rH   rQ   rd   r5   re   rf   rP   r\   rg   Znew_line_segmentrA   r4   Úsegment_styler_   r`   ra   Zcropped_liner1   r1   r2   Úsplit_and_crop_lines2  s4   €
ÿ
õ€
ÿzSegment.split_and_crop_linesrP   c                 C   sÒ   t dd„ |D ƒƒ}||k r%|r|| d||  |ƒg }|S |dd… }|S ||krag }|j}d}|D ],}|j}	||	 |k s@|jrI||ƒ ||	7 }q2|\}
}}t|
|| ƒ}
|| |
|ƒƒ  |S |S |dd… }|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  qd S r;   )r:   )rT   rA   r1   r1   r2   rV   t  s   € z-Segment.adjust_line_length.<locals>.<genexpr>rE   Nr   )Úsumr\   r:   r6   r   )rH   rP   rd   r5   re   Úline_lengthra   r\   rA   Úsegment_lengthr4   ri   r_   r1   r1   r2   rg   a  s.   ïð

ÿzSegment.adjust_line_lengthc                    s   t ‰ t‡ fdd„|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  qd S r;   r1   )rT   r4   r5   r6   ©Ú	_cell_lenr1   r2   rV   ™  s   €  z*Segment.get_line_length.<locals>.<genexpr>)r   rk   )rH   rP   r1   rn   r2   Úget_line_lengthŽ  s   
zSegment.get_line_lengthÚlinesc                    s0   | j ‰ |rt‡ fdd„|D ƒƒnd}|t|ƒfS )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  qd S r;   r1   ©rT   rP   ©rp   r1   r2   rV   ¦  s   € z$Segment.get_shape.<locals>.<genexpr>r   )rp   ÚmaxrG   )rH   rq   Ú	max_widthr1   rs   r2   Ú	get_shape›  s   
zSegment.get_shapeÚwidthÚheightÚ	new_linesc           	         sŒ   |pt |ƒ}|r| dˆ d ˆƒgn| dˆ ˆƒg}| j‰ |d|… }‡ ‡‡fdd„|D ƒ|dd…< 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.
        rE   rO   Nc                    s   g | ]	}ˆ |ˆˆd �‘qS ))r5   r1   rr   ©rg   r5   rw   r1   r2   Ú
<listcomp>Æ  s    ÿz%Segment.set_shape.<locals>.<listcomp>)rG   rg   Úextend)	rH   rq   rw   rx   r5   ry   Ú_heightÚblankZshaped_linesr1   rz   r2   Ú	set_shape©  s   &ÿÿzSegment.set_shaperH   c                 C   s`   |t |ƒ }|s|dd… S |d|… }|r| d| d |ƒn| d| |ƒ}||gg|  }|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.
        NrE   rO   ©rG   ©rH   rq   rw   rx   r5   ry   Úextra_linesr~   r1   r1   r2   Ú	align_topÍ  ó   $zSegment.align_topc                 C   s`   |t |ƒ }|s|dd… S |d|… }|r| d| d |ƒn| d| |ƒ}|gg| | }|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.
        NrE   rO   r€   r�   r1   r1   r2   Úalign_bottomê  r„   zSegment.align_bottomc           
      C   s|   |t |ƒ }|s|dd… S |d|… }|r| d| d |ƒn| d| |ƒ}|d }|| }	|gg| | |gg|	  }|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.
        NrE   rO   r   r€   )
rH   rq   rw   rx   r5   ry   r‚   r~   Z	top_linesZbottom_linesr1   r1   r2   Úalign_middle  s   $zSegment.align_middlec                 c   sv   � t |ƒ}zt|ƒ}W n
 ty   Y dS w t}|D ]}|j|jkr0|js0||j|j |jƒ}q|V  |}q|V  dS )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ÚStopIterationr3   r5   r6   r4   )rH   rQ   Úiter_segmentsZlast_segmentrI   rA   r1   r1   r2   Úsimplify&  s    €
ÿÿ
zSegment.simplifyc                 c   sL   � |D ] }|j s|jdu r|V  q|\}}}| ||r| d¡ndƒV  qdS )zÆRemove all links from an iterable of styles.

        Args:
            segments (Iterable[Segment]): An iterable segments.

        Yields:
            Segment: Segments with link removed.
        N)r6   r5   Úupdate_link)rH   rQ   rA   r4   r5   Ú_controlr1   r1   r2   Ústrip_linksA  s   €

ûzSegment.strip_linksc                 c   s$   � |D ]\}}}| |d|ƒV  qdS )zÔRemove all styles from an iterable of segments.

        Args:
            segments (Iterable[Segment]): An iterable segments.

        Yields:
            Segment: Segments with styles replace with None
        Nr1   )rH   rQ   r4   r9   r6   r1   r1   r2   Ústrip_stylesR  s   €
ÿzSegment.strip_stylesc                 c   s\   � i }|D ]&\}}}|r$|  |¡}|du r|j}|||< | |||ƒV  q| |d|ƒV  qdS )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)rH   rQ   Úcacher4   r5   r6   Zcolorless_styler1   r1   r2   Úremove_color_  s   €
øzSegment.remove_colorÚcutsc                 c   sF  � g }|j }t|ƒ}	 t|dƒ}|dkrdS |dkrng V  qd}|j}|j}	t}
|D ]q}|\}}}|rœ|r8|n||
|ƒ }||k rI||ƒ |}nS||krm||ƒ |	ƒ V  |ƒ  |}t|dƒ}|dkrl|ri|	ƒ V   dS n/| || ¡\}}|\}}}||ƒ |	ƒ V  |ƒ  |}t|dƒ}|dkrš|r—|	ƒ V   dS |s4q+|	ƒ V  dS )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.
        TrD   Nr   )r\   r‡   rˆ   rh   Úcopyr   rN   )rH   rQ   r”   Zsplit_segmentsZadd_segmentZ	iter_cutsrB   rK   Zsegments_clearZsegments_copyro   rA   r4   r9   r6   Úend_posrL   r1   r1   r2   Údivideu  sb   €
ú



ß€#zSegment.divide)r7   r3   )NN©F)NTT)NT)NNF).r,   r-   r.   r/   ÚstrÚ__annotations__r5   r   r   r6   r   ÚControlCodeÚpropertyrF   r:   r   r=   r>   r?   r@   Úclassmethodr   r   rM   rN   rP   r   rX   rZ   r	   rb   rc   rj   rg   rp   rv   r   r   rƒ   r…   r†   r‹   rŽ   r�   r“   r—   r1   r1   r1   r2   r3   <   sJ  
 		/üþýüû(ÿÿÿþ ÿþúþýüûú
ù.ûþýüûú,$ú
þýüûú
ù#úÿ
þýüûú
ùúÿ
þýüûú
ùúÿ
þýüûú
ùÿÿ
þr3   c                   @   sB   e Zd ZdZddee deddfdd„Z			
				ddd„ZdS )Ú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.
    FrQ   ry   r7   Nc                 C   s   t |ƒ| _|| _d S r;   )ÚlistrQ   ry   )r8   rQ   ry   r1   r1   r2   Ú__init__Ä  s   

zSegments.__init__Úconsoler   Úoptionsr   r   c                 c   s<   � | j rt ¡ }| jD ]}|V  |V  qd S | jE d H  d S r;   )ry   r3   rP   rQ   )r8   r¡   r¢   rP   rA   r1   r1   r2   Ú__rich_console__È  s   €
þzSegments.__rich_console__r˜   ©r¡   r   r¢   r   r7   r   )	r,   r-   r.   r/   r   r3   r>   r    r£   r1   r1   r1   r2   rž   »  s    ÿÿþrž   c                   @   sB   e Zd Zddeee  deddfdd„Z				
			ddd„ZdS )ÚSegmentLinesFrq   ry   r7   Nc                 C   s   t |ƒ| _|| _dS )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Ÿ   rq   ry   )r8   rq   ry   r1   r1   r2   r    Õ  s   

zSegmentLines.__init__r¡   r   r¢   r   r   c                 c   sJ   � | j rt ¡ }| jD ]
}|E d H  |V  qd S | jD ]}|E d H  qd S r;   )ry   r3   rP   rq   )r8   r¡   r¢   ra   rP   r1   r1   r2   r£   à  s   €

þ
ÿzSegmentLines.__rich_console__r˜   r¤   )	r,   r-   r.   r   r	   r3   r>   r    r£   r1   r1   r1   r2   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)7Úenumr   Ú	functoolsr   Ú	itertoolsr   Úoperatorr   Útypingr   r   r   r	   r
   r   r   r   r   r   Úcellsr   r   r   r   r   Úreprr   r   r5   r   r¡   r   r   r   r   rF   r™   r›   r3   rž   r¥   r,   Úrich.consoleZrich.syntaxr§   Ú	rich.textr¨   ÚcodeÚfrom_markupr4   ÚruleÚprintrŸ   ÚrenderÚ	fragmentsr1   r1   r1   r2   Ú<module>   sh    0þÿ     

ÿ
ÿ


ÿã