3
/*^s                 @   s   d Z ddlmZ ddlZddlmZmZ ddlmZm	Z
 ddlmZ G dd deZd	d
 ZG dd deZdd Ze
ddfddZG dd deZejde
dfddZedkrdd Zeej dS )z$
Common uncompyle6 parser routines.
    )print_functionN)iscodepy_str2float)GenericASTBuilderDEFAULT_DEBUG)maybe_show_asmc               @   s    e Zd ZefddZdd ZdS )ParserErrorc             C   s   || _ || _|| _d S )N)tokenoffsetdebug)selfr	   r
   r    r   N/home/psgendb/BIRCHDEV/python/lib/python3.6/site-packages/uncompyle6/parser.py__init__    s    zParserError.__init__c             C   s   d| j | jf S )Nz5Parse error at or near `%r' instruction at offset %s
)r	   r
   )r   r   r   r   __str__%   s    zParserError.__str__N)__name__
__module____qualname__PARSER_DEFAULT_DEBUGr   r   r   r   r   r   r      s   r   c             C   s   d S )Nr   )r   argsr   r   r   nop_func,   s    r   c                   s   e Zd Z fddZdd Zdd Zdd Zd	d
 Zdd Zdd Z	dd Z
dd Zdd Zdd Zdd Zdd Zdd Zdd Zdd  Zd!d" Zd#d$ Zd%d& Zd'd( Zd)d* Zd+d, Zd-d. Zd/d0 Zd1d2 Zd3d4 Z  ZS )5PythonParserc                sr   t t| j||| ddddddddd	d
ddddddg}t|| _td| _|  jtdO  _td| _g | _d S )NZ_come_froms_stmtsZ
attributes
come_fromsZexcept_stmtsexprlistZ
importlistkvlistkwargsZl_stmtsZstmtsZprint_itemsZimports_contkvlist_nZcome_from_loopsZimportlist37suite_stmtsl_stmts_optc_stmts_opt	stmts_optstmtstrstoresuite_stmts_opt
inplace_op)r   r   )r   r   r   r    r!   r"   )r#   r$   r   r%   r&   )	superr   r   	frozensetcollectkeep_epsilonoptional_nt	singletonZinsts)r   Z
SyntaxTreestartr   Znt_list)	__class__r   r   r   1   s0    


zPythonParser.__init__c             C   s"   t |dr|jS | j|d S d S )Nr
   r   )hasattrr
   ast_first_offset)r   astr   r   r   r0   i   s    
zPythonParser.ast_first_offsetc             C   s.   || j kr*| j j| | j|t |||< dS )aT  Add rule to grammar, but only if it hasn't been added previously
           opname and stack_count are used in the customize() semantic
           the actions to add the semantic action rule. Stack_count is
           used in custom opcodes like MAKE_FUNCTION to indicate how
           many arguments it has. Often it is not used.
        N)Z	new_rulesaddZaddRuler   )r   ruleopnameZ	arg_count	customizer   r   r   add_unique_ruleo   s
    
zPythonParser.add_unique_rulec             C   sB   x<|D ]4}t |dkrq|jdd j }| j||d| qW dS )zAdd rules (a list of string) to grammar. Note that
        the rules must not be those that set arg_count in the
        custom dictionary.
        r   z::=N)lensplitstripr6   )r   rulesr5   r3   r4   r   r   r   add_unique_rules~   s    
zPythonParser.add_unique_rulesc             C   s$   dd |j dD }| j|| dS )zAdd rules (a docstring-like list of rules) to grammar.
        Note that the rules must not be those that set arg_count in the
        custom dictionary.
        c             S   s   g | ]}|j  qS r   )r9   ).0rr   r   r   
<listcomp>   s    z5PythonParser.add_unique_doc_rules.<locals>.<listcomp>
N)r8   r;   )r   Z	rules_strr5   r:   r   r   r   add_unique_doc_rules   s    z!PythonParser.add_unique_doc_rulesc             C   sZ   x6| j | j| jfD ]"}xt|j D ]}d||< q$W qW xt| D ]}t| |d qBW dS )zh
        Remove recursive references to allow garbage
        collector to collect this object.
        N)Z	rule2funcr:   Z	rule2namelistkeysdirsetattr)r   dictir   r   r   cleanup   s
    zPythonParser.cleanupc             C   s   dd }d}|r|r|| }t |dr8|jr8d|j }nd}t |dr|d||j 7 }t|d	 d	kr|d
|||d	  j 7 }q|d7 }nd}td||d dj|d	 |f  dS )zwCustomized format and print for our kind of tokens
        which gets called in debugging grammar reduce rules
        c             S   s.   t | }|jd}|dkr|S |d | S d S )N_   )r#   find)cslast_token_posr   r   r   fix   s
    
z&PythonParser.debug_reduce.<locals>.fix 	linestartzL.%3d: z       r
   z%3srI   z-%-3s z     z               z%s%s ::= %s (%d)r    N)r/   rQ   r
   r7   printjoin)r   r3   tokensparentrN   rO   prefixZp_tokenr   r   r   debug_reduce   s    

zPythonParser.debug_reducec             C   s   d
\}}x t |ddD ]}|| jrP qW x&t |d t|D ]}|| jr>P q>W |dkr|| }td x8t ||D ]*}||krd}nd}td||| f  qvW t||j| jd ntd d| jd d S )NrI   r   zInstruction context:z   z-> z%s%sreducerJ   rJ   )rJ   rJ   rJ   rJ   rJ   )rangerQ   r7   rS   r   r
   r   )r   Zinstructionsindexr-   finishZ	err_tokenrF   indentr   r   r   error   s&    

zPythonParser.errorc             C   s    |j d@ }|j d? d@ }||fS )zbReturn then the number of positional parameters and
        represented by the attr field of token      )attr)r   r	   Zargs_posZargs_kwr   r   r   
get_pos_kw   s    
zPythonParser.get_pos_kwc             C   s   t |}|| jkrv|dkrvt|d ds>tj| ||d g}n|d }t |dkrf|| jkrf|d }q|j|d  nZ|dkr|d | jkrtj| ||d }|d= n*|dkr|| jkr|d }ntj| ||}|S )NrI   r   append)	r7   r)   r/   r   nonterminalr*   rc   r,   r+   )r   ntr   nrvr   r   r   rd      s    

zPythonParser.nonterminalc             C   s   t | tj| |S )N)rS   r   Z	ambiguity)r   childrenr   r   r   Z__ambiguity  s    zPythonParser.__ambiguityc             C   s@   t |dkr d|kr d|kr dS d|kr4d|kr4dS tj| |S )N   Zfunction_defZassigngrammarexpr)r7   r   resolve)r   rA   r   r   r   rl     s
    zPythonParser.resolvec             C   s   dS )zE
        # The start or goal symbol
        stmts ::= sstmt+
        Nr   )r   r   r   r   r   p_start  s    zPythonParser.p_startc             C   s   dS )z
        # eval-mode compilation.  Single-mode interactive compilation
        # adds another rule.
        call_stmt ::= expr POP_TOP
        Nr   )r   r   r   r   r   p_call_stmt  s    zPythonParser.p_call_stmtc             C   s   dS )aW  
        pass ::=

        _stmts ::= stmt+

        # statements with continue
        c_stmts ::= _stmts
        c_stmts ::= _stmts lastc_stmt
        c_stmts ::= lastc_stmt
        c_stmts ::= continues

        lastc_stmt ::= iflaststmt
        lastc_stmt ::= forelselaststmt
        lastc_stmt ::= ifelsestmtc

        c_stmts_opt ::= c_stmts
        c_stmts_opt ::= pass

        stmts_opt ::= _stmts
        stmts_opt ::= pass

        # statements inside a loop
        l_stmts ::= _stmts
        l_stmts ::= returns
        l_stmts ::= continues
        l_stmts ::= _stmts lastl_stmt
        l_stmts ::= lastl_stmt

        lastl_stmt ::= iflaststmtl
        lastl_stmt ::= ifelsestmtl
        lastl_stmt ::= forelselaststmtl
        lastl_stmt ::= tryelsestmtl

        l_stmts_opt ::= l_stmts
        l_stmts_opt ::= pass

        suite_stmts ::= _stmts
        suite_stmts ::= returns
        suite_stmts ::= continues

        suite_stmts_opt ::= suite_stmts

        # passtmt is needed for semantic actions to add "pass"
        suite_stmts_opt ::= pass

        else_suite ::= suite_stmts
        else_suitel ::= l_stmts
        else_suitec ::= c_stmts
        else_suitec ::= returns

        stmt ::= assert

        stmt ::= classdef
        stmt ::= call_stmt

        stmt ::= ifstmt
        stmt ::= ifelsestmt

        stmt ::= whilestmt
        stmt ::= while1stmt
        stmt ::= whileelsestmt
        stmt ::= while1elsestmt
        stmt ::= for
        stmt ::= forelsestmt
        stmt ::= try_except
        stmt ::= tryelsestmt
        stmt ::= tryfinallystmt
        stmt ::= with
        stmt ::= withasstmt

        stmt ::= del_stmt
        del_stmt ::= DELETE_FAST
        del_stmt ::= DELETE_NAME
        del_stmt ::= DELETE_GLOBAL


        stmt   ::= return
        return ::= ret_expr RETURN_VALUE

        # "returns" nonterminal is a sequence of statements that ends in a RETURN statement.
        # In later Python versions with jump optimization, this can cause JUMPs
        # that would normally appear to be omitted.

        returns ::= return
        returns ::= _stmts return

        Nr   )r   r   r   r   r   p_stmt  s    XzPythonParser.p_stmtc             C   s   dS )a  
        stmt               ::= function_def
        function_def       ::= mkfunc store
        stmt               ::= function_def_deco
        function_def_deco  ::= mkfuncdeco store
        mkfuncdeco         ::= expr mkfuncdeco CALL_FUNCTION_1
        mkfuncdeco         ::= expr mkfuncdeco0 CALL_FUNCTION_1
        mkfuncdeco0        ::= mkfunc
        load_closure       ::= load_closure LOAD_CLOSURE
        load_closure       ::= LOAD_CLOSURE
        Nr   )r   r   r   r   r   p_function_defx  s    zPythonParser.p_function_defc             C   s   dS )z
        expr ::= generator_exp
        stmt ::= genexpr_func

        genexpr_func ::= LOAD_FAST FOR_ITER store comp_iter JUMP_BACK
        Nr   )r   r   r   r   r   p_generator_exp  s    zPythonParser.p_generator_expc             C   s   dS )a  
        _jump ::= JUMP_ABSOLUTE
        _jump ::= JUMP_FORWARD
        _jump ::= JUMP_BACK

        # Zero or more COME_FROMs - loops can have this
        _come_froms ::= COME_FROM*

        # One or more COME_FROMs - joins of tryelse's have this
        come_froms ::= COME_FROM+

        # Zero or one COME_FROM
        # And/or expressions have this
        come_from_opt ::= COME_FROM?
        Nr   )r   r   r   r   r   p_jump  s    zPythonParser.p_jumpc             C   s   dS )a  
        stmt ::= aug_assign1
        stmt ::= aug_assign2

        # This is odd in that other aug_assign1's have only 3 slots
        # The store isn't used as that's supposed to be also
        # indicated in the first expr
        aug_assign1 ::= expr expr
                        inplace_op store
        aug_assign1 ::= expr expr
                        inplace_op ROT_THREE STORE_SUBSCR
        aug_assign2 ::= expr DUP_TOP LOAD_ATTR expr
                        inplace_op ROT_TWO STORE_ATTR

        inplace_op ::= INPLACE_ADD
        inplace_op ::= INPLACE_SUBTRACT
        inplace_op ::= INPLACE_MULTIPLY
        inplace_op ::= INPLACE_TRUE_DIVIDE
        inplace_op ::= INPLACE_FLOOR_DIVIDE
        inplace_op ::= INPLACE_MODULO
        inplace_op ::= INPLACE_POWER
        inplace_op ::= INPLACE_LSHIFT
        inplace_op ::= INPLACE_RSHIFT
        inplace_op ::= INPLACE_AND
        inplace_op ::= INPLACE_XOR
        inplace_op ::= INPLACE_OR
        Nr   )r   r   r   r   r   p_augmented_assign  s    zPythonParser.p_augmented_assignc             C   s   dS )a  
        stmt ::= assign
        assign ::= expr DUP_TOP designList
        assign ::= expr store

        stmt ::= assign2
        stmt ::= assign3
        assign2 ::= expr expr ROT_TWO store store
        assign3 ::= expr expr expr ROT_THREE ROT_TWO store store store
        Nr   )r   r   r   r   r   p_assign  s    zPythonParser.p_assignc             C   s   dS )a  
        for_iter ::= GET_ITER FOR_ITER

        for_block ::= l_stmts_opt _come_froms JUMP_BACK

        forelsestmt ::= SETUP_LOOP expr for_iter store
                        for_block POP_BLOCK else_suite _come_froms

        forelselaststmt ::= SETUP_LOOP expr for_iter store
                for_block POP_BLOCK else_suitec _come_froms

        forelselaststmtl ::= SETUP_LOOP expr for_iter store
                for_block POP_BLOCK else_suitel _come_froms
        Nr   )r   r   r   r   r   	p_forstmt  s    zPythonParser.p_forstmtc             C   s   dS )a  
        stmt ::= import
        stmt ::= import_from
        stmt ::= import_from_star
        stmt ::= importmultiple

        importlist ::= importlist alias
        importlist ::= alias
        alias      ::= IMPORT_NAME store
        alias      ::= IMPORT_FROM store
        alias      ::= IMPORT_NAME attributes store

        import           ::= LOAD_CONST LOAD_CONST alias
        import_from_star ::= LOAD_CONST LOAD_CONST IMPORT_NAME IMPORT_STAR
        import_from      ::= LOAD_CONST LOAD_CONST IMPORT_NAME importlist POP_TOP
        importmultiple   ::= LOAD_CONST LOAD_CONST alias imports_cont

        imports_cont ::= import_cont+
        import_cont  ::= LOAD_CONST LOAD_CONST alias

        attributes   ::= LOAD_ATTR+
        Nr   )r   r   r   r   r   
p_import20  s    zPythonParser.p_import20c             C   s   dS )a   
        expr ::= list_comp

        list_iter ::= list_for
        list_iter ::= list_if
        list_iter ::= list_if_not
        list_iter ::= lc_body

        list_if ::= expr jmp_false list_iter
        list_if_not ::= expr jmp_true list_iter
        Nr   )r   r   r   r   r   p_list_comprehension  s    z!PythonParser.p_list_comprehensionc             C   s   dS )z
        comp_iter ::= comp_for
        comp_iter ::= comp_body
        comp_body ::= gen_comp_body
        gen_comp_body ::= expr YIELD_VALUE POP_TOP

        comp_iter ::= comp_if
        comp_if  ::= expr jmp_false comp_iter
        Nr   )r   r   r   r   r   
p_set_comp  s    zPythonParser.p_set_compc             C   s   dS )a	  
        expr ::= LOAD_CODE
        expr ::= LOAD_CONST
        expr ::= LOAD_DEREF
        expr ::= LOAD_FAST
        expr ::= LOAD_GLOBAL
        expr ::= LOAD_NAME
        expr ::= _mklambda
        expr ::= and
        expr ::= bin_op
        expr ::= call
        expr ::= compare
        expr ::= dict
        expr ::= list
        expr ::= or
        expr ::= subscript
        expr ::= subscript2
        expr ::= unary_op
        expr ::= unary_not
        expr ::= yield

        # bin_op (formerly "binary_expr") is the Python AST BinOp
        bin_op ::= expr expr binary_operator
        binary_operator   ::= BINARY_ADD
        binary_operator   ::= BINARY_MULTIPLY
        binary_operator   ::= BINARY_AND
        binary_operator   ::= BINARY_OR
        binary_operator   ::= BINARY_XOR
        binary_operator   ::= BINARY_SUBTRACT
        binary_operator   ::= BINARY_TRUE_DIVIDE
        binary_operator   ::= BINARY_FLOOR_DIVIDE
        binary_operator   ::= BINARY_MODULO
        binary_operator   ::= BINARY_LSHIFT
        binary_operator   ::= BINARY_RSHIFT
        binary_operator   ::= BINARY_POWER

        # unary_op (formerly "unary_expr") is the Python AST BinOp
        unary_op          ::= expr unary_operator
        unary_operator    ::= UNARY_POSITIVE
        unary_operator    ::= UNARY_NEGATIVE
        unary_operator    ::= UNARY_INVERT

        unary_not ::= expr UNARY_NOT

        subscript ::= expr expr BINARY_SUBSCR

        attribute ::= expr LOAD_ATTR
        get_iter  ::= expr GET_ITER

        yield ::= expr YIELD_VALUE

        _mklambda ::= mklambda

        expr ::= if_exp

        ret_expr ::= expr
        ret_expr ::= ret_and
        ret_expr ::= ret_or

        ret_expr_or_cond ::= ret_expr
        ret_expr_or_cond ::= if_exp_ret

        stmt ::= return_lambda

        return_lambda ::= ret_expr RETURN_VALUE_LAMBDA LAMBDA_MARKER
        return_lambda ::= ret_expr RETURN_VALUE_LAMBDA

        compare        ::= compare_chained
        compare        ::= compare_single
        compare_single ::= expr expr COMPARE_OP

        # A compare_chained is two comparisions like x <= y <= z
        compare_chained  ::= expr compare_chained1 ROT_TWO POP_TOP _come_froms
        compare_chained2 ::= expr COMPARE_OP JUMP_FORWARD

        # Non-null kvlist items are broken out in the indiviual grammars
        kvlist ::=

        # Positional arguments in make_function
        pos_arg ::= expr
        Nr   )r   r   r   r   r   p_expr  s    zPythonParser.p_exprc             C   s   dS )a  
        # Note. The below is right-recursive:
        designList ::= store store
        designList ::= store DUP_TOP designList

        ## Can we replace with left-recursive, and redo with:
        ##
        ##   designList  ::= designLists store store
        ##   designLists ::= designLists store DUP_TOP
        ##   designLists ::=
        ## Will need to redo semantic actiion

        store           ::= STORE_FAST
        store           ::= STORE_NAME
        store           ::= STORE_GLOBAL
        store           ::= STORE_DEREF
        store           ::= expr STORE_ATTR
        store           ::= store_subscript
        store_subscript ::= expr expr STORE_SUBSCR
        store           ::= unpack
        Nr   )r   r   r   r   r   p_storeZ  s    zPythonParser.p_store)r   r   r   r   r0   r6   r;   r@   rG   rX   r^   rb   rd   Z_PythonParser__ambiguityrl   rm   rn   ro   rp   rq   rr   rs   rt   ru   rv   rw   rx   ry   rz   __classcell__r   r   )r.   r   r   0   s4   8		#ZSr   c             C   s   | j || | j|}|S )N)Zcustomize_grammar_rulesparse)prU   r5   r1   r   r   r   r|   r  s    
r|   execFc             C   s  t | trt| } | dk rX| dk r| dkrZddljj}|dkrN|j|}q|j|}n2| dkrddljj	}|dkr|j
|}n
|j|}| dkrddljj}|dkr|j|}n
|j|}| d	krddljj}|dkr|j|}n
|j|}n| d
kr*ddljj}	|dkr|	j|}n
|	j|}n| dkrbddljj}
|dkrV|
j|}n
|
j|}nn| dkrddljj}|dkr|j|}n
|j|}n6| dkrTddl jj!}|dkr|j"|}n
|j#|}q| dkrddl$jj%}|dkr |j&|}n
|j'|}q| dkrHddl(jj)}|dkr:|j*|}n
|j+|}q| dkrddl,jj-}|dkrt|j.|}n
|j/|}n| dkrddl0jj1}|dkr|j2|}n
|j3|}n| dkrddl4jj5}|dkr|j6|}n
|j7|}nd| dkr(ddl8jj9}|dkr|j:|}n
|j;|}n,ddl<jj=}|dkrJ|j>|}n
|j?|}n.ddl@jjA}| dkrddlBjjC}|dkr|jD|}n
|jE|}n| dkrddlFjjG}|dkr|jH|}n
|jI|}n| dkrddlJjjK}|dkr|jL|}n
|jM|}nt| dkrLddlNjjO}|dkr>|jP|}n
|jQ|}n:| dkrddlRjjS}|dkrx|jT|}n
|jU|}n | dkrddlVjjW}|dkr|jX|}n
|jY|}n| dkrddlZjj[}|dkr|j\|}n
|j]|}n| dkr.ddl^jj_}|dkr"|j`|}n
|ja|}nX| dkrfddlbjjc}|dkrZ|jd|}n
|je|}n |dkr||jf|}n
|jg|}| |_h|S )a  Returns parser object for Python version 2 or 3, 3.2, 3.5on,
    etc., depending on the parameters passed.  *compile_mode* is either
    'exec', 'eval', or 'single'. See
    https://docs.python.org/3.6/library/functions.html#compile for an
    explanation of the different modes.
    g      @g@g      ?r   Nr~   g?g333333?g?gffffff?g      ?g?g @gffffff@g333333@g      @g@g@g@g	@gffffff
@g333333@g      @g@g@gffffff@)i
isinstancer#   r   Zuncompyle6.parsers.parse10parsersparse10ZPython10ParserZPython01ParserSingleZuncompyle6.parsers.parse11parse11ZPython11ParserZPython11ParserSingleZuncompyle6.parsers.parse12parse12ZPython12ParserZPython12ParserSingleZuncompyle6.parsers.parse13parse13ZPython13ParserZPython13ParserSingleZuncompyle6.parsers.parse14parse14ZPython14ParserZPython14ParserSingleZuncompyle6.parsers.parse15parse15ZPython15ParserZPython15ParserSingleZuncompyle6.parsers.parse16parse16ZPython16ParserZPython16ParserSingleZuncompyle6.parsers.parse21parse21ZPython21ParserZPython21ParserSingleZuncompyle6.parsers.parse22parse22ZPython22ParserZPython22ParserSingleZuncompyle6.parsers.parse23parse23ZPython23ParserZPython23ParserSingleZuncompyle6.parsers.parse24parse24ZPython24ParserZPython24ParserSingleZuncompyle6.parsers.parse25parse25ZPython25ParserZPython25ParserSingleZuncompyle6.parsers.parse26parse26ZPython26ParserZPython26ParserSingleZuncompyle6.parsers.parse27parse27ZPython27ParserZPython27ParserSingleZuncompyle6.parsers.parse2parse2ZPython2ParserZPython2ParserSingleZuncompyle6.parsers.parse3parse3Zuncompyle6.parsers.parse30parse30ZPython30ParserZPython30ParserSingleZuncompyle6.parsers.parse31parse31ZPython31ParserZPython31ParserSingleZuncompyle6.parsers.parse32parse32ZPython32ParserZPython32ParserSingleZuncompyle6.parsers.parse33parse33ZPython33ParserZPython33ParserSingleZuncompyle6.parsers.parse34parse34ZPython34ParserZPython34ParserSingleZuncompyle6.parsers.parse35parse35ZPython35ParserZPython35ParserSingleZuncompyle6.parsers.parse36parse36ZPython36ParserZPython36ParserSingleZuncompyle6.parsers.parse37parse37ZPython37ParserZPython37ParserSingleZuncompyle6.parsers.parse38parse38ZPython38ParserZPython38ParserSingleZPython3ParserZPython3ParserSingleversion)r   Zdebug_parserZcompile_modeis_pypyr   r}   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   get_python_parsery  s   














































r   c               @   s   e Zd Zdd ZdS )PythonParserSinglec             C   s   dS )z
        # single-mode compilation. Eval-mode interactive compilation
        # drops the last rule.

        call_stmt ::= expr PRINT_EXPR
        Nr   )r   r   r   r   r   p_call_stmt_singleG  s    z%PythonParserSingle.p_call_stmt_singleN)r   r   r   r   r   r   r   r   r   F  s   r   c             C   sP   t |stddlm} || |}|j|\}}	t|| t| |}
t|
||	S )a  
    Parse a code object to an abstract syntax tree representation.

    :param version:         The python version this code is from as a float, for
                            example 2.6, 2.7, 3.2, 3.3, 3.4, 3.5 etc.
    :param co:              The code object to parse.
    :param out:             File like object to write the output to.
    :param showasm:         Flag which determines whether the disassembled and
                            ingested code is written to sys.stdout or not.
    :param parser_debug:    dict containing debug flags for the spark parser.

    :return: Abstract syntax tree representation of the code object.
    r   )get_scanner)r   AssertionErrorZuncompyle6.scannerr   Zingestr   r   r|   )r   cooutshowasmZparser_debugr   r   scannerrU   r5   r}   r   r   r   python_parserP  s    


r   __main__c             C   s,   ddl m}m} t|| d|d}t| d S )Nr   )PYTHON_VERSIONIS_PYPYT)r   r   )
uncompyle6r   r   r   rS   )r   r   r   r1   r   r   r   
parse_testv  s    r   )__doc__
__future__r   sysZxdisr   r   Zspark_parserr   r   r   Zuncompyle6.showr   	Exceptionr   r   r   r|   r   r   stdoutr   r   r   __code__r   r   r   r   <module>   s.       F M