o
    ìôj’^  ã                   @   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	 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r^ddl m!Z!m"Z"m#Z# edƒ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l0m1Z1 dZ2e1 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 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© r3   r3   ú_/var/www/html/academy/tools/voices/clone/cosy-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dHdd„ƒZe		dIded  dee dee ded  fdd„ƒZe	dJded  deded  fdd „ƒZeded  deed   fd!d"„ƒZe		#	#dKded  d$edee d%ed&edeed   fd'd(„ƒZe		#dLd)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d.eed   deeef fd/d0„ƒZ"e			dMd.eed   d1ed2ee dee d3edeed   fd4d5„ƒZ#e	dJd6e$d  d.eed   d1ed2eded3edeed   fd7d8„ƒZ%e	dJd6e$d  d.eed   d1ed2eded3edeed   fd9d:„ƒZ&e	dJd6e$d  d.eed   d1ed2eded3e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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  dEee deed   fdFdG„ƒZ,dS )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	dS 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   
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)r6   r8   r7   ©r:   r3   r3   r4   Ú__rich_repr__[   s   €

ÿzSegment.__rich_repr__c                 C   s
   t | jƒS )z#Check if the segment contains text.)Úboolr6   r>   r3   r3   r4   Ú__bool__d   s   
zSegment.__bool__c                 C   s
   | j duS )z,Check if the segment contains control codes.N)r8   r>   r3   r3   r4   Ú
is_controlh   s   
zSegment.is_controli @  ÚsegmentÚcut)r5   r5   c                 C   s0  |\}}}t }|j}||kr||d||ƒfS t}t|| t|ƒd  ƒ}	|d |	… }
t|
ƒ}||krB||
||ƒ|||	d … ||ƒfS |	t|ƒk r”||	 }|	d7 }	|||ƒ7 }|d |	… }
||krp||
||ƒ|||	d … ||ƒfS ||krŽ||
d |	d … d ||ƒ|d||	d …  ||ƒfS |	t|ƒk sHtdƒ‚)NÚ r   ú zWill never reach here)r5   r<   r   ÚintÚlenr   ÚAssertionError)ÚclsrC   rD   r6   r7   r8   Ú_Segmentr<   Ú	cell_sizeÚposÚbeforeZcell_posÚcharr3   r3   r4   Ú_split_cellsm   s8   

þ
þþõzSegment._split_cellsc                 C   sb   | \}}}t |ƒr+|t|ƒkr| td||ƒfS t|d|… ||ƒt||d… ||ƒfS |  | |¡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.
        rE   N)r   rH   r5   rP   )r:   rD   r6   r7   r8   r3   r3   r4   Úsplit_cells”   s   
	þzSegment.split_cellsc                 C   s   | dƒS )zMake a new line segment.Ú
r3   )rJ   r3   r3   r4   Ú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=   r3   ©Ú.0r6   r;   r8   )ÚapplyrJ   r3   r4   Ú	<genexpr>Å   s
   € ÿ
ÿz&Segment.apply_style.<locals>.<genexpr>c                 3   s6   � | ]\}}}ˆ ||rd n|r|ˆ nˆ|ƒV  qd S r=   r3   rV   )rJ   rU   r3   r4   rY   Ê   s   € 
÷ÿù
ÿ)Ú__add__)rJ   rT   r7   rU   Zresult_segmentsr3   )rX   rJ   rU   r4   Úapply_style¯   s   þ
özSegment.apply_styleFrB   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.

        r8   )Úfilterr   r   )rJ   rT   rB   r3   r3   r4   Ú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.
        rR   N)Úappendr6   r8   Ú	partition)
rJ   rT   rS   r^   rC   r6   r7   Ú_Ú_textÚnew_liner3   r3   r4   Úsplit_linesë   s(   €

ù€
	
ÿzSegment.split_linesTÚ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.
        rR   )r7   re   N)r^   Úadjust_line_lengthr6   r8   r_   Úclear)rJ   rT   rd   r7   re   rf   rS   r^   rg   Znew_line_segmentrC   r6   Úsegment_styler`   ra   rb   Zcropped_liner3   r3   r4   Úsplit_and_crop_lines  s4   €
ÿ
õ€
ÿzSegment.split_and_crop_linesrS   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<   )rW   rC   r3   r3   r4   rY   J  s   € z-Segment.adjust_line_length.<locals>.<genexpr>rF   Nr   )Úsumr^   r<   r8   r   )rJ   rS   rd   r7   re   Úline_lengthrb   r^   rC   Úsegment_lengthr6   ri   r`   r3   r3   r4   rg   7  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=   r3   )rW   r6   r7   r8   ©Ú	_cell_lenr3   r4   rY   o  s   €  z*Segment.get_line_length.<locals>.<genexpr>)r   rk   )rJ   rS   r3   rn   r4   Úget_line_lengthd  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=   r3   ©rW   rS   ©rp   r3   r4   rY   |  s   € z$Segment.get_shape.<locals>.<genexpr>r   )rp   ÚmaxrH   )rJ   rq   Ú	max_widthr3   rs   r4   Ú	get_shapeq  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.
        rF   rR   Nc                    s   g | ]	}ˆ |ˆˆd �‘qS ))r7   r3   rr   ©rg   r7   rw   r3   r4   Ú
<listcomp>œ  s    ÿz%Segment.set_shape.<locals>.<listcomp>)rH   rg   Úextend)	rJ   rq   rw   rx   r7   ry   Ú_heightÚblankZshaped_linesr3   rz   r4   Ú	set_shape  s   &ÿÿzSegment.set_shaperJ   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.
        NrF   rR   ©rH   ©rJ   rq   rw   rx   r7   ry   Úextra_linesr~   r3   r3   r4   Ú	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.
        NrF   rR   r€   r�   r3   r3   r4   Ú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.
        NrF   rR   r   r€   )
rJ   rq   rw   rx   r7   ry   r‚   r~   Z	top_linesZbottom_linesr3   r3   r4   Ú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ÚStopIterationr5   r7   r8   r6   )rJ   rT   Úiter_segmentsZlast_segmentrK   rC   r3   r3   r4   Ú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)r8   r7   Úupdate_link)rJ   rT   rC   r6   r7   Ú_controlr3   r3   r4   Ústrip_links  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
        Nr3   )rJ   rT   r6   r;   r8   r3   r3   r4   Ústrip_styles(  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)rJ   rT   Úcacher6   r7   r8   Zcolorless_styler3   r3   r4   Úremove_color5  s   €
øzSegment.remove_colorÚcutsc                 c   sF  � g }|j }t|ƒ}	 t|dƒ}|dkrg 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.
        Téÿÿÿÿr   N)r^   r‡   rˆ   rh   Úcopyr   rQ   )rJ   rT   r”   Zsplit_segmentsZadd_segmentZ	iter_cutsrD   rM   Zsegments_clearZsegments_copyro   rC   r6   r;   r8   Úend_posrN   r3   r3   r4   ÚdivideK  sb   €
ú



ß€#zSegment.divide)r9   r5   )NN©F)NTT)NT)NNF)-r.   r/   r0   r1   ÚstrÚ__annotations__r7   r   r   r8   r   ÚControlCodeÚpropertyrG   r<   r   r?   r@   rA   rB   Úclassmethodr   r   rP   rQ   rS   r	   r[   r]   r
   rc   rj   rg   rp   rv   r   r   rƒ   r…   r†   r‹   rŽ   r�   r“   r˜   r3   r3   r3   r4   r5   ?   s>  
 		%üþýüû(ÿÿÿþ úþýüûú
ù.ûþýüûú,$ú
þýüûú
ù#úÿ
þýüûú
ùúÿ
þýüûú
ùúÿ
þýüûú
ùÿÿ
þr5   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.
    FrT   ry   r9   Nc                 C   s   t |ƒ| _|| _d S r=   )ÚlistrT   ry   )r:   rT   ry   r3   r3   r4   Ú__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   r5   rS   rT   )r:   r¢   r£   rS   rC   r3   r3   r4   Ú__rich_console__ž  s   €
þzSegments.__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 Zd Zddeee  deddfdd„Z				
			ddd„ZdS )ÚSegmentLinesFrq   ry   r9   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   )r:   rq   ry   r3   r3   r4   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   r5   rS   rq   )r:   r¢   r£   rb   rS   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   rG   rš   rœ   r5   rŸ   r¦   r.   Úrich.consoleZrich.syntaxr¨   Ú	rich.textr©   ÚcodeÚfrom_markupr6   ÚruleÚprintr    ÚrenderÚ	fragmentsr3   r3   r3   r4   Ú<module>   sj    0þÿ    U

ÿ
ÿ


ÿã