|
Server : LiteSpeed System : Linux server51.dnsbootclub.com 4.18.0-553.62.1.lve.el8.x86_64 #1 SMP Mon Jul 21 17:50:35 UTC 2025 x86_64 User : nandedex ( 1060) PHP Version : 8.1.33 Disable Function : NONE Directory : /opt/cppython/lib/python3.8/site-packages/pexpect/__pycache__/ |
U
O��g�T � @ s� d dl mZmZ d dlZd dlZd dlZd dlZd dlZddlm Z m
Z
m Z ddl m
Z
mZmZ ejd dkZerveneZG dd� de�ZG d d
� d
e�ZdS ) � )�StringIO�BytesION� )�ExceptionPexpect�EOF�TIMEOUT)�Expecter�searcher_string� searcher_re� c @ s, e Zd ZdZeddd��Zed dd��ZdS )
�
_NullCoderz Pass bytes through unchanged.Fc C s | S �N� ��b�finalr r �>/opt/cppython/lib/python3.8/site-packages/pexpect/spawnbase.py�encode s z_NullCoder.encodec C s | S r
r r r r r �decode s z_NullCoder.decodeN)F)F)�__name__�
__module__� __qualname__�__doc__� staticmethodr r r r r r r
s
r c @ s� e Zd ZdZdZdZdZd7dd�Zd d
� Zd d � Z d
d� Z
dd� Z dd� Z dd� Z
ee e
�Zd8dd�Zdd� Zdd� Zd9d d �Zd:d d �Zd;d!d"�Zd<d#d$�Zd=d%d&�Zd>d'd(�Zd)d*� Zd?d+d,�Zd-d.� Zd/d0� Z d1d2� Z d3d4� Z d5d6� Z dS )@� SpawnBasez�A base class providing the backwards-compatible spawn API for Pexpect.
This should not be instantiated directly: use :class:`pexpect.spawn` or
:class:`pexpect.fdpexpect.fdspawn`.
NF� �� �strictc C s� t j| _t j| _t j| _d | _d| _d | _d | _d | _d | _ d| _
d | _ d | _ d | _
d| _|| _t| _|| _d | _d | _|| _|| _d| _d| _d| _d| _d| _dt | � d | _ d| _ || _ || _ |d k�r:t!� | _"| _#t$| _%t&| _'d | _(t)�r t$t*f| _+t,j-�.d
�| _-d d � }|| _/nt0f| _+t,j-| _-t jj1| _/nbt2�3|�|�| _"t2�4|�|�| _#t5| _%t6| _'d
| _(t5f| _+t)�r�t,j-| _-nt,j-�7d
�| _-t jj1| _/d | _8| �'� | _9| �'� | _:d S )NFT���g�������?g�������?g-C ��6?�<�>s
�asciic S s> zt jj�| �W S tk
r8 t j�| �dd�� Y S X d S )Nr! �replace)�sys�stdout�buffer�write�AttributeErrorr )r r r r �write_to_stdout^ s z+SpawnBase.__init__.<locals>.write_to_stdoutz
);r# �stdinr$ �stderr�searcher�
ignorecase�before�after�matchZ match_indexZ
terminatedZ
exitstatusZ signalstatus�status�child_fd�timeoutr � delimiter�logfile� logfile_read� logfile_send�maxread�searchwindowsizeZdelaybeforesendZdelayaftercloseZdelayafterterminateZdelayafterread� softspace�repr�name�closed�encoding� codec_errorsr �_encoder�_decoder�bytes� string_typer � buffer_type�crlf�PY3�str�allowed_string_types�os�linesepr r( �
basestringr& �codecs�getincrementalencoder�getincrementaldecoder� text_typer r Zasync_pw_transport�_bufferZ_before)�selfr2 r7 r8 r4 r= r> r( r r r �__init__! sp
zSpawnBase.__init__c C sR | j d k r | j �|� | j �� |dkr.| jn| j}|d k rN|�|� |�� d S )N�send)r4 r& �flushr6 r5 )rP �s� directionZ
second_logr r r �_log s
zSpawnBase._logc C s" | j d kr t|t�s |�d�S |S )Nr! �r= �
isinstancerA r �rP rT r r r �_coerce_expect_string� s
z SpawnBase._coerce_expect_stringc C sR |j }| jd kr*t|t�s*t�|�d��S | jd k rNt|t�rNt�|�d��S |S �Nzutf-8)�patternr= rX rA �re�compiler r )rP �r�pr r r �_coerce_expect_re� s zSpawnBase._coerce_expect_rec C s" | j d kr t|t�s |�d�S |S r[ rW rY r r r �_coerce_send_string� s
z SpawnBase._coerce_send_stringc C s
| j �� S r
)rO �getvalue�rP r r r � _get_buffer� s zSpawnBase._get_bufferc C s | � � | _| j�|� d S r
)rC rO r& )rP �valuer r r � _set_buffer� s
zSpawnBase._set_bufferr c
C s� zt �| j|�}W nB tk
rT } z$|jd tjkrBd| _td��� W 5 d}~X Y nX |dkrld| _td��| j j
|dd�}| � |d � |S )
z�This reads data from the file descriptor.
This is a simple implementation suitable for a regular file. Subclasses using ptys or pipes should override it.
The timeout parameter is ignored.
r Tz,End Of File (EOF). Exception style platform.N� z/End Of File (EOF). Empty string style platform.F)r �read) rH ri r1 �OSError�args�errnoZEIO�flag_eofr r@ r rV )rP �sizer2 rT �errr r r �read_nonblocking� s zSpawnBase.read_nonblockingc C s. t djt|�|d�dd� | jD ��d���d S )Nz`got {badtype} ({badobj!r}) as pattern, must be one of: {goodtypes}, pexpect.EOF, pexpect.TIMEOUTz, c S s g | ] }t |��qS r )rF )�.0�astr r r �
<listcomp>� s �z/SpawnBase._pattern_type_err.<locals>.<listcomp>)ZbadtypeZbadobjZ goodtypes)� TypeError�format�type�joinrG )rP r\ r r r �_pattern_type_err� s
��zSpawnBase._pattern_type_errc C s� |dkr g S t |t�s |g}tj}| jr2|tjB }g }t|�D ]�\}}t || j�rp| �|�}|� t�
||�� q>|t kr�|� t � q>|t kr�|� t � q>t |t
t�
d���r�| �|�}|� |� q>| �|� q>|S )a� This compiles a pattern-string or a list of pattern-strings.
Patterns must be a StringType, EOF, TIMEOUT, SRE_Pattern, or a list of
those. Patterns may also be None which results in an empty list (you
might do this if waiting for an EOF or TIMEOUT condition without
expecting any pattern).
This is used by expect() when calling expect_list(). Thus expect() is
nothing more than::
cpl = self.compile_pattern_list(pl)
return self.expect_list(cpl, timeout)
If you are using expect() within a loop it may be more
efficient to compile the patterns first and then call expect_list().
This avoid calls in a loop to compile_pattern_list()::
cpl = self.compile_pattern_list(my_pattern)
while some_condition:
...
i = self.expect_list(cpl, timeout)
...
N� )rX �listr] �DOTALLr, �
IGNORECASE� enumeraterG rZ �appendr^ r r rv ra rx )rP �patternsZ
compile_flags�compiled_pattern_list�idxr` r r r �compile_pattern_list� s*
z SpawnBase.compile_pattern_listr c K s> d|kr|� d�}|r$td�|���| �|�}| �||||�S )a� This seeks through the stream until a pattern is matched. The
pattern is overloaded and may take several types. The pattern can be a
StringType, EOF, a compiled re, or a list of any of those types.
Strings will be compiled to re types. This returns the index into the
pattern list. If the pattern was not a list this returns index 0 on a
successful match. This may raise exceptions for EOF or TIMEOUT. To
avoid the EOF or TIMEOUT exceptions add EOF or TIMEOUT to the pattern
list. That will cause expect to match an EOF or TIMEOUT condition
instead of raising an exception.
If you pass a list of patterns and more than one matches, the first
match in the stream is chosen. If more than one pattern matches at that
point, the leftmost in the pattern list is chosen. For example::
# the input is 'foobar'
index = p.expect(['bar', 'foo', 'foobar'])
# returns 1('foo') even though 'foobar' is a "better" match
Please note, however, that buffering can affect this behavior, since
input arrives in unpredictable chunks. For example::
# the input is 'foobar'
index = p.expect(['foobar', 'foo'])
# returns 0('foobar') if all input is available at once,
# but returns 1('foo') if parts of the final 'bar' arrive late
When a match is found for the given pattern, the class instance
attribute *match* becomes an re.MatchObject result. Should an EOF
or TIMEOUT pattern match, then the match attribute will be an instance
of that exception class. The pairing before and after class
instance attributes are views of the data preceding and following
the matching pattern. On general exception, class attribute
*before* is all data received up to the exception, while *match* and
*after* attributes are value None.
When the keyword argument timeout is -1 (default), then TIMEOUT will
raise after the default value specified by the class timeout
attribute. When None, TIMEOUT will not be raised and may block
indefinitely until match.
When the keyword argument searchwindowsize is -1 (default), then the
value specified by the class maxread attribute is used.
A list entry may be EOF or TIMEOUT instead of a string. This will
catch these exceptions and return the index of the list entry instead
of raising the exception. The attribute 'after' will be set to the
exception type. The attribute 'match' will be None. This allows you to
write code like this::
index = p.expect(['good', 'bad', pexpect.EOF, pexpect.TIMEOUT])
if index == 0:
do_something()
elif index == 1:
do_something_else()
elif index == 2:
do_some_other_thing()
elif index == 3:
do_something_completely_different()
instead of code like this::
try:
index = p.expect(['good', 'bad'])
if index == 0:
do_something()
elif index == 1:
do_something_else()
except EOF:
do_some_other_thing()
except TIMEOUT:
do_something_completely_different()
These two forms are equivalent. It all depends on what you want. You
can also just expect the EOF if you are waiting for all output of a
child to finish. For example::
p = pexpect.spawn('/bin/ls')
p.expect(pexpect.EOF)
print p.before
If you are trying to optimize for speed then see expect_list().
On Python 3.4, or Python 3.3 with asyncio installed, passing
``async_=True`` will make this return an :mod:`asyncio` coroutine,
which you can yield from to get the same result that this method would
normally give directly. So, inside a coroutine, you can replace this code::
index = p.expect(patterns)
With this non-blocking form::
index = yield from p.expect(patterns, async_=True)
�async� Unknown keyword arguments: {})�poprt ru r� � expect_list)rP r\ r2 r8 �async_�kwr� r r r �expect� s ^
�zSpawnBase.expectc K sj |dkr| j }d|kr |�d�}|r2td�|���t| t|�|�}|r\ddlm} |||�S |�|�S dS )am This takes a list of compiled regular expressions and returns the
index into the pattern_list that matched the child output. The list may
also contain EOF or TIMEOUT(which are not compiled regular
expressions). This method is similar to the expect() method except that
expect_list() does not recompile the pattern list on every call. This
may help if you are trying to optimize for speed, otherwise just use
the expect() method. This is called by expect().
Like :meth:`expect`, passing ``async_=True`` will make this return an
asyncio coroutine.
r r� r� r �� expect_asyncN) r2 r� rt ru r r
�_asyncr� � expect_loop�rP Z pattern_listr2 r8 r� r� �expr� r r r r� e s
zSpawnBase.expect_listc s� |dkr�j }d|kr |�d�}|r2td�|���t|�j�sJ|ttfkrP|g}�fdd�� z t|�}W n tk
r� �� |� Y nX � fdd�|D �}t
�t |�|�}|r�dd l m
} |||�S |�|�S d
S ) a� This is similar to expect(), but uses plain string matching instead
of compiled regular expressions in 'pattern_list'. The 'pattern_list'
may be a string; a list or other sequence of strings; or TIMEOUT and
EOF.
This call might be faster than expect() for two reasons: string
searching is faster than RE matching and it is possible to limit the
search to just the end of the input buffer.
This method is also useful when you don't want to have to worry about
escaping regular expression characters that you want to match.
Like :meth:`expect`, passing ``async_=True`` will make this return an
asyncio coroutine.
r r� r� c s4 | t tfkr| S t| � j�r&� �| �S � �| � d S r
)r r rX rG rZ rx )r\ rd r r �prepare_pattern� s
z/SpawnBase.expect_exact.<locals>.prepare_patternc s g | ] }� |��qS r r )rq r` )r� r r rs � s z*SpawnBase.expect_exact.<locals>.<listcomp>r r� N)r2 r� rt ru rX rG r r �iterrx r r r� r� r� r� r )r� rP r � expect_exact� s*
�
zSpawnBase.expect_exactc C s t | ||�}|�|�S )a This is the common loop used inside expect. The 'searcher' should be
an instance of searcher_re or searcher_string, which describes how and
what to search for in the input.
See expect() for other arguments, return value and exceptions. )r r� )rP r+ r2 r8 r� r r r r� � s zSpawnBase.expect_loopc C sf |dkr| � � S |dk r*| �| j� | jS t�| �d| �tj�}| �|| jg�}|dkr`| jS | jS )aD This reads at most "size" bytes from the file (less if the read hits
EOF before obtaining size bytes). If the size argument is negative or
omitted, read all data until EOF is reached. The bytes are returned as
a string object. An empty string is returned when EOF is encountered
immediately. r z.{%d}) rB r� r3 r- r] r^ rZ r{ r. )rP rn Zcre�indexr r r ri � s zSpawnBase.readc C s@ |dkr| � � S | �| j| jg�}|dkr6| j| j S | jS dS )al This reads and returns one entire line. The newline at the end of
line is returned as part of the string, unless the file ends without a
newline. An empty string is returned if EOF is encountered immediately.
This looks for a newline as a CR/LF pair (\r\n) even on UNIX because
this is what the pseudotty device returns. So contrary to what you may
expect you will receive newlines as \r\n.
If the size argument is 0 then an empty string is returned. In all
other cases the size argument is ignored, which is not standard
behavior for a file-like object. r N)rB r� rD r3 r- )rP rn r� r r r �readline� s zSpawnBase.readlinec C s t | j| �� �S )z>This is to support iterators over a file-like object.
)r� r� rB rd r r r �__iter__� s zSpawnBase.__iter__c C s" g }| � � }|sq |�|� q|S )a� This reads until EOF using readline() and returns a list containing
the lines thus read. The optional 'sizehint' argument is ignored.
Remember, because this reads until EOF that means the child
process should have closed its stdout. If you run this method on
a child that is still running with its stdout open then this
method will block until it timesout.)r� r~ )rP �sizehint�lines�liner r r � readlines� s zSpawnBase.readlinesc C s | j S )z9Expose file descriptor for a file-like interface
)r1 rd r r r �fileno s zSpawnBase.filenoc C s dS )zWThis does nothing. It is here to support the interface for a
File-like object. Nr rd r r r rS s zSpawnBase.flushc C s dS )z Overridden in subclass using ttyFr rd r r r �isatty
s zSpawnBase.isattyc C s | S r
r rd r r r � __enter__ s zSpawnBase.__enter__c C s | � � d S r
)�close)rP �etypeZevalue�tbr r r �__exit__ s zSpawnBase.__exit__)r r NNNr )r N)r r F)r r F)r r F)r r )r )r )r ) r r r r r= �pidrm rQ rV rZ ra rb re rg �propertyr% rp rx r� r� r� r� r� ri r� r� r� r� rS r� r� r� r r r r r sH �
^
1
g �
�
1
r )�ior r rK rH r# r] rl �
exceptionsr r r r� r r r
� version_inforE rF �unicoderN �objectr r r r r r �<module> s