<s> import sys <EOL> import inspect <EOL> if sys . platform . startswith ( '<STR_LIT>' ) : <EOL> from java . lang import Class <EOL> from java . util import List , Map <EOL> from robotide . lib . robot . errors import DataError <EOL> from robotide . lib . robot . variables import is_dict_var , is_list_var , is_scalar_var <EOL> from . argumentspec import ArgumentSpec <EOL> class _ArgumentParser ( object ) : <EOL> def __init__ ( self , type = '<STR_LIT>' ) : <EOL> self . _type = type <EOL> def parse ( self , source , name = None ) : <EOL> return ArgumentSpec ( name , self . _type , * self . _get_arg_spec ( source ) ) <EOL> def _get_arg_spec ( self , source ) : <EOL> raise NotImplementedError <EOL> class PythonArgumentParser ( _ArgumentParser ) : <EOL> def _get_arg_spec ( self , handler ) : <EOL> args , varargs , kwargs , defaults = inspect . getargspec ( handler ) <EOL> if inspect . ismethod ( handler ) : <EOL> args = args [ <NUM_LIT:1> : ] <EOL> defaults = list ( defaults ) if defaults else [ ] <EOL> return args , defaults , varargs , kwargs <EOL> class JavaArgumentParser ( _ArgumentParser ) : <EOL> def _get_arg_spec ( self , signatures ) : <EOL> if not signatures : <EOL> return self . _no_signatures_arg_spec ( ) <EOL> elif len ( signatures ) == <NUM_LIT:1> : <EOL> return self . _single_signature_arg_spec ( signatures [ <NUM_LIT:0> ] ) <EOL> else : <EOL> return self . _multi_signature_arg_spec ( signatures ) <EOL> def _no_signatures_arg_spec ( self ) : <EOL> return self . _format_arg_spec ( ) <EOL> def _single_signature_arg_spec ( self , signature ) : <EOL> varargs , kwargs = self . _get_varargs_and_kwargs_support ( signature . args ) <EOL> positional = len ( signature . args ) - int ( varargs ) - int ( kwargs ) <EOL> return self . _format_arg_spec ( positional , varargs = varargs , kwargs = kwargs ) <EOL> def _get_varargs_and_kwargs_support ( self , args ) : <EOL> if not args : <EOL> return False , False <EOL> if self . _is_varargs_type ( args [ - <NUM_LIT:1> ] ) : <EOL> return True , False <EOL> if not self . _is_kwargs_type ( args [ - <NUM_LIT:1> ] ) : <EOL> return False , False <EOL> if len ( args ) > <NUM_LIT:1> and self . _is_varargs_type ( args [ - <NUM_LIT:2> ] ) : <EOL> return True , True <EOL> return False , True <EOL> def _is_varargs_type ( self , arg ) : <EOL> return arg is List or isinstance ( arg , Class ) and arg . isArray ( ) <EOL> def _is_kwargs_type ( self , arg ) : <EOL> return arg is Map <EOL> def _multi_signature_arg_spec ( self , signatures ) : <EOL> mina = maxa = len ( signatures [ <NUM_LIT:0> ] . args ) <EOL> for sig in signatures [ <NUM_LIT:1> : ] : <EOL> argc = len ( sig . args ) <EOL> mina = min ( argc , mina ) <EOL> maxa = max ( argc , maxa ) <EOL> return self . _format_arg_spec ( maxa , maxa - mina ) <EOL> def _format_arg_spec ( self , positional = <NUM_LIT:0> , defaults = <NUM_LIT:0> , varargs = False , kwargs = False ) : <EOL> positional = [ '<STR_LIT>' % ( i + <NUM_LIT:1> ) for i in range ( positional ) ] <EOL> defaults = [ '<STR_LIT>' ] * defaults <EOL> varargs = '<STR_LIT>' if varargs else None <EOL> kwargs = '<STR_LIT>' if kwargs else None <EOL> supports_named = False <EOL> return positional , defaults , varargs , kwargs , supports_named <EOL> class _ArgumentSpecParser ( _ArgumentParser ) : <EOL> def parse ( self , argspec , name = None ) : <EOL> result = ArgumentSpec ( name , self . _type ) <EOL> for arg in argspec : <EOL> if result . kwargs : <EOL> self . _raise_invalid_spec ( '<STR_LIT>' ) <EOL> if self . _is_kwargs ( arg ) : <EOL> self . _add_kwargs ( arg , result ) <EOL> continue <EOL> if result . varargs : <EOL> self . _raise_invalid_spec ( '<STR_LIT>' ) <EOL> if self . _is_varargs ( arg ) : <EOL> self . _add_varargs ( arg , result ) <EOL> continue <EOL> if '<STR_LIT:=>' in arg : <EOL> self . _add_arg_with_default ( arg , result ) <EOL> continue <EOL> if result . defaults : <EOL> self . _raise_invalid_spec ( '<STR_LIT>' <EOL> '<STR_LIT>' ) <EOL> self . _add_arg ( arg , result ) <EOL> return result <EOL> def _raise_invalid_spec ( self , error ) : <EOL> raise DataError ( '<STR_LIT>' % error ) <EOL> def _is_kwargs ( self , arg ) : <EOL> raise NotImplementedError <EOL> def _add_kwargs ( self , kwargs , result ) : <EOL> result . kwargs = self . _format_kwargs ( kwargs ) <EOL> def _format_kwargs ( self , kwargs ) : <EOL> raise NotImplementedError <EOL> def _is_varargs ( self , arg ) : <EOL> raise NotImplementedError <EOL> def _add_varargs ( self , varargs , result ) : <EOL> result . varargs = self . _format_varargs ( varargs ) <EOL> def _format_varargs ( self , varargs ) : <EOL> raise NotImplementedError <EOL> def _add_arg_with_default ( self , arg , result ) : <EOL> arg , default = arg . split ( '<STR_LIT:=>' , <NUM_LIT:1> ) <EOL> self . _add_arg ( arg , result ) <EOL> result . defaults . append ( default ) <EOL> def _add_arg ( self , arg , result ) : <EOL> result . positional . append ( self . _format_arg ( arg ) ) <EOL> def _format_arg ( self , arg ) : <EOL> return arg <EOL> class DynamicArgumentParser ( _ArgumentSpecParser ) : <EOL> def _is_kwargs ( self , arg ) : <EOL> return arg . startswith ( '<STR_LIT>' ) <EOL> def _format_kwargs ( self , kwargs ) : <EOL> return kwargs [ <NUM_LIT:2> : ] <EOL> def _is_varargs ( self , arg ) : <EOL> return arg . startswith ( '<STR_LIT:*>' ) and not self . _is_kwargs ( arg ) <EOL> def _format_varargs ( self , varargs ) : <EOL> return varargs [ <NUM_LIT:1> : ] <EOL> class UserKeywordArgumentParser ( _ArgumentSpecParser ) : <EOL> def _is_kwargs ( self , arg ) : <EOL> return is_dict_var ( arg ) <EOL> def _is_varargs ( self , arg ) : <EOL> return is_list_var ( arg ) <EOL> def _format_kwargs ( self , kwargs ) : <EOL> return kwargs [ <NUM_LIT:2> : - <NUM_LIT:1> ] <EOL> def _format_varargs ( self , varargs ) : <EOL> return varargs [ <NUM_LIT:2> : - <NUM_LIT:1> ] <EOL> def _format_arg ( self , arg ) : <EOL> if not is_scalar_var ( arg ) : <EOL> self . _raise_invalid_spec ( "<STR_LIT>" % arg ) <EOL> return arg [ <NUM_LIT:2> : - <NUM_LIT:1> ] </s>
