|
|
'''
Created on Feb 8, 2014
@author: Chris '''
import types
from parser_exceptions import ArgumentError from argparse import ArgumentParser from argparse import RawDescriptionHelpFormatter import code_prep
class MonkeyParser(object): '''
Builds a parser instance from the code extracted from the client module.
The instance is stored as a private variable in the class and all methods are delagted to it so that the user of the class can treat it just as a normal argparse instance. '''
def __init__(self, source_code): self._parser_instance = self._build_argparser_from_client_source(source_code) # Monkey patch parser's `error` method so that it raises an error # rather than silently exiting self._parser_instance.error = types.MethodType( self._ErrorAsString, self._parser_instance )
def _build_argparser_from_client_source(self, source_code): '''
runs the client code by evaling each line.
Example input Code: parser = ArgumentParser(description=program_license, formatter_class=RawDescriptionHelpFormatter) parser.add_argument("-r", "--recursive", dest="recurse", action="store_true", help="recurse into subfolders [default: %(default)s]") parser.add_argument("-v", "--verbose", dest="verbose", action="count", help="set verbosity level [default: %(default)s]")
Method extracts the instance name (e.g. parser) from the first line, and instantiates it in a local variable by evaling the rest of the lines. Each subsequent line updates the local variable in turn. '''
imports = filter(lambda x: 'gooey' not in x, code_prep.take_imports(source_code)) arg_code = code_prep.drop_imports(source_code) updated_source_code = code_prep.update_parser_varname('clients_parser', arg_code)
for _import in imports: exec(_import)
first_line = updated_source_code.pop(0) clients_parser, assignment = code_prep.split_line(first_line) clients_parser = eval(assignment)
for line in updated_source_code: eval(line) return clients_parser
def _format_source_with_new_varname(self, new_variable_name, source): '''
'injects' the client code with a known variable name so that it can be `eval`d and assigned to a variable in the local code.
For example, if the client code was: parser = ArgumentParser(descrip...) parser.add_argument("-r", "--re...) parser.add_argument("-v", "--ve...)
The variable "parser" would be overwritten with a custom name. e.g. my_parser = ArgumentParser(descrip...) my_parser.add_argument("-r", "--re...) '''
source_code = source[:]
first_line = source_code[0] client_parser_variable, statement = self._split_line(first_line)
client_parser_variable = client_parser_variable.strip()
for index, line in enumerate(source_code): source_code[index] = line.replace(client_parser_variable, new_variable_name) source_code.append('{0}.parse_args()'.format(new_variable_name)) return source_code
def _split_line(self, line): # Splits line at the first = sign, # joins everything after the first = # to account for additional = signs in # parameters components = line.split('=') var = components.pop(0) return var, '='.join(components)
def __getattr__(self, attr): '''
Auto-delegates everything to the ArgumentParser instance'''
return getattr(self._parser_instance, attr)
@staticmethod def _ErrorAsString(self, msg): '''
Monkey patch for parser.error Raises an error rather than printing and silently exiting. '''
raise ArgumentError(msg)
if __name__ == '__main__': pass
|