Файловый менеджер - Редактировать - /opt/imh-python/lib/python3.9/site-packages/prompt_toolkit/contrib/regular_languages/__pycache__/compiler.cpython-39.pyc
Ðазад
a d�h�U � @ s d Z ddlmZ ddlZddlmZmZmZmZm Z m Z m Z ddlm Z ddlmZmZmZmZmZmZmZmZmZ g d�Zd Zeeeegef f ZG d d � d �Z G d d � d �Z e d�Z G dd� d�Z G dd� d�Z d dddd d�dd�Z d dddd d�dd�Z!dS ) a� Compiler for a regular grammar. Example usage:: # Create and compile grammar. p = compile('add \s+ (?P<var1>[^\s]+) \s+ (?P<var2>[^\s]+)') # Match input string. m = p.match('add 23 432') # Get variables. m.variables().get('var1') # Returns "23" m.variables().get('var2') # Returns "432" Partial matches are possible:: # Create and compile grammar. p = compile(''' # Operators with two arguments. ((?P<operator1>[^\s]+) \s+ (?P<var1>[^\s]+) \s+ (?P<var2>[^\s]+)) | # Operators with only one arguments. ((?P<operator2>[^\s]+) \s+ (?P<var1>[^\s]+)) ''') # Match partial input string. m = p.match_prefix('add 23') # Get variables. (Notice that both operator1 and operator2 contain the # value "add".) This is because our input is incomplete, and we don't know # yet in which rule of the regex we we'll end up. It could also be that # `operator1` and `operator2` have a different autocompleter and we want to # call all possible autocompleters that would result in valid input.) m.variables().get('var1') # Returns "23" m.variables().get('operator1') # Returns "add" m.variables().get('operator2') # Returns "add" � )� annotationsN)�Callable�Dict�Iterable�Iterator�Pattern�TypeVar�overload)�Match� ) �AnyNode� Lookahead�Node� NodeSequence�Regex�Repeat�Variable� parse_regex�tokenize_regex)�compiler � VariablesZinvalid_trailingc @ s� e Zd ZdZd ddddd�dd�Zd d d d �d d �Zd d d d �d d�Zeddd d�dd��Zedddd�dd��Z d dd�dd�Z d dd�dd�Z dS ) �_CompiledGrammaraI Compiles a grammar. This will take the parse tree of a regular expression and compile the grammar. :param root_node: :class~`.regex_parser.Node` instance. :param escape_funcs: `dict` mapping variable names to escape callables. :param unescape_funcs: `dict` mapping variable names to unescape callables. Nr �EscapeFuncDict | None�None�� root_node� escape_funcs�unescape_funcs�returnc s� |�_ |p i �_|pi �_i �_dg� ddd�� �fdd� }d��||�� d��_t��||���_t j �t � �j���_ �fd d ��jD ��_ �fd d ��jD ��_d S ) Nr r �str��noder c s. d� d � �}| j �j|< � d d7 < |S )N�nr r )�varname�_group_names_to_nodes)r! �name)�counter�self� ��/root/rpmbuild/BUILDROOT/imh-python39-modules-3.9.7-92.el8.x86_64/opt/imh-python/lib/python3.9/site-packages/prompt_toolkit/contrib/regular_languages/compiler.py�create_group_funca s z4_CompiledGrammar.__init__.<locals>.create_group_func�^�$c s g | ]}t �|� ��qS r( )�rer ��.0�t��flagsr( r) � <listcomp>q � z-_CompiledGrammar.__init__.<locals>.<listcomp>c s& g | ] }t �d �|�d�t�� ��qS )z(?:{})(?P<{}>.*?)$r, )r- r �format�rstrip�_INVALID_TRAILING_INPUTr. r1 r( r) r3 v s ��)r r r r$ � _transformZ _re_pattern�list�_transform_prefixZ_re_prefix_patternsr- �DOTALLr �_re� _re_prefix� _re_prefix_with_trailing_input)r' r r r r* r( )r& r2 r' r) �__init__Q s" � � �z_CompiledGrammar.__init__r �r# �valuer c C s | j �|�}|r||�S |S )zW Escape `value` to fit in the place of this variable into the grammar. )r �get�r' r# rA �fr( r( r) �escape~ s z_CompiledGrammar.escapec C s | j �|�}|r||�S |S )z# Unescape `value`. )r rB rC r( r( r) �unescape� s z_CompiledGrammar.unescapezCallable[[Variable], str])r r* r c s ddd�� �fdd� ��|�S )a Turn a :class:`Node` object into a regular expression. :param root_node: The :class:`Node` instance for which we generate the grammar. :param create_group_func: A callable which takes a `Node` and returns the next free name for this node. r r r c s: t | t�r*d�d��fdd�| jD ���S t | t�rNd��fdd�| jD ��S t | t�r^| jS t | t�r�| j rrdnd}|�| j � d S t | t �r�d � | �� d �| j �� d �S t | t ��r(| j d u r�| jd kr�d }n| jdkr�d}n$d| j| j d u � r�dnt| j �f }d��| j �|| j�r"dnd�S td| ����d S )Nz(?:{})�|c 3 s | ]}� |�V qd S �Nr( �r/ �c�� transformr( r) � <genexpr>� r4 zA_CompiledGrammar._transform.<locals>.transform.<locals>.<genexpr>� c 3 s | ]}� |�V qd S rH r( rI rK r( r) rM � r4 �(?!z(=�)�(?P<�>r �*r �+z{%i,%s}z (?:{}){}{}�?�Got )� isinstancer r5 �join�childrenr r �regexr �negative� childnoder r � max_repeatZ min_repeatr �greedy� TypeError)r! �before� repeat_sign�r* rL r( r) rL � s6 ��z._CompiledGrammar._transform.<locals>.transformr( )�clsr r* r( rb r) r8 � s *z_CompiledGrammar._transform� Iterable[str]c # sN ddd��fdd� �ddd�� ���fdd� ��|�D ]}d |� d �V q6d S ) a} Yield all the regular expressions matching a prefix of the grammar defined by the `Node` instance. For each `Variable`, one regex pattern will be generated, with this named group at the end. This is required because a regex engine will terminate once a match is found. For autocompletion however, we need the matches for all possible paths, so that we can provide completions for each `Variable`. - So, in the case of an `Any` (`A|B|C)', we generate a pattern for each clause. This is one for `A`, one for `B` and one for `C`. Unless some groups don't contain a `Variable`, then these can be merged together. - In the case of a `NodeSequence` (`ABC`), we generate a pattern for each prefix that ends with a variable, and one pattern for the whole sequence. So, that's one for `A`, one for `AB` and one for `ABC`. :param root_node: The :class:`Node` instance for which we generate the grammar. :param create_group_func: A callable which takes a `Node` and returns the next free name for this node. r �boolr c s^ t | t�rdS t | t�r dS t | ttf�r4� | j�S t | ttf�rZt� fdd�| j D ��S dS )NFTc 3 s | ]}� |�V qd S rH r( )r/ �child��contains_variabler( r) rM � r4 zP_CompiledGrammar._transform_prefix.<locals>.contains_variable.<locals>.<genexpr>) rW r r r r r\ r r �anyrY )r! rg r( r) rh � s z=_CompiledGrammar._transform_prefix.<locals>.contains_variablerd c 3 s� t | t�rvg }g }| jD ]"}�|�r0|�|� q|�|� q|D ]}�|�E d H q@|rrd��fdd�|D ��V �nlt | t��r�� �fdd�| jD �}�fdd�| jD �}�fdd�| jD �}tt| j��D ]2}|| r�|| D ] }d�|d |� �| V q�q�t|��s�g } tt| j��D ] }| �d � | �|| � �q tt| j�d d d �D ]X}|| �rn| �d � n<| �d � t|| �d k�s�J �| �|| d � | �d� �qTd�| �V �n$t | t ��r�d | j � d�V �nt | t ��r| j �r d� � | j��� d �V ntd��n�t | t��rN�| j�D ] }d�| �� d|� d �V �q,n�t | t��rԈ � | j��} | jd k�r��| j�E d H nL�| j�D ]@}| j�r�d| jd } nd} d�| | | j�r�dnd|�V �q�ntd| ����d S )NrG c 3 s | ]}� |�D ] }|V qqd S rH r( )r/ rJ �rrK r( r) rM s zH_CompiledGrammar._transform_prefix.<locals>.transform.<locals>.<genexpr>c s g | ]}� � |���qS r( )r8 rI )rc r* r( r) r3 r4 zI_CompiledGrammar._transform_prefix.<locals>.transform.<locals>.<listcomp>c s g | ]}t � |���qS r( �r9 rI rK r( r) r3 r4 c s g | ] }� |��qS r( r( rI rg r( r) r3 r4 rN z(?:r ���rP z|(?:r z))z)?rO z%Positive lookahead not yet supported.rQ rR z{,%i}rS z (?:{}){}{}{}rU rV )rW r rY �appendrX r �range�len�allr rZ r r[ r8 r\ � Exceptionr r r] r5 r^ r_ ) r! Zchildren_with_variableZchildren_without_variablerJ Zcomplete�prefixesZvariable_nodes�iZc_str�result�prefixra �rc rh r* rL r( r) rL � st � � z5_CompiledGrammar._transform_prefix.<locals>.transformz^(?:z)$Nr( )rc r r* rj r( rv r) r: � s w z"_CompiledGrammar._transform_prefixz Match | None)�stringr c C s. | j �|�}|r*t|| j |fg| j| j�S dS )z� Match the string with the grammar. Returns a :class:`Match` instance or `None` when the input doesn't match the grammar. :param string: The input string. N)r< �matchr r$ r )r' rw �mr( r( r) rx d s �z_CompiledGrammar.matchc sT | j | jfD ]B}� fdd�|D �}dd� |D �}|g kr t� || j| j� S q dS )aR Do a partial match of the string with the grammar. The returned :class:`Match` instance can contain multiple representations of the match. This will never return `None`. If it doesn't match at all, the "trailing input" part will capture all of the input. :param string: The input string. c s g | ]}||� � �f�qS r( )rx )r/ rj �rw r( r) r3 r4 z1_CompiledGrammar.match_prefix.<locals>.<listcomp>c S s g | ]\}}|r||f�qS r( r( )r/ rj ry r( r( r) r3 � r4 N)r= r> r r$ r )r' rw �patterns�matchesZmatches2r( rz r) � match_prefixs s � z _CompiledGrammar.match_prefix)NN) �__name__� __module__� __qualname__�__doc__r? rE rF � classmethodr8 r: rx r} r( r( r( r) r G s �-7 r c @ s| e Zd ZdZddddd�dd�Zd d �d d �Zd d �dd�Zdddd�dd�Zdd �dd�Zdd �dd�Z dd �dd�Z d S ) r z� :param string: The input string. :param re_matches: List of (compiled_re_pattern, re_match) tuples. :param group_names_to_nodes: Dictionary mapping all the re group names to the matching Node instances. r z*list[tuple[Pattern[str], RegexMatch[str]]]zdict[str, str]z dict[str, Callable[[str], str]])rw � re_matches�group_names_to_nodesr c C s || _ || _|| _|| _d S rH )rw � _re_matchesr$ �_unescape_funcs)r' rw r� r� r r( r( r) r? � s zMatch.__init__z!list[tuple[str, tuple[int, int]]]�r c s dd�� fdd� }t |� �S )z9 Return a list of (varname, reg) tuples. z%Iterable[tuple[str, tuple[int, int]]]r� c 3 sR � j D ]F\} }| j�� D ]2\}}|tkr|j}|| }� j| }||fV qqd S rH )r� � groupindex�itemsr7 �regsr$ )rj �re_match� group_name� group_indexr� �regr! �r' r( r) � get_tuples� s z(Match._nodes_to_regs.<locals>.get_tuplesrk )r' r� r( r� r) �_nodes_to_regs� s zMatch._nodes_to_regs�&list[tuple[str, str, tuple[int, int]]]c s< ddd�dd��ddd��fdd� � � �fd d ��� � D �S ) z> Returns list of (Node, string_value) tuples. �tuple[int, int]re )�slr c S s | d dko| d dkS )Nr rl r r( �r� r( r( r) �is_none� s z'Match._nodes_to_values.<locals>.is_noner c s � j | d | d � S �Nr r rz r� r� r( r) rB � s z#Match._nodes_to_values.<locals>.getc s& g | ] \}}�|�s|� |�|f�qS r( r( )r/ r# �slice)rB r� r( r) r3 � s �z*Match._nodes_to_values.<locals>.<listcomp>)r� r� r( )rB r� r' r) �_nodes_to_values� s �zMatch._nodes_to_valuesr@ c C s | j �|�}|r||�S |S rH )r� rB )r' r# rA Z unwrapperr( r( r) � _unescape� s zMatch._unescaper c s t � fdd�� �� D ��S )z6 Returns :class:`Variables` instance. c s$ g | ] \}}}|� � ||�|f�qS r( )r� )r/ �k�vr� r� r( r) r3 � r4 z#Match.variables.<locals>.<listcomp>)r r� r� r( r� r) � variables� s �zMatch.variableszMatchVariable | Nonec C s� g }| j D ]4\}}|j�� D ] \}}|tkr |�|j| � q q |r�tdd� |D ��tdd� |D ��f}| j|d |d � }td||�S dS )a Get the `MatchVariable` instance, representing trailing input, if there is any. "Trailing input" is input at the end that does not match the grammar anymore, but when this is removed from the end of the input, the input would be a valid string. c s s | ]}|d V qdS )r Nr( �r/ rs r( r( r) rM � r4 z'Match.trailing_input.<locals>.<genexpr>c s s | ]}|d V qdS )r Nr( r� r( r( r) rM � r4 r r z<trailing_input>N) r� r� r� r7 rm r� �maxrw � MatchVariable)r' Zslicesrj r� r� r� r� rA r( r( r) �trailing_input� s $ zMatch.trailing_inputzIterable[MatchVariable]c c s` | � � D ]R\}}|d t| j�kr| �|| j|d |d � �}t|||d |d f�V qdS )z� Yields `MatchVariable` instances for all the nodes having their end position at the end of the input string. r r N)r� ro rw r� r� )r' r# r� rA r( r( r) � end_nodes� s zMatch.end_nodesN) r~ r r� r� r? r� r� r� r� r� r� r( r( r( r) r � s r �_Tc @ s� e Zd Zddd�dd�Zdd�dd �Zedd d �d d ��Zedddd�dd ��Zd dddd�dd �Zddd �dd�Zdd d �dd�Zdd�dd�Z dS ) r r� r )�tuplesr c C s || _ d S rH ��_tuples)r' r� r( r( r) r? � s zVariables.__init__r r� c C s" d� | jjd�dd� | jD ���S )Nz{}({})�, c s s" | ]\}}}|� d |��V qdS )�=Nr( �r/ r� r� �_r( r( r) rM � r4 z%Variables.__repr__.<locals>.<genexpr>)r5 � __class__r~ rX r� r� r( r( r) �__repr__� s �zVariables.__repr__z str | None)�keyr c C s d S rH r( �r' r� r( r( r) rB � s z Variables.getzstr | _T)r� �defaultr c C s d S rH r( )r' r� r� r( r( r) rB � s Nzstr | _T | Nonec C s | � |�}|r|d S |S )Nr )�getall)r' r� r� r� r( r( r) rB s z list[str]c s � fdd�| j D �S )Nc s g | ]\}}}|� kr|�qS r( r( r� �r� r( r) r3 r4 z$Variables.getall.<locals>.<listcomp>r� r� r( r� r) r� s zVariables.getallc C s | � |�S rH )rB r� r( r( r) � __getitem__ s zVariables.__getitem__zIterator[MatchVariable]c c s$ | j D ]\}}}t|||�V qdS )z2 Yield `MatchVariable` instances. N)r� r� �r' r# rA r� r( r( r) �__iter__ s zVariables.__iter__)N) r~ r r� r? r� r rB r� r� r� r( r( r( r) r � s r c @ s2 e Zd ZdZddddd�dd�Zdd�d d �Zd S ) r� a Represents a match of a variable in the grammar. :param varname: (string) Name of the variable. :param value: (string) Value of this variable. :param slice: (start, stop) tuple, indicating the position of this variable in the input string. r r� r )r# rA r� r c C s. || _ || _|| _| jd | _| jd | _d S r� )r# rA r� �start�stopr� r( r( r) r? s zMatchVariable.__init__r� c C s | j j� d| j�d| j�d�S )N�(r� rP )r� r~ r# rA r� r( r( r) r� $ s zMatchVariable.__repr__N)r~ r r� r� r? r� r( r( r( r) r� s r� r r )� expressionr r r c C s t tt| ��||d�S )z^ Compile grammar (given as regex string), returning a `CompiledGrammar` instance. �r r )�_compile_from_parse_treer r )r� r r r( r( r) r ( s �r r r c C s t | ||d�S )z\ Compile grammar (given as parse tree), returning a `CompiledGrammar` instance. r� )r )r r r r( r( r) r� 8 s �r� )NN)NN)"r� � __future__r r- �typingr r r r r r r r Z RegexMatchZ regex_parserr r r r r r r r r �__all__r7 r ZEscapeFuncDictr r� r r� r r� r( r( r( r) �<module> s* ) $ , Eb# � �
| ver. 1.1 | |
.
| PHP 8.3.30 | Ð“ÐµÐ½ÐµÑ€Ð°Ñ†Ð¸Ñ Ñтраницы: 0 |
proxy
|
phpinfo
|
ÐаÑтройка