File: //opt/alt/python37/lib/python3.7/site-packages/exabgp/vendoring/__pycache__/cmd2.cpython-37.pyc
B
RP�e� � @ s� d Z ddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl
Z
ddl Z ddl Z ddl
Z
ddlZddlZddlmZ ddlmZmZ ddlmZ ddlmZ dZejd dkr�ej�� ejd d kr�eZ G d
d � d ej �Z d d
� Z dd� Z dd� Z e ej!_"g Z#dPdd�Z$G dd� de%�Z&dZ'ej(�r~y ddl)Z)dd� Z*dd� Z+W n" e,k
�rx d d� Z*e*Z+Y nX �ndejd k�r�d Z-y"ej.d d ej/ej/ej/d!� d Z-W n ej0e1e2fk
�r� Y nX e-�r�d"d� Z*d#d� Z+n d$d� Z*e*Z+n�d Z-y"ej.d%d ej/ej/ej/d!� d Z-W n� e3k
�r� y^d&Z4ej5d'd ej/ej/d(�Z6e6j7�8e4� e6j7�9� ej5d%d ej/ej/d(�Z6e6j:�;� e4k�r�d Z-W n ek
�r� Y nX Y n ek
�r� Y nX e-�r�d)d� Z*d*d� Z+n d+d� Z*e*Z+ej�<d,� G d-d.� d.e=�Z>G d/d0� d0e?�Z@d1d2� ZAd3d4� ZBG d5d6� d6eC�ZDG d7d8� d8e�ZEdQd:d;�ZFG d<d=� d=ejG�ZGG d>d?� d?e=�ZHG d@dA� dAeI�ZJG dBdC� dCe�ZKdDdE� ZLG dFdG� dGeM�ZNG dHdI� dIeM�ZOG dJdK� dKeO�ZPG dLdM� dMe jQ�ZReSdNk�r�ejTejUdO� dS )Ra, Variant on standard library's cmd with extra features.
To use, simply import cmd2.Cmd instead of cmd.Cmd; use precisely as though you
were using the standard library's cmd, while enjoying the extra features.
Searchable command history (commands: "hi", "li", "run")
Load commands from file, save to file, edit commands in file
Multi-line commands
Case-insensitive commands
Special-character shortcut commands (beyond cmd's "@" and "!")
Settable environment parameters
Optional _onchange_{paramname} called when environment parameter changes
Parsing commands with `optparse` options (flags)
Redirection to file with >, >>; input from file with <
Easy transcript-based testing of applications (see example/example.py)
Bash-style ``select`` available
Note that redirection with > and | will only work if `self.stdout.write()`
is used in place of `print`. The standard library's `cmd` module is
written to use `self.stdout.write()`,
- Catherine Devlin, Jan 03 2008 - catherinedevlin.blogspot.com
mercurial repository at https://www.assembla.com/wiki/show/python-cmd2
� N)�six)�InteractiveConsole�InteractiveInterpreter)� make_option)� pyparsingz0.6.8� � c @ s& e Zd Zd dd�Zdd� Zdd� ZdS )
� OptionParserr Nc C s d| j _|rt|� d S )NT)�values�_exit�print)�self�status�msg� r �F/opt/alt/python37/lib/python3.7/site-packages/exabgp/vendoring/cmd2.py�exitG s zOptionParser.exitc O s> yt | jj� W n tk
r$ Y nX tjj| f|�|� d S )N)r �_func�__doc__�AttributeError�optparser �
print_help)r
�args�kwargsr r r r L s
zOptionParser.print_helpc C s t �|��dS )z�error(msg : string)
Print a usage message incorporating 'msg' to stderr and exit.
If you override this in a subclass, it should not return -- it
should either exit or raise an exception.
N)r �
OptParseError)r
r r r r �errorS s zOptionParser.error)r N)�__name__�
__module__� __qualname__r r r r r r r r F s
r c C s4 d� dd� |D ��d }t�|| �}| |�� d� S )z�
Preserves the spacing originally in the argument after
the removal of options.
>>> remaining_args('-f bar bar cow', ['bar', 'cow'])
'bar cow'
z\s+c s s | ]}t �|�V qd S )N)�re�escape)�.0�ar r r � <genexpr>e s z!remaining_args.<locals>.<genexpr>z\s*$N)�joinr �search�start)ZoldArgs�
newArgList�patternZmatchObjr r r �remaining_args] s r) c C s$ y
t | |�S tk
r dS X dS )z�Returns an attribute's value, or None (no error) if undefined.
Analagous to .get() for dictionaries. Useful when checking for
value of options that may not have been defined on a given
method.N)�getattrr )�obj�attrr r r �
_attr_get_j s
r- c C s: y t jd| gt jt jd��� d S tk
r4 d S X d S )N�which)�stdout�stderrr )�
subprocess�Popen�PIPE�STDOUT� communicate�OSError)�editorr r r �_whichu s r8 �argc sD t �t�s�g�x �D ]}t�t�|�� �� qW � �fdd�}|S )a� Used as a decorator and passed a list of optparse-style options,
alters a cmd2 method to populate its ``opts`` argument from its
raw text argument.
Example: transform
def do_something(self, arg):
into
@options([make_option('-q', '--quick', action="store_true",
help="Makes things fast")],
"source dest")
def do_something(self, arg, opts):
if opts.quick:
self.fast_button = True
c sf t � �x�D ]}��|� q W ��d� jdd � �f � � �_� �fdd�}d� j��� f |_|S )Nz%s [options] %sr c
s� y:�� |�� �\}}t||�}t|t�r4|�|�}n|}W n4 tjk
rn } zt|� �� � d S d }~X Y nX t
|d�r~d S � | ||�}|S )Nr ) �
parse_args�splitr) �
isinstance� ParsedString�with_args_replacedr r r r �hasattr)�instancer9 �optsr' ZnewArgs�e�result)�func� optionParserr r �new_func� s
z/options.<locals>.option_setup.<locals>.new_funcz%s
%s)r �
add_option� set_usager r r � format_help)rD �optrF )�arg_desc� option_list)rD rE r � option_setup� s
z options.<locals>.option_setup)r< �list�options_defined�appendr �Literal�get_opt_string)rL rK rJ rM r )rK rL r �options� s
rS c @ sD e Zd Zejdd� dkr dZnejdd� dkr4ndZdd� ZdS ) �PasteBufferErrorNr �winz�Redirecting to or from paste buffer requires pywin32
to be installed on operating system.
Download from https://sourceforge.net/projects/pywin32/Zdarz�Redirecting to or from paste buffer requires xclip
to be installed on operating system.
On Debian/Ubuntu, 'sudo apt-get install xclip' will install it.c C s t �| | j� d S )N)� Exception�__init__�errmsg)r
r r r rW � s zPasteBufferError.__init__)r r r �sys�platformrX rW r r r r rT � s rT zWRedirecting to or from paste buffer requires %s
to be installed on operating system.
%sc C s< t �d� y t �� } W n tk
r. d} Y nX t �� | S )Nr � )�win32clipboard�
OpenClipboardZGetClipboardData� TypeError�CloseClipboard)rC r r r �get_paste_buffer� s
r` c C s( t �d� t �� t �| � t �� d S )Nr )r\ r] ZEmptyClipboardZSetClipboardTextr_ )�txtr r r �write_to_paste_buffer� s
rb c G s t td ��d S )N)Zpywin32z7Download from https://sourceforge.net/projects/pywin32/)r6 � pastebufferr)r r r r r` � s �darwinFz pbcopy -helpT)�shellr/ �stdinr0 c C s$ t jddt jt jt jd�} | j�� S )Nz pbcopy -helpT)re r/ rf r0 )r1 r2 r3 r/ �read)�
pbcopyprocr r r r` � s c C s, t jddt jt jt jd�}|�| �� � d S )N�pbcopyT)re r/ rf r0 )r1 r2 r3 r5 �encode)ra rh r r r rb � s c G s t td ��d S )N)ri zFOn MacOS X - error should not occur - part of the default installation)r6 rc )r r r r r` s zxclip -o -sel clipz Testing for presence of xclip.zxclip -sel clip)re r/ rf c C s t jddt jt jd�} | j�� S )Nzxclip -o -sel clipT)re r/ rf )r1 r2 r3 r/ rg )� xclipprocr r r r` s c C sd t jddt jt jd�}|j�| �� � |j�� t jddt jt jd�}|j�| �� � |j�� d S )Nzxclip -sel clipT)re r/ rf �xclip)r1 r2 r3 rf �writerj �close)ra rk r r r rb $ s
c G s t td ��d S )N)rl z;On Debian/Ubuntu, install with "sudo apt-get install xclip")r6 rc )r r r r r` / s z c @ s e Zd Zdd� Zdd� ZdS )r= c C s, t d| jj| jjf �}| j|_| j|_|S )Nz%s %s)r= �parsed�commandr �parser)r
�newr r r �full_parsed_statement8 s z"ParsedString.full_parsed_statementc C s2 t |�}| j|_| j|_||jd< ||jjd< |S )Nr )r= ro rq � statement)r
Znewargsrr r r r r> > s
z ParsedString.with_args_replacedN)r r r rs r> r r r r r= 7 s r= c @ s@ e Zd ZdZdd� ZeZdd� Zdd� Zdd � Ze d
d � �Z
d S )
� StubbornDictaG Dictionary that tolerates many input formats.
Create it with stubbornDict(arg) factory function.
>>> d = StubbornDict(large='gross', small='klein')
>>> sorted(d.items())
[('large', 'gross'), ('small', 'klein')]
>>> d.append(['plain', ' plaid'])
>>> sorted(d.items())
[('large', 'gross'), ('plaid', ''), ('plain', ''), ('small', 'klein')]
>>> d += ' girl Frauelein, Maedchen\n\n shoe schuh'
>>> sorted(d.items())
[('girl', 'Frauelein, Maedchen'), ('large', 'gross'), ('plaid', ''), ('plain', ''), ('shoe', 'schuh'), ('small', 'klein')]
c C s t �| t�|�� d S )N)�dict�updateru �to_dict)r
r9 r r r rw V s zStubbornDict.updatec C s | � |� | S )N)rw )r
r9 r r r �__iadd__[ s
zStubbornDict.__iadd__c C s t � | �}|�t|�� |S )N)�copyrw � stubbornDict)r
r9 �selfcopyr r r �__add___ s
zStubbornDict.__add__c C s t � | �}|�t|�� |S )N)rz rw r{ )r
r9 r| r r r �__radd__d s
zStubbornDict.__radd__c C sz t |d�r|�� }t |d�rri }xT|D ]F}|�� }|r&|�dd�}|d }t|�dkr`|d }nd}|||< q&W n|}|S )z3Generates dictionary from string or list of strings�
splitlines� __reversed__N� r r[ )r? r �stripr; �len)�clsr9 rC r" Zkey_val�key�valr r r rx i s
zStubbornDict.to_dictN) r r r r rw rP ry r} r~ � classmethodrx r r r r ru G s
ru c O s4 i }x | D ]}|� t�|�� q
W |� |� t|�S )az
>>> sorted(stubbornDict('cow a bovine\nhorse an equine').items())
[('cow', 'a bovine'), ('horse', 'an equine')]
>>> sorted(stubbornDict(['badger', 'porcupine a poky creature']).items())
[('badger', ''), ('porcupine', 'a poky creature')]
>>> sorted(stubbornDict(turtle='has shell', frog='jumpy').items())
[('frog', 'jumpy'), ('turtle', 'has shell')]
)rw ru rx )r9 �kwargrC r" r r r r{ s
r{ c C sN | rDy t tj�| d ���� }W qJ tk
r@ d| d }Y qJX nt� }|S )Nr z< %s)�open�os�path�
expanduserrg �IOErrorr` )�fnamerC r r r �replace_with_file_contents� s r� c @ s e Zd ZdS )�EmbeddedConsoleExitN)r r r r r r r r� � s r� c @ s e Zd ZdS )�EmptyStatementN)r r r r r r r r� � s r� � c C s@ t | d�r| �||�S t| �|k r8| |g| d|� } | S dS )z+analogous to str.ljust, but works for lists�ljustN)r? r� r� )�x�widthZfillcharr r r r� � s
r� c @ sd e Zd ZdZdZdZdZdej ej Z
ddddd �Z d
� � Z
dZd � � Zd Zd
ZdZdZg ZdZdZdZdZdZdZed�Z dd� Z d�dd�Z dd� Z dZ dZ!e"j#�$d�Z%e%s�e&j'dd� dkr�dZ%nxd D ]Z%e(e%�r�P q�W d d d �d d!d �d"d!d �d#d!d �d$d!d �d%d!d �d&d'd �d(�Z)e'�*� d)kZ+d*d+� Z,d,d-� Z-d.d/� Z.d0d1� Z/d2d3� Z0e�1� Z2e�3ej4ej5g�Z6e6�7d4d5� � e�8d6�e�9ej:d7A � Z;d8gZ<dZ=g Z>d9d:� Z?d;d<� Z@d=d>� ZAd?d@� ZBdAdB� ZCdCdD� ZDdEdF� ZEdGdH� ZFdIdJ� ZGdKdL� ZHdMdN� ZIdOdP� ZJdQdR� ZKdSdT� ZLd�dUdV�ZMdWdX� ZNeNZOdYdZ� ZPePZQePZRd�d\d]�ZSeTeUd^d_d`dadb�g�dcdd� �ZVdedf� ZWdgdh� ZXdidj� ZYdkdl� ZZeTeUdmdnd`dodb�gdpdq�drds� �Z[dtdu� Z\dvdw� Z]e[Z^e]Z_e]Z`dxdy� ZaeaZbe�ce�deje�dzA �d{�e�ce�de
d| ��d}� ej: Zfd~d� Zgd�d�� Zhd�d�d��Ziej�kd��Zld�d�d��ZmemZnd�d�� ZoeoZpd�d�� Zqd�d�� Zrd�d�� Zsd�d�� ZtdS )��CmdFTz> z !#$%.:?@_�helpre �loadZ_relative_load)�?�!�@z@@z&run r list l history hi ed edit li eofzset ed edit exitra z command.txtN�>a�
prompt
colors Colorized output (*nix only)
continuation_prompt On 2nd+ line of input
debug Show full error stack on error
default_file_name for ``save``, ``load``, etc.
editor Program used by ``edit``
case_insensitive upper- and lower-case both OK
feedback_to_output include nonessentials in `|`, `>` results
quiet Don't print nonessential feedback
echo Echo command issued into output
timing Report execution times
abbrev Accept abbreviated commands
c C s, |r(| j �|� |d dkr(| j �d� dS )zGConvenient shortcut for self.stdout.write(); adds newline if necessary.����
N)r/ rm )r
r r r r �poutput� s z Cmd.poutputc C s | j rt�� tt|�� d S )N)�debug� traceback� print_excr �str)r
rX rt r r r �perror� s z
Cmd.perrorc C s$ | j s | jr| �|� nt|� dS )z�For printing nonessential feedback. Can be silenced with `quiet`.
Inclusion in redirected output is controlled by `feedback_to_output`.N)�quiet�feedback_to_outputr� r )r
r r r r � pfeedback� s z
Cmd.pfeedbacki���ZEDITORr rU Znotepad)ZgeditZkate�vim�vi�emacsZnanoZpicoz[1mz[22m)TFz[36mz[39mz[34mz[31mz[35mz[32mz[4mz[24m)�bold�cyan�blue�red�magenta�green� underline�Windowsc C s6 | j r2| j| jkr2| j| d | | j| d S |S )a� Given a string (``val``), returns that string wrapped in UNIX-style
special characters that turn on (and then off) text color and style.
If the ``colors`` environment paramter is ``False``, or the application
is running on Windows, will return ``val`` unchanged.
``color`` should be one of the supported strings (or styles):
red/blue/green/cyan/magenta, bold, underlineTF)�colorsr/ �initial_stdout�
colorcodes)r
r� �colorr r r �colorize� s z Cmd.colorizec C s4 | j �d| jrdpdt| j�d�| j�d� � dS )z)Summary report of interactive parameters.z�
Commands are %(casesensitive)scase-sensitive.
Commands may be terminated with: %(terminators)s
Settable parameters: %(settable)s
znot r[ r� )Z
casesensitive� terminators�settableN)r/ rm �case_insensitiver� r� r$ r� )r
r r r r �do_cmdenvironment s
zCmd.do_cmdenvironmentc C sp |r^| � |�}|rlt| |�}y|jj| jd� W ql tk
rZ tj�| |dd � � Y qlX ntj�| |� d S )N)�filer ) �
func_namedr* rE r r/ r �cmdr� �do_help)r
r9 �funcname�fnr r r r� s
z Cmd.do_helpc O sd t jj| f|�|� tj| _t� | _i | _t | j
� � dd�| _
| j dd� t
| �D � | _| �� d S )NT)�reversec S s" g | ]}|� d �r|dd� �qS )�do_r N)�
startswith)r! r� r r r �
<listcomp>) s z Cmd.__init__.<locals>.<listcomp>)r� r� rW rY r/ r� �History�history�pystate�sorted� shortcuts�items�reserved_words�dir�keywords� _init_parser)r
r r r r r rW # s z Cmd.__init__c C s. d� dd� t| j�D ��}| j�d| � dS )z%Lists single-key shortcuts available.r� c s s" | ]}d |d |d f V qdS )z%s: %sr r� Nr )r! �scr r r r# . s z#Cmd.do_shortcuts.<locals>.<genexpr>z,Single-key shortcuts for other commands:
%s
N)r$ r� r� r/ rm )r
r rC r r r � do_shortcuts, s zCmd.do_shortcutsc C s dS )Nr[ r )r� r r r �<lambda>3 � z Cmd.<lambda>z/*z*/�;c s t �� jd �t �� � j B t �d� j �B d�}t �dd� � jD ��d�}t jdA }t �� fdd�� jD ��d �� _ � j t �
� j � d
�}t j d d d �}� j
�t j��d
d� � � j
� jB t jB }t �|t j||A |d�d� �t �|t j||d��dd� �d� � }� j�r2� j �dd� � |�dd� � � j�rDt j� _nRt jt j d�� _� j�d� � j |A t j� j|d��dd� �d� � j d�� _� j |A t j||d��dd� �d� | d�t j||A |A |d��dd� �d� | � _� j�� j� |t j||A |A |A |d��dd� �d� d�t �|� | � _ � j�d�� _� j |� jB � j B � jB � j t j||d� B � _ � j �� j
� t �d �}|�d d� � t �
� j d �} | d �}
|
�t � |t �|
� t �d � t �| � t jd B � _ � j �� j� d!S )"a�
>>> c = Cmd()
>>> c.multilineCommands = ['multiline']
>>> c.case_insensitive = True
>>> c._init_parser()
>>> print (c.parser.parseString('').dump())
[]
>>> print (c.parser.parseString('').dump())
[]
>>> print (c.parser.parseString('/* empty command */').dump())
[]
>>> print (c.parser.parseString('plainword').dump())
['plainword', '']
- command: plainword
- statement: ['plainword', '']
- command: plainword
>>> print (c.parser.parseString('termbare;').dump())
['termbare', '', ';', '']
- command: termbare
- statement: ['termbare', '', ';']
- command: termbare
- terminator: ;
- terminator: ;
>>> print (c.parser.parseString('termbare; suffx').dump())
['termbare', '', ';', 'suffx']
- command: termbare
- statement: ['termbare', '', ';']
- command: termbare
- terminator: ;
- suffix: suffx
- terminator: ;
>>> print (c.parser.parseString('barecommand').dump())
['barecommand', '']
- command: barecommand
- statement: ['barecommand', '']
- command: barecommand
>>> print (c.parser.parseString('COMmand with args').dump())
['command', 'with args']
- args: with args
- command: command
- statement: ['command', 'with args']
- args: with args
- command: command
>>> print (c.parser.parseString('command with args and terminator; and suffix').dump())
['command', 'with args and terminator', ';', 'and suffix']
- args: with args and terminator
- command: command
- statement: ['command', 'with args and terminator', ';']
- args: with args and terminator
- command: command
- terminator: ;
- suffix: and suffix
- terminator: ;
>>> print (c.parser.parseString('simple | piped').dump())
['simple', '', '|', ' piped']
- command: simple
- pipeTo: piped
- statement: ['simple', '']
- command: simple
>>> print (c.parser.parseString('double-pipe || is not a pipe').dump())
['double', '-pipe || is not a pipe']
- args: -pipe || is not a pipe
- command: double
- statement: ['double', '-pipe || is not a pipe']
- args: -pipe || is not a pipe
- command: double
>>> print (c.parser.parseString('command with args, terminator;sufx | piped').dump())
['command', 'with args, terminator', ';', 'sufx', '|', ' piped']
- args: with args, terminator
- command: command
- pipeTo: piped
- statement: ['command', 'with args, terminator', ';']
- args: with args, terminator
- command: command
- terminator: ;
- suffix: sufx
- terminator: ;
>>> print (c.parser.parseString('output into > afile.txt').dump())
['output', 'into', '>', 'afile.txt']
- args: into
- command: output
- output: >
- outputTo: afile.txt
- statement: ['output', 'into']
- args: into
- command: output
>>> print (c.parser.parseString('output into;sufx | pipethrume plz > afile.txt').dump())
['output', 'into', ';', 'sufx', '|', ' pipethrume plz', '>', 'afile.txt']
- args: into
- command: output
- output: >
- outputTo: afile.txt
- pipeTo: pipethrume plz
- statement: ['output', 'into', ';']
- args: into
- command: output
- terminator: ;
- suffix: sufx
- terminator: ;
>>> print (c.parser.parseString('output to paste buffer >> ').dump())
['output', 'to paste buffer', '>>', '']
- args: to paste buffer
- command: output
- output: >>
- statement: ['output', 'to paste buffer']
- args: to paste buffer
- command: output
>>> print (c.parser.parseString('ignore the /* commented | > */ stuff;').dump())
['ignore', 'the /* commented | > */ stuff', ';', '']
- args: the /* commented | > */ stuff
- command: ignore
- statement: ['ignore', 'the /* commented | > */ stuff', ';']
- args: the /* commented | > */ stuff
- command: ignore
- terminator: ;
- terminator: ;
>>> print (c.parser.parseString('has > inside;').dump())
['has', '> inside', ';', '']
- args: > inside
- command: has
- statement: ['has', '> inside', ';']
- args: > inside
- command: has
- terminator: ;
- terminator: ;
>>> print (c.parser.parseString('multiline has > inside an unfinished command').dump())
['multiline', ' has > inside an unfinished command']
- multilineCommand: multiline
>>> print (c.parser.parseString('multiline has > inside;').dump())
['multiline', 'has > inside', ';', '']
- args: has > inside
- multilineCommand: multiline
- statement: ['multiline', 'has > inside', ';']
- args: has > inside
- multilineCommand: multiline
- terminator: ;
- terminator: ;
>>> print (c.parser.parseString('multiline command /* with comment in progress;').dump())
['multiline', ' command /* with comment in progress;']
- multilineCommand: multiline
>>> print (c.parser.parseString('multiline command /* with comment complete */ is done;').dump())
['multiline', 'command /* with comment complete */ is done', ';', '']
- args: command /* with comment complete */ is done
- multilineCommand: multiline
- statement: ['multiline', 'command /* with comment complete */ is done', ';']
- args: command /* with comment complete */ is done
- multilineCommand: multiline
- terminator: ;
- terminator: ;
>>> print (c.parser.parseString('multiline command ends\n\n').dump())
['multiline', 'command ends', '\n', '\n']
- args: command ends
- multilineCommand: multiline
- statement: ['multiline', 'command ends', '\n', '\n']
- args: command ends
- multilineCommand: multiline
- terminator: ['\n', '\n']
- terminator: ['\n', '\n']
>>> print (c.parser.parseString('multiline command "with term; ends" now\n\n').dump())
['multiline', 'command "with term; ends" now', '\n', '\n']
- args: command "with term; ends" now
- multilineCommand: multiline
- statement: ['multiline', 'command "with term; ends" now', '\n', '\n']
- args: command "with term; ends" now
- multilineCommand: multiline
- terminator: ['\n', '\n']
- terminator: ['\n', '\n']
>>> print (c.parser.parseString('what if "quoted strings /* seem to " start comments?').dump())
['what', 'if "quoted strings /* seem to " start comments?']
- args: if "quoted strings /* seem to " start comments?
- command: what
- statement: ['what', 'if "quoted strings /* seem to " start comments?']
- args: if "quoted strings /* seem to " start comments?
- command: what
r z[^=]�outputc S s$ g | ] }t |d �r|p t�|��qS )� parseString)r? r rQ )r! �tr r r r� � s z$Cmd._init_parser.<locals>.<listcomp>�
terminatorz
EOFc s g | ]}t j|� jd ��qS ))�caseless)r �Keywordr� )r! �c)r
r r r� � s �multilineCommandrp �|)�
identCharsc S s dS )Nr[ r )r� r r r r� � r� z"Cmd._init_parser.<locals>.<lambda>)�ignore�pipeToc S s | d � � S )Nr )r� )r� r r r r� � r� �outputToc S s | d � � S )Nr )�lower)r� r r r r� r� c S s | d � � S )Nr )r� )r� r r r r� r� c S s | d � � S )Nr )r� )r� r r r r� r� r rt c S s | d � � S )Nr )r� )r� r r r r� r� c S s | d � � S )Nr )r� )r� r r r r� r� �suffixc S s | d � � S )Nr )r� )r� r r r r� ! r� �<c S s dS )Nr[ r )r� r r r r� 3 r� z/\� inputFromr� N)!r rQ �
redirector� WordStart�Regex�Orr� � stringEnd�multilineCommandsr� �Word�
legalCharsr� �commentGrammarsr� � quotedString�setParseAction�commentInProgress�Optional�SkipTor� �blankLinesAllowed�NoMatchZblankLineTerminationParser�lineEndZblankLineTerminator�setResultsNameZmultilineParserZsingleLineParser� prefixParserrq r� � inputParser) r
Z outputParserZterminatorParserr� ZoneLineCommand�pipeZ
doNotParseZ
afterElementsZ inputMark�fileNamer� r )r
r r� 9 sT 5,
"
,
X @.
.zCmd._init_parserc K s |S )Nr )r
�rawr r r r �preparseB s z Cmd.preparsec C s |S )Nr )r
Z parseResultr r r � postparseE s z
Cmd.postparsec
K s� t |t�r|}n�| j|f|�}| j�|�� �}| j�|�}x4| jD ]*\}}|�� � |�rB|�
||d d�}P qBW | j � |�}||d< |j
p�|j|d< | �|�}t|j�}||_| j|_ x |�� D ]\}} | |j|< q�W |S )Nr� r� r� rp )r< r= r� r� �transformString�lstripr� r� r� r� �replacerq r� r� rp r� r ro r� )
r
r� r �p�sZshortcutZ expansionrC r� r� r r r ro H s&
z
Cmd.parsedc C s d}||fS )Nr r )r
rt �stopr r r �postparsing_precmd_ s zCmd.postparsing_precmdc C s |S )Nr )r
r r r r �postparsing_postcmdc s zCmd.postparsing_postcmdc sT d }d� }|t | �kr |}n2| jrP� fdd�| jD �}t|�dkrPd|d }|S )Nr� c s g | ]}|� � �r|�qS r )r� )r! r� )r9 r r r� m s z"Cmd.func_named.<locals>.<listcomp>r� r )r� �abbrevr� r� )r
r9 rC �target�funcsr )r9 r r� f s zCmd.func_namedc
C s
d}z�y�| � |�}| �|�\}}|r.| �|�S |jj| jkrL| j�|jj� zZ| � |� t
j
� � }| � |�}| �
|�}| �||�}| jr�| �dtt
j
� � | � � W d | �|� X W nD tk
r� dS tk
r� } z| �t|�|� W d d }~X Y nX W d | �|�S )Nr z Elapsed: %s)�complete_statementr r ro rp �excludeFromHistoryr� rP r� �redirect_output�datetime�nowZprecmd�onecmdZpostcmd�timingr� r� �restore_outputr� rV r� )r
�liner rt Z timestartrB r r r �onecmd_plus_hooksr s.
&zCmd.onecmd_plus_hooksc C s~ |r t �| j��dd� ��|�s&t� �| �|�}x:|jjrj|jjdkrjd|jj | �
| j �f }| �|�}q2W |jj szt� �|S )z<Keep accepting lines of input until the command is complete.c S s dS )Nr[ r )r� r r r r� � r� z(Cmd.complete_statement.<locals>.<lambda>r[ z%s
%s)
r r� r� r� r� r� ro r� r� r� �pseudo_raw_input�continuation_promptrp )r
r rt r r r r
� s
zCmd.complete_statementc C s� |j jrNt| d�| _ttd�| _tj|j jdtjtjd�| _ | j j
t_ | _ n�|j j r�|j j
sjtsjtd��t| d�| _ttd�| _|j j
r�d}|j j d| j kr�d}ttj�|j j
�|� t_ | _ n.tjdd � t_ | _ |j j d
kr�| j �t� � d S ) N)r/ T)re r/ rf zGCannot redirect to paste buffer; install ``xclip`` and re-run to enable�wr r" zw+)�modez>>)ro r� � Statekeeper�
kept_staterY �kept_sysr1 r2 r3 �redirectrf r/ r� r� �can_clip�EnvironmentErrorr� r� r� r� r� �tempfile�
TemporaryFilerm r` )r
rt r r r r r � s& zCmd.redirect_outputc C s� | j r�|jjr2|jjs`| j�d� t| j�� � n.|jjr`x$| j �
� D ]}| j j� |pXd� qFW | j� � | j �
� | j�
� d | _ d S )Nr r[ )r ro r� r� r/ �seekrb rg r� r r5 rm rn �restorer )r
rt rC r r r r � s
zCmd.restore_outputc C sf | � |�}|j j| _| �|j j�}|s0| �|�S yt| |�}W n tk
rX | �|�S X ||�}|S )a� Interpret the argument as though it had been typed in response
to the prompt.
This may be overridden, but should not normally need to be;
see the precmd() and postcmd() methods for useful execution hooks.
The return value is a flag indicating whether interpretation of
commands by the interpreter should stop.
This (`cmd2`) version of `onecmd` already override's `cmd`'s `onecmd`.
)ro r� �lastcmdr� rp �_defaultr* r )r
r rt r� rD r r r r r � s
z
Cmd.onecmdc C s6 |� � }| jr&t�|�}|s&| �d �S | �| �|��S )N)rs �default_to_shellr� �systemr �default)r
rt r9 rC r r r r# � s
z Cmd._defaultc C sx | j r.y t|�}W qt tk
r* d}Y qtX nF| j�|� | j�� | j�� }t|�s\d}n|d dkrt|dd� }|S )zQcopied from cmd's cmdloop; like raw_input, but accounts for changed stdin, stdoutZEOFr� r� N) � use_rawinput� raw_input�EOFErrorr/ rm �flushrf �readliner� )r
�promptr r r r r � s
zCmd.pseudo_raw_inputc C s2 | � � | jr\| jr\y2ddl}|�� | _|�| j� |�| jd � W n t k
rZ Y nX z�|dk rl|| _
| j
r�| j � t
| j
�d � d}xT|s�| jr�| j�d�}n | �| j�}| jr�t| jt�r�| j � |d � | �|�}q�W | �� W d| j�r.| j�r.yddl}|�| j� W n t k
�r, Y nX |S )z�Repeatedly issue a prompt, accept input, parse an initial prefix
off the received input, and dispatch to action methods, passing them
the remainder of the line as argument.
r Nz
: completer� )Zpreloopr' Z completekeyr+ Z
get_completerZ
old_completerZ
set_completerZcomplete�parse_and_bind� ImportError�intror/ rm r� Zcmdqueue�popr r, �echor< rf r� r Zpostloop)r
r/ r+ r r r r r �_cmdloop� s<
z Cmd._cmdloopc C s | j S )N)�_STOP_SCRIPT_NO_EXIT)r
r9 r r r �do_EOF s z
Cmd.do_EOFc C s | j S )N)�_STOP_AND_EXIT)r
r9 r r r �do_quit$ s z Cmd.do_quit�
Your choice? c
C s t |t�r t|�� |�� �}g }xl|D ]d}t |t�rD|�||f� q&y|�|d |d f� W q& tk
r� |�|d |d f� Y q&X q&W x.t|�D ]"\}\}}| �d|d |f � q�W x@t|�}y t |�}||d d } P W q� t
k
r� Y q�X q�W | S )a� Presents a numbered menu to the user. Modelled after
the bash shell's SELECT. Returns the item chosen.
Argument ``options`` can be:
| a single string -> will be split into one-word options
| a list of strings -> will be offered as options
| a list of tuples -> interpreted as (value, text), so
that the return value can differ from
the text advertised to the user r r� z
%2d. %s
) r< �
basestring�zipr; rP �
IndexError� enumerater� r( �int�
ValueError)
r
rS r, Z fulloptionsrJ �idx�value�text�responserC r r r �select* s*
z
Cmd.selectz-lz--long�
store_truez describe function of parameter)�actionr� c C s� |� � �� }i }d}xH| jD ]>}|r.|�|�r d|tt| |��f ||< t|t|| ��}q W |r�xVt|�D ]<}|j r�| �
d|| � |�| j| f � ql| �
|| � qlW n t d| ��dS )zShows value of a parameter.r z%s: %sz%s # %szBParameter '%s' not supported (type 'show' for list of parameters).N)
r� r� r� r� r� r* �maxr� r� �longr� r� �NotImplementedError)r
r9 rA �paramrC �maxlenr r r r �do_showL s $z Cmd.do_showc
sH �y |j j�dd�\}� }|�� }� �� �� � � | jkrl� fdd�| jD �}t|�dkrb|d � n
| �� �S t| � �}|d |d kr�|d dkr�|dd� }n
t ||�}t
| � |� | j � d � ||f � ||k�r y t| d
� �}|||d � W n t
k
�r
Y nX W n4 tt
tfk
�rB } z| �|� W dd}~X Y nX dS ) z�
Sets a cmd2 parameter. Accepts abbreviated parameter names so long
as there is no ambiguity. Call without arguments for a list of
settable parameters with their values.Nr c s g | ]}|� � �r|�qS r )r� )r! r )� paramNamer r r� i s z Cmd.do_set.<locals>.<listcomp>r� r r� )�'�"z%s - was: %s
now: %s
z _onchange_%s)�oldrr )ro r� r; r� r� r� r� rJ r* �cast�setattrr/ rm r r= �NotSettableError)r
r9 rt r� �hitsZ
currentValZ
onchange_hookrB r )rK r �do_set_ s.
z
Cmd.do_setc C s t |d � dS )zDDisplays the specified text then waits for the user to press RETURN.r� N)r( )r
r9 r r r �do_pause~ s z Cmd.do_pausec C s t �|� dS )z)execute a command as if at the OS prompt.N)r� r% )r
r9 r r r �do_shell� s z Cmd.do_shellc s
��j d< |jjdd� �� }�jr*�j p,i }t|d�� � �d� |�� rV� �|� n�dd� }�fdd �}� �fd
d �}|�j d < |�j d
< |�j d< |�j d< yHd}ttd�}�j t_ �j
t_
� j dtj tj
|�jj�jjf d� W n tk
r� Y nX |�� dS )aI
py <command>: Executes a Python command.
py: Enters interactive Python mode.
End with ``Ctrl-D`` (Unix) / ``Ctrl-Z`` (Windows), ``quit()``, '`exit()``.
Non-python commands can be issued with ``cmd("your command")``.
Run python code from external files with ``run("filename.py")``
r
r N)�localsz.import sys, os;sys.path.insert(0, os.getcwd())c S s t �d S )N)r� r r r r �quit� s zCmd.do_py.<locals>.quitc s � � | d �S )Nr� )r )r9 )r
r r r � s z$Cmd.do_py.<locals>.onecmd_plus_hooksc
sT y"t | �}� �|�� � |�� W n, tk
rN } z��|� W d d }~X Y nX d S )N)r� �runcoderg rn r� r� )r9 r� rB )�interpr
r r �run� s zCmd.do_py.<locals>.runrW r r� rZ zFType "help", "copyright", "credits" or "license" for more information.)rf r/ zPython %s on %s
%s
(%s)
%s)Zbanner)r� ro r� r� � locals_in_pyr rX r rY r/ rf Zinteract�versionrZ � __class__r �do_pyr r� r! )r
r9 Z localvarsrW r rZ Zcprt� keepstater )rY r
r r^ � s2
$z Cmd.do_pyz-sz--scriptz"Script format; no separation linesz$(limit on which commands to include))rK c C sL |r| j �|�}n| j }x.|D ]&}|jr4| �|� q | j�|�� � q W dS )a history [arg]: lists past commands issued
| no arg: list all
| arg is integer: list one history item, by index
| arg is string: string search
| arg is /enclosed in forward-slashes/: regular expression search
N)r� �get�scriptr� r/ rm �pr)r
r9 rA r� �hir r r �
do_history� s
zCmd.do_historyc C s< y"|r| j �|�d S | j d S W n tk
r6 d S X d S )Nr� )r� r` r: )r
r9 r r r �
last_matching� s zCmd.last_matchingc C sV y| j �|pd�}W n tk
r4 | j �|�}Y nX x|D ]}| �|�� � q<W dS )ai list [arg]: lists last command issued
no arg -> list most recent command
arg is integer -> list one history item, by index
a..b, a:b, a:, ..b -> list spans from a (or start) to b (or end)
arg is string -> list all commands matching string search
arg is /enclosed in forward-slashes/ -> regular expression search
z-1N)r� �spanr: r% r� rb )r
r9 r� rc r r r �do_list� s
z Cmd.do_listc C s� | j std��| j}|rJy| �t|��}W qT tk
rF |}d}Y qTX n
| jd }|r�ttj �
|�d�}|� |ptd� |� � t�
d| j |f � | �|� dS )a8 ed: edit most recent command in text editor
ed [N]: edit numbered command from history
ed [filename]: edit specified file name
commands are run after editor is closed.
"set edit (program-name)" or set EDITOR environment variable
to control which editing program is used.zGPlease use 'set editor' to specify your text editing program of choice.r[ r� r z%s %sN)r7 r �default_file_namere r< r= r� r� r� r� r� rm rn r% �do__load)r
r9 �filename�buffer�fr r r �do_ed� s
z Cmd.do_ed�*r> z/\r� c
C s y| j �|�}W n0 tjk
r@ | �d| � t| jj��Y nX |jpL| j }|j
dkrnd� | j dd� �}n&|j
r�| j t
|j
�d }n
| j d }y6ttj�|�d�}|�|� |�� | �d| � W n2 tk
r� } z| �d | � � W dd}~X Y nX dS )
z�`save [N] [filename.ext]`
Saves command from history to file.
| N => Number of command (from history), or `*`;
| most recent command if omittedz#Could not understand save target %srn z
Nr� r� r z Saved to %szError saving %s)�
saveparserr� r �ParseExceptionr� � SyntaxError�do_saver r� rh r> r$ r� r< r� r� r� r� rm rn r� rV )r
r9 r r� Zsavemerl rB r r r rr
s&
z Cmd.do_savec C s� t |t�rt|d�}nv| j�|�}|r8t�|�d��}nTtj �
|�}yttj �
|�d�}W n0 t k
r� tdtj �
|�| j f d�}Y nX |S )N�rr� z%s.%s)
r< r� r� �urlre�match�urllib�urlopen�groupr� r� r� r� �defaultExtension)r
r� rC ru r r r �read_file_or_url* s
"zCmd.read_file_or_urlc C sZ |rV|� dd�}|d |dd� p&dgd }}tj�| jp>d|�}| �d||f � dS )z�
Runs commands in script at file or URL; if this is called from within an
already-running script, the filename will be interpreted relative to the
already-running script's directory.Nr� r r[ z%s %s)r; r� r� r$ �current_script_dirri )r
r9 �
targetnamer r r r �do__relative_load: s
zCmd.do__relative_loadz(https?://[-\w\./]+)c
C s� |dkr| j }n0|�dd�}|d |dd� p2dgd �� }}y| �|�}W n4 tk
r� } z| �d||f � dS d}~X Y nX t| d�}|| _d| _d | _ | _
t j �|�d | _
| �� }| j�� |�� d| _|o�|| jkS )z-Runs script of command(s) from a file or URL.Nr� r r[ z%Problem accessing script from %s:
%s)rf r' r, r r{ F)rh r; r� rz r� r� r rf r' r, r r� r� r{ r2 rn r! r" r3 )r
r9 r| r r rB r_ r r r r �do_loadG s& $
z Cmd.do_loadc C s& | � |�}| �|� |r"| �|�}dS )a run [arg]: re-runs an earlier command
no arg -> run most recent command
arg is integer -> run one history item, by index
arg is string -> run most recent command by string search
arg is /enclosed in forward-slashes/ -> run most recent by regex
N)re r� r )r
r9 Zrunmer r r r �do_run` s
z
Cmd.do_runc C sN yt tj�|��}W n$ tk
r8 | j�d| � dS X |�� }|�� |S )NzCouldn't read from file %s
r[ ) r� r� r� r� r� r/ rm rg rn )r
rt �sourcerl �datar r r �
fileimportp s zCmd.fileimportc sN G � fdd�dt �}|� j_tjd gt_|� }t�� }|�|�}|�� d S )Nc s e Zd Z� jZdS )z-Cmd.runTranscriptTests.<locals>.TestMyAppCaseN)r r r r] �CmdAppr )r
r r �
TestMyAppCase{ s r� r ) � Cmd2TestCaser] � testfilesrY �argv�unittestZTextTestRunnerrZ Z printErrors)r
�callargsr� Ztestcase�runnerrC r )r
r �runTranscriptTestsz s
zCmd.runTranscriptTestsc C s& x |D ]}| � |d �r| jS qW d S )Nr� )r r5 )r
r� Zinitial_commandr r r �run_commands_at_invocation� s
z Cmd.run_commands_at_invocationc C sP t �� }|jdddddd� |�� \}}|jr:| �|� n| �|�sL| �� d S )Nz-tz--test�testrC z1Test against transcript(s) in FILE (wildcards OK))�destrD r� )r r rG r: r� r� r� r2 )r
rq Zcalloptsr� r r r �cmdloop� s
z Cmd.cmdloop)N)N)r7 )N)N)ur r r r1 r� r r r � alphanums�
alphas8bitr� r� r; r r$ ZnoSpecialParsery rh r r{ r� r� r� r� r[ r r� r{ r� r� r� r� r5 r3 r� �environr` r7 rY rZ r8 r� r% r� r� r� r� rW r� �Emptyr� r� �pythonStyleComment�
cStyleCommentr� �addParseActionrQ r� r� r� r� r� r� r� r� r� ro r r r� r r
r r r r# r r2 r4 Zdo_eofr6 Zdo_exitZdo_qrB rS r rJ rS rT rU r^ rd re rg Zdo_hiZdo_lZdo_lirm Zdo_editr� r� �numsro rr rz r} r �compilert r~ ri r Zdo_rr� r� r� r� r r r r r� � s�
,
" 0 8
r� c @ s e Zd ZdZdd� Zdd� ZdS )� HistoryItemz!-------------------------[%d]
%s
c C s t �| � | �� | _d | _d S )N)r� rW r� � lowercaser> )r
�instrr r r rW � s
zHistoryItem.__init__c C s | j | jt| �f S )N)�
listformatr> r� )r
r r r rb � s zHistoryItem.prN)r r r r� rW rb r r r r r� � s r� c @ s^ e Zd ZdZdd� Zdd� Zdd� Ze�d�Z d d
� Z
e�d �Z d d
� Z dd� Z
ddd�ZdS )r� ab A list of HistoryItems that knows how to respond to user requests.
>>> h = History([HistoryItem('first'), HistoryItem('second'), HistoryItem('third'), HistoryItem('fourth')])
>>> h.span('-2..')
['third', 'fourth']
>>> h.span('2..3')
['second', 'third']
>>> h.span('3')
['third']
>>> h.span(':')
['first', 'second', 'third', 'fourth']
>>> h.span('2..')
['second', 'third', 'fourth']
>>> h.span('-1')
['fourth']
>>> h.span('-2..-3')
['third', 'second']
>>> h.search('o')
['second', 'fourth']
>>> h.search('/IR/')
['first', 'third']
c C s |}|dkr|d8 }|S )Nr r� r )r
ZonebasedrC r r r �zero_based_index� s zHistory.zero_based_indexc C s |r| � t|��}nd }|S )N)r� r< )r
r� rC r r r �to_index� s zHistory.to_indexc sl |� � }|d |d kr$dkrBn nt|�dkrB|dd� }n
t�|�}t�|tj�� � fdd�| D �S )Nr r� �/r� c s g | ]}� � |�r|�qS r )r% )r! r )r( r r r� � s z"History.search.<locals>.<listcomp>)r� r� r r r� �
IGNORECASE)r
r r )r( r r% � s ,
zHistory.searchzJ^\s*(?P<start>\-?\d+)?\s*(?P<separator>:|(\.{2,}))?\s*(?P<end>\-?\d+)?\s*$c C s� |� � dkrd}| j�|�}|s$t�|�d�sD| | �|�d�� gS | �|�d��}| �|�d��}d}|d k r�||k r�|| }}d}|d7 }| ||� }|r�|�� |S ) N)rn �-�all�:� separatorr& �endFTr� )r� � spanpatternr% r: rx r� r� )r
r� �resultsr& r� r� rC r r r rf � s&
z History.spanz0^\s*(?P<start>[\d]+)?\s*\-\s*(?P<end>[\d]+)?\s*$c C s" t |�}t�| |� t| �|_d S )N)r� rN rP r� r> )r
rr r r r rP � s zHistory.appendc C s x|D ]}| � |� qW d S )N)rP )r
rr �nr r r �extend� s
zHistory.extendNFc s& �s| S y2t ����dk r*| d d� � S | �d gS W n� tk
rN g S tk
�r | j���}|r�|�d�pzd }|�d�p�d }|r�t |�d }|r�t |�}| ||� S ��� ���d��r��d��rt �
�dd� t j t j B t j
B �� � fdd��n �fdd���fd d
�| D �S X d S ) Nr r� r� r& r� c s
� � | �S )N)r% )rc )�finderr r �isin
s zHistory.get.<locals>.isinc s � � � | jkS )N)r� r� )rc )�getmer r r� s c s g | ]}� |�r|�qS r r )r! Zitm)r� r r r� s z History.get.<locals>.<listcomp>)r< r: r= � rangePatternr% rx r� r� �endswithr r� �DOTALL� MULTILINEr� )r
r� ZfromEndZ rangeResultr& r� r )r� r� r� r r` � s2 " z History.get)NF)r r r r r� r� r% r r� r� rf r� rP r� r` r r r r r� � s
r� c @ s e Zd ZdS )rQ N)r r r r r r r rQ s rQ c C s� t | �}|tkr�y tt|��S ttfk
r4 Y nX y |�� }W n tk
rV Y nX |dksl|d dkrpdS |dks�|d dkr�dS n y||�S tk
r� Y nX td| |f � | S ) z=Tries to force a new value into the same type as the current.�onr )�yr� T�off)r� rl Fz9Problem setting parameter (now %s) to %s; incorrect type?)�type�boolr< r= r^ r� rV r )�currentrr �typr r r rO s( rO c @ s$ e Zd Zdd� Zdd� Zdd� ZdS )r c C s || _ || _| j r| �� d S )N)r+ �attribs�save)r
r+ r� r r r rW 6 s zStatekeeper.__init__c C s( x"| j D ]}t| |t| j|�� qW d S )N)r� rP r* r+ )r
�attribr r r r� < s zStatekeeper.savec C s. | j r*x"| jD ]}t| j |t| |�� qW d S )N)r+ r� rP r* )r
r� r r r r! @ s zStatekeeper.restoreN)r r r rW r� r! r r r r r 5 s r c @ s e Zd ZdZi Zdd� ZdS )�BorgzcAll instances of any Borg subclass will share state.
from Python Cookbook, 2nd Ed., recipe 6.16c O s t j| f|�|�}| j|_|S )N)�object�__new__�
_shared_state�__dict__)r� r" �kr+ r r r r� L s z Borg.__new__N)r r r r r� r� r r r r r� F s r� c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
S ) �
OutputTrapz�Instantiate an OutputTrap to divert/capture ALL stdout output. For use in unit testing.
Call `tearDown()` to return to normal output.c C s d| _ tj| _| t_d S )Nr[ )�contentsrY r/ �
old_stdout)r
r r r rW V s zOutputTrap.__init__c C s | j |7 _ d S )N)r� )r
ra r r r rm [ s zOutputTrap.writec C s | j }d| _ |S )Nr[ )r� )r
rC r r r rg ^ s zOutputTrap.readc C s | j t_d| _d S )Nr[ )r� rY r/ r� )r
r r r �tearDownc s zOutputTrap.tearDownN)r r r r rW rm rg r� r r r r r� R s
r� c @ s� e Zd ZdZdZdd� Zdd� Zdd� Zej d d
d d d �Z
e
� ej � e�
ej�Ze�d
d� � e
eB Ze�dejejB �Zdd� Zdd� ZdS )r� z�Subclass this, setting CmdApp, to make a unittest.TestCase class
that will execute the commands in a transcript file and expect the results shown.
See example.pyNc C sd i | _ xF| jjD ]:}x4t�|�D ]&}t|�}t|�� �| j |< |�� q W qW t| j �s`t d��d S )Nz&No test files found - nothing to test.)
� transcriptsr� r� �globr� �iter� readlinesrn r� �
StandardError)r
Zfilesetr� Ztfiler r r �fetchTranscriptso s
z Cmd2TestCase.fetchTranscriptsc C s$ | j r t� | _| � � | _| �� d S )N)r� r� �
outputTrap�cmdappr� )r
r r r �setUpy s
zCmd2TestCase.setUpc C s6 | j r2t| j�� �}x |D ]\}}| �||� qW d S )N)r� r� r� r� �_test_transcript)r
Zitsr� �
transcriptr r r �runTest s zCmd2TestCase.runTestr� �\T)� quoteChar�escChar� multiline�unquoteResultsc C s t �| d �S )Nr )r r )r� r r r r� � r� zCmd2TestCase.<lambda>z\sc C s d}d}t �|�}|d7 }d}�x�|�s
xD|�| jj�slyt �|�}W n tk
r` d}P Y nX |d7 }q*W |t| jj�d � g}t �|�}xh|�| jj�r�|�|t| jj�d � � yt �|�}W n$ tk
r� td|d f�Y nX |d7 }q�W d� |�}| j�
|�}| j � � } |�| jj��rLd|||| f }
| �
| �� |
� q"g } xT|�| jj��s�| �|� yt �|�}W n tk
�r� d}P Y nX |d7 }�qRW d� | �} d|||| | f }
| j�| �} | j�d| �} | j�d| �} | �
t�| | tjtjB �|
� q"W d S ) Nr Fr� TzGTranscript broke off while reading command beginning at line %d with
%sr[ z>
File %s, line %d
Command was:
%r
Expected: (nothing)
Got:
%r
z7
File %s, line %d
Command was:
%s
Expected:
%s
Got:
%s
)r �nextr� r� r, �
StopIterationr� r rP r$ r r� rg Zassert_r� �expectationParserr� �
anyWhitespace�subr ru r� r� ) r
r� r� ZlineNum�finishedr Z tests_runrp r rC �message�expectedr r r r� � sl
z Cmd2TestCase._test_transcriptc C s | j r| j�� d S )N)r� r� r� )r
r r r r� � s zCmd2TestCase.tearDown)r r r r r� r� r� r� r � QuotedStringZ regexPatternr� r� r� �
printablesZnotRegexPatternr� r� r r� r� r� r� r� r� r r r r r� h s
Cr� �__main__)Z optionflags)r9 )r� )Vr r� r r� rY r r1 r �doctestr� r
rv r� r� rZ rz Zexabgp.vendoringr �coder r r r � __version__� version_info�
ParserElement�
enablePackratrV r� r r) r- r8 �Valuesr` rO rS r rT rc Z mswindowsr\ r` rb r. r �
check_callr3 �CalledProcessErrorr6 r� r Z
teststringr2 rk rf rm rn r/ rg �setDefaultWhitespaceCharsr� r= rv ru r{ r� �
SystemExitr� r� r� r� r� rN r� rQ rO r� r r� r� ZTestCaser� r �testmodZNORMALIZE_WHITESPACEr r r r �<module> s�
7
8
r u l