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   úS/var/www/html/chatgpt/venv/lib/python3.10/site-packages/pip/_vendor/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   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   )r5   r<   r   ÚintÚlenr   )ÚclsrC   rD   r6   r7   r8   Ú_Segmentr<   Z	cell_sizeÚposÚbeforeZcell_posZout_byr3   r3   r4   Ú_split_cellsm   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   rE   N)r   rI   r5   rN   )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   rT   )rJ   rS   r3   r4   rW   Ø   s   € 
÷ÿù
ÿ)Ú__add__)rJ   rR   r7   rS   Zresult_segmentsr3   )rV   rJ   rS   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   rR   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.
        rP   N)Úappendr6   r8   Ú	partition)
rJ   rR   rQ   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.
        rP   )r7   rc   N)r\   Úadjust_line_lengthr6   r8   r]   Úclear)rJ   rR   rb   r7   rc   rd   rQ   r\   re   Znew_line_segmentrC   r6   Úsegment_styler^   r_   r`   Zcropped_liner3   r3   r4   Úsplit_and_crop_lines  s4   €
ÿ
õ€
ÿzSegment.split_and_crop_linesrQ   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<   )rU   rC   r3   r3   r4   rW   X  s   € z-Segment.adjust_line_length.<locals>.<genexpr>rG   Nr   )Úsumr\   r<   r8   r   )rJ   rQ   rb   r7   rc   Zline_lengthr`   r\   rC   Zsegment_lengthr6   rg   r^   r3   r3   r4   re   E  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   )rU   r6   r7   r8   ©Ú	_cell_lenr3   r4   rW   }  s   €  z*Segment.get_line_length.<locals>.<genexpr>)r   ri   )rJ   rQ   r3   rj   r4   Úget_line_lengthr  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   ©rU   rQ   ©rl   r3   r4   rW   Š  s   € z$Segment.get_shape.<locals>.<genexpr>r   )rl   ÚmaxrI   )rJ   rm   Z	max_widthr3   ro   r4   Ú	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.
        rG   rP   Nc                    s   g | ]	}ˆ |ˆˆd �‘qS ))r7   r3   rn   ©re   r7   rr   r3   r4   Ú
<listcomp>ª  s    ÿz%Segment.set_shape.<locals>.<listcomp>)rI   re   Úextend)	rJ   rm   rr   rs   r7   rt   Z_heightÚblankZshaped_linesr3   ru   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.
        NrG   rP   ©rI   ©rJ   rm   rr   rs   r7   rt   Úextra_linesrx   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.
        NrG   rP   rz   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.
        NrG   rP   r   rz   )
rJ   rm   rr   rs   r7   rt   r|   rx   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   rR   Z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   Zupdate_link)rJ   rR   rC   r6   r7   Z_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   rR   r6   r;   r8   r3   r3   r4   Ústrip_styles6  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)ÚgetZwithout_color)rJ   rR   Úcacher6   r7   r8   Zcolorless_styler3   r3   r4   Úremove_colorC  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.
        TrF   Nr   )r\   r�   r‚   rf   Úcopyr   rO   )rJ   rR   rŠ   Zsplit_segmentsZadd_segmentZ	iter_cutsrD   rL   Zsegments_clearZsegments_copyrk   rC   r6   r;   r8   Zend_posrM   r3   r3   r4   ÚdivideY  sb   €
ú



ß€#zSegment.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   rN   rO   rQ   r	   rY   r[   r
   ra   rh   re   rl   rq   ry   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.
    FrR   rt   r9   Nc                 C   s   t |ƒ| _|| _d S r=   )ÚlistrR   rt   )r:   rR   rt   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=   )rt   r5   rQ   rR   )r:   r–   r—   rQ   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 )ÚSegmentLinesFrm   rt   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”   rm   rt   )r:   rm   rt   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=   )rt   r5   rQ   rm   )r:   r–   r—   r`   rQ   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   Zcellsr   r   r   r   r   Úreprr   r   r7   r   r–   r   r   r   Úlogr   rH   rŽ   r�   r5   r“   rš   r.   Úpip._vendor.rich.consoleZpip._vendor.rich.syntaxrœ   Zpip._vendor.rich.textr�   ÚcodeZfrom_markupr6   ÚruleÚprintr”   ÚrenderÚ	fragmentsr3   r3   r3   r4   Ú<module>   sj    0þÿ    c

ÿ
ÿ


ÿã