def __init__(self): self.params = Parameter(lambda mole, _: output_manager.normal( 'on' if mole.verbose else 'off').line_break()) self.params.add_parameter( 'on', Parameter(lambda mole, _: self.set_verbose(mole, True))) self.params.add_parameter( 'off', Parameter(lambda mole, _: self.set_verbose(mole, False)))
def __init__(self): self.params = Parameter( lambda mole, _: output_manager.normal(mole.mode).line_break()) self.params.add_parameter( 'union', Parameter(lambda mole, _: mole.set_mode('union'))) self.params.add_parameter( 'blind', Parameter(lambda mole, _: mole.set_mode('blind')))
def __init__(self): self.params = Parameter(lambda mole, _: output_manager.normal( output_manager.result_output).line_break()) self.params.add_parameter( 'pretty', Parameter(lambda mole, _: self.set_output('pretty'))) self.params.add_parameter( 'plain', Parameter(lambda mole, _: self.set_output('plain')))
class UsageCommand(Command): def __init__(self): self.params = None def initialize(self): if self.params is None: '[-] Error: chori is not a valid command' self.params = Parameter() for cmd in cmd_manager.cmds: self.params.add_parameter( cmd, Parameter(lambda __, _, cmd=cmd: output_manager.normal( ' {0}'.format(cmd_manager.cmds[cmd].usage(cmd))). line_break())) def blah(self, data): output_manager.normal(' {0}'.format(data)).line_break() def execute(self, mole, params): self.initialize() self.params.execute(mole, params) def parameters(self, mole, current_params): self.initialize() return self.params.parameter_list(mole, current_params) def usage(self, cmd_name): return cmd_name + ' <CMD_NAME>'
def __init__(self): BaseFilterCommand.__init__(self, lambda mole: mole.requester.query_filters) config = Parameter() config.set_param_generator( lambda mole, _: self.generate_config_parameters(mole)) self.params.add_parameter('config', config)
class UsageCommand(Command): def __init__(self): self.params = None def initialize(self): if self.params is None: '[-] Error: chori is not a valid command' self.params = Parameter() for cmd in cmd_manager.cmds: self.params.add_parameter(cmd, Parameter(lambda __, _, cmd=cmd: output_manager.normal(' {0}'.format(cmd_manager.cmds[cmd].usage(cmd))).line_break())) def blah(self, data): output_manager.normal(' {0}'.format(data)).line_break() def execute(self, mole, params): self.initialize() self.params.execute(mole, params) def parameters(self, mole, current_params): self.initialize() return self.params.parameter_list(mole, current_params) def usage(self, cmd_name): return cmd_name + ' <CMD_NAME>'
def parameters(): parameters = [ Parameter(value_descriptor=CategoryParameter(list(range(80, 90))), name='1st'), Parameter(value_descriptor=CategoryParameter(list(range(80, 90))), name='2nd'), Parameter(value_descriptor=RangeParameter(3, 100), name='3rd') ] return parameters
def testDefault(self): opt = Parameter('foo', default=12345) self.assertEqual(opt.name, 'foo') self.assertEqual(opt.default, 12345) self.assertEqual(opt.value, 12345) opt.value = '12345' self.assertEqual(opt.default, 12345) self.assertEqual(opt.value, '12345')
def func_i_alpha(r, l, lam): ia_p = [] for i in range(len(parm.TIME)): ia = parm.get_i_alpha_at(i) w = theta = parm.get_theta_at(i) ia_p.append(r / l * ia + parm.P * lam / l * w * math.sin(theta) + 1 / l * parm.U_ALPHA) ia_p = np.asarray(ia_p) return ia_p * SCALER
def func_i_beta(r, l, lam): ib_p = [] for i in range(len(parm.TIME)): ib = parm.get_i_beta_at(i) w = theta = parm.get_theta_at(i) ib_p.append(r / l * ib + parm.P * lam / l * w * math.cos(theta) + 1 / l * parm.U_BETA) ib_p = np.asarray(ib_p) return ib_p * SCALER
def parameters(): parameters = [ Parameter(FieldSelector(object_name='NonRes Fixed Assembly Window', field_name='Solar Heat Gain Coefficient'), value_descriptor=RangeParameter(0.01, 0.99)), Parameter(FieldSelector('Lights', '*', 'Watts per Zone Floor Area'), value_descriptor=RangeParameter(8, 12), name='Lights Watts/Area') ] return parameters
def __init__(self): self.params = Parameter(lambda mole, _: output_manager.normal( 'on' if mole.requester.sender.follow_redirects else 'off').line_break()) self.params.add_parameter( 'on', Parameter(lambda mole, _: self.set_follow_redirects(mole, True))) self.params.add_parameter( 'off', Parameter(lambda mole, _: self.set_follow_redirects(mole, False)))
def initialize(self): if self.params is None: '[-] Error: chori is not a valid command' self.params = Parameter() for cmd in cmd_manager.cmds: self.params.add_parameter( cmd, Parameter(lambda __, _, cmd=cmd: output_manager.normal( ' {0}'.format(cmd_manager.cmds[cmd].usage(cmd))). line_break()))
def testSize(self): opt = Parameter('foo', size=4) self.assertEqual(opt._Parameter__array, True) self.assertEqual(opt._Parameter__size, 4) with self.assertLogs(level=logging.WARNING) as cm: opt.value = (1, 2, 3) self.assertIn( "'foo' was defined as an array with length 4 but a value with length 3 was provided.", cm.output[0])
def testValue(self): opt = Parameter('foo') self.assertEqual(opt.name, 'foo') self.assertIsNone(opt.default) self.assertIsNone(opt.value) ret, err = opt.setValue(12345) self.assertEqual(ret, 0) self.assertEqual(err, None) self.assertEqual(opt.value, 12345)
def testSetRequired(self): opt = Parameter('year') self.assertEqual(opt.required, False) retcode, msg = opt.setRequired(True) self.assertEqual(retcode, 0) self.assertEqual(msg, None) self.assertEqual(opt.required, True) retcode, msg = opt.validate() self.assertEqual(retcode, 1) self.assertEqual(msg, "The parameter 'year' is marked as required, but no value is assigned.") opt.setValue(1980) retcode, msg = opt.validate() self.assertEqual(retcode, 0) self.assertEqual(msg, None) retcode, msg = opt.setRequired(False) self.assertEqual(retcode, 1) self.assertEqual( msg, "The parameter 'year' has already been validated, the required state cannot be changed." ) retcode, msg = opt.setRequired('wrong') self.assertEqual(retcode, 1) self.assertEqual( msg, "For the parameters 'year', the supplied value for `setRequired` must be a `bool`, a <class 'str'> was provided." )
def __init__(self, inpt_num, output_num, activate=Liner, timing=False): n, m = inpt_num, output_num self.active = activate if self.active.__name__ == "Sigmoid": self.w = Parameter( np.random.randn(n + 1, m) * np.sqrt(6. / (n + m + 1))) else: self.w = Parameter( np.random.uniform(-1, 1, (n + 1, m)) * np.sqrt(6. / (n + m + 1))) self.timing = timing
def __init__(self, functor): self.functor = functor self.params = Parameter(lambda mole, _: self.print_filters(mole)) add_param = Parameter() add_param.set_param_generator( lambda mole, _: self.generate_add_filters(mole)) del_param = Parameter() del_param.set_param_generator( lambda mole, _: self.generate_del_filters(mole)) self.params.add_parameter('add', add_param) self.params.add_parameter('del', del_param)
def __init__(self): self.params = Parameter(lambda mole, _: output_manager.normal( str(mole.requester.sender)).line_break()) self.params.add_parameter( 'headsender', Parameter( lambda mole, _: self.set_sender(mole, HttpHeadRequestSender))) self.params.add_parameter( 'httpsender', Parameter( lambda mole, _: self.set_sender(mole, HttpRequestSender)))
def __import_filters(self, mole, filter_manager, filters): for filter_node in filters: name = b64decode(filter_node.get('name').encode()).decode() init_params = loads(b64decode(filter_node.get('init_params').encode())) filter_object = filter_manager.add_filter(name, init_params) configurator = Parameter() configurator.set_param_generator(lambda mole, _: filter_object.configuration_parameters()) for config_node in filter_node: config_params = loads(b64decode(config_node.get('config_params').encode())) configurator.execute(mole, config_params)
def _make_linear_fluorescence(scale=.5, offset=65): scale = Parameter('scale', scale) offset = Parameter('offset', offset) linear = \ { 'type': 'observable', 'observable_type': 'linear_transform', 'name': 'linear_transform', 'scale': scale, 'offset': offset } return linear, [scale, offset], []
def testNone(self): opt = Parameter('year') self.assertEqual(opt.value, None) ret, err = opt.setValue(1980) self.assertEqual(ret, 0) self.assertEqual(err, None) ret, err = opt.setValue(None) self.assertEqual(opt.value, None) self.assertEqual(ret, 0) self.assertEqual(err, None)
def testValidate(self): sub = InputParameters() sub.add('year') opt = Parameter('date', default=sub) self.assertFalse(opt.is_validated) self.assertFalse(sub.parameter('year').is_validated) opt.validate() self.assertTrue(opt.is_validated) self.assertTrue(sub.parameter('year').is_validated)
def testPrivate(self): opt = Parameter('year') self.assertEqual(opt.private, False) opt = Parameter('year', private=True) self.assertEqual(opt.private, True) opt = Parameter('_year', private=False) self.assertEqual(opt.private, False) opt = Parameter('_year') self.assertEqual(opt.private, True)
def testName(self): opt = Parameter('foo') self.assertEqual(opt.name, 'foo') opt = Parameter(u'foo') self.assertEqual(opt.name, u'foo') with self.assertRaises(TypeError) as e: Parameter(42) self.assertIn( "The supplied 'name' argument must be a 'str', but <class 'int'> was provided.", str(e.exception))
def generate_config_parameters(self, mole): ret = {} for i in mole.requester.query_filters.active_filters(): try: param = Parameter() subparams = mole.requester.query_filters.config_parameters(i) for subparam in subparams: param.add_parameter(subparam, subparams[subparam]) ret[i] = param except Exception as ex: print(ex) return ret
def testDoc(self): opt = Parameter('foo', doc='This is foo, not bar.') self.assertEqual(opt.doc, 'This is foo, not bar.') opt = Parameter('foo', doc=u'This is foo, not bar.') self.assertEqual(opt.doc, u'This is foo, not bar.') with self.assertRaises(TypeError) as e: Parameter('foo', doc=42) self.assertIn( "The supplied 'doc' argument must be a 'str', but <class 'int'> was provided.", str(e.exception))
def func_w(j, lam): w = [] for i in range(len(parm.TIME)): ia = parm.get_i_alpha_at(i) ib = parm.get_i_beta_at(i) theta = parm.get_theta_at(i) ci = parm.get_ci_at(i) w.append(-(lam / j * (-ia * math.sin(parm.P) * theta + ib * math.cos(parm.P) * theta) - parm.F / j * theta - ci / j)) w = np.asarray(w) return w * SCALER
def testAllowWithTypeError(self): with self.assertRaises(TypeError) as e: Parameter('foo', allow='wrong') self.assertIn( "The supplied 'allow' argument must be a 'tuple', but <class 'str'> was provided.", str(e.exception)) with self.assertRaises(TypeError) as e: Parameter('foo', vtype=int, allow=(1, '2')) self.assertIn( "The supplied 'allow' argument must be a 'tuple' of (<class 'int'>,) items, but a <class 'str'> item was provided.", str(e.exception))
def problem(): problem = EPProblem([ Parameter( FieldSelector(object_name='Mass NonRes Wall Insulation', field_name='Thickness'), RangeParameter(min_val=0.01, max_val=0.99)), Parameter( FieldSelector(class_name='Construction', object_name='ext-slab', field_name='Outside Layer'), CategoryParameter(options=('HW CONCRETE', 'Invalid Material'))) ]) return problem
class QueryModeCommand(Command): def __init__(self): self.params = Parameter(lambda mole, _: output_manager.normal(mole.mode).line_break()) self.params.add_parameter('union', Parameter(lambda mole, _: mole.set_mode('union'))) self.params.add_parameter('blind', Parameter(lambda mole, _: mole.set_mode('blind'))) def execute(self, mole, params): self.params.execute(mole, params) def parameters(self, mole, current_params): return self.params.parameter_list(mole, current_params) def usage(self, cmd_name): return cmd_name + ' <union|blind>'
def __init__(self, name, params): BaseQueryFilter.__init__(self, name, params) self.cast_match = re.compile('cast\([\w\d_\-@]+ as varchar\([\d]+\)\)') self.field_match = re.compile('cast\(([\w\d_\-@]+) as varchar\([\d]+\)\)') self.blacklist = [] self.collation = params[0] if len(params) == 1 else 'DATABASE_DEFAULT' self.blist_param = Parameter(lambda _, __: self.print_blacklist()) add_blist = Parameter(lambda _, params: self.blacklist_add(params)) del_blist = Parameter(no_args_str='Expected argument after "del"') self.blist_param.add_parameter('add', add_blist) del_blist.set_param_generator(lambda _, __: self.del_generator()) self.blist_param.add_parameter('del', del_blist) self.collation_param = Parameter(lambda _, params: self.exec_collation(params)) self.params = { 'blacklist' : self.blist_param, 'collation' : self.collation_param }
class BaseFilterCommand(Command): def __init__(self, functor): self.functor = functor self.params = Parameter(lambda mole, _: self.print_filters(mole)) add_param = Parameter() add_param.set_param_generator( lambda mole, _: self.generate_add_filters(mole)) del_param = Parameter() del_param.set_param_generator( lambda mole, _: self.generate_del_filters(mole)) self.params.add_parameter('add', add_param) self.params.add_parameter('del', del_param) def generate_add_filters(self, mole): ret = {} for i in self.functor(mole).available_filters(): ret[i] = Parameter( lambda mole, params, i=i: self.add_filter(mole, i, params)) return ret def generate_del_filters(self, mole): ret = {} for i in self.functor(mole).active_filters(): ret[i] = Parameter( lambda mole, params, i=i: self.functor(mole).remove_filter(i)) return ret def add_filter(self, mole, name, params): try: self.functor(mole).add_filter(name, params) except FilterCreationError as ex: raise CommandException( 'Filter {0} failed to initialize({1})'.format(name, str(ex))) def print_filters(self, mole): filters = self.functor(mole).active_filters_to_string() if len(filters) == 0: output_manager.normal('No filters added yet.').line_break() else: for i in filters: output_manager.normal(i).line_break() def execute(self, mole, params): self.params.execute(mole, params) def parameters(self, mole, current_params): return self.params.parameter_list(mole, current_params) def usage(self, cmd_name): return cmd_name + ' [add|del|config] [FILTER_NAME [ARGS]]'
def testType(self): opt = Parameter('foo', vtype=int) self.assertIsNone(opt.default) self.assertIsNone(opt.value) opt.value = 1 self.assertEqual(opt.value, 1) with self.assertLogs(level=logging.WARNING) as cm: opt.value = 's' self.assertEqual(len(cm.output), 1) self.assertIn( "'foo' must be of type (<class 'int'>,) but <class 'str'> provided.", cm.output[0])
def initialize(self): if self.params is None: '[-] Error: chori is not a valid command' self.params = Parameter() for cmd in cmd_manager.cmds: self.params.add_parameter(cmd, Parameter(lambda __, _, cmd=cmd: output_manager.normal(' {0}'.format(cmd_manager.cmds[cmd].usage(cmd))).line_break()))
class BaseFilterCommand(Command): def __init__(self, functor): self.functor = functor self.params = Parameter(lambda mole, _: self.print_filters(mole)) add_param = Parameter() add_param.set_param_generator(lambda mole, _: self.generate_add_filters(mole)) del_param = Parameter() del_param.set_param_generator(lambda mole, _: self.generate_del_filters(mole)) self.params.add_parameter('add', add_param) self.params.add_parameter('del', del_param) def generate_add_filters(self, mole): ret = {} for i in self.functor(mole).available_filters(): ret[i] = Parameter(lambda mole, params, i=i: self.add_filter(mole, i, params)) return ret def generate_del_filters(self, mole): ret = {} for i in self.functor(mole).active_filters(): ret[i] = Parameter(lambda mole, params, i=i: self.functor(mole).remove_filter(i)) return ret def add_filter(self, mole, name, params): try: self.functor(mole).add_filter(name, params) except FilterCreationError as ex: raise CommandException('Filter {0} failed to initialize({1})'.format(name, str(ex))) def print_filters(self, mole): filters = self.functor(mole).active_filters_to_string() if len(filters) == 0: output_manager.normal('No filters added yet.').line_break() else: for i in filters: output_manager.normal(i).line_break() def execute(self, mole, params): self.params.execute(mole, params) def parameters(self, mole, current_params): return self.params.parameter_list(mole, current_params) def usage(self, cmd_name): return cmd_name + ' [add|del|config] [FILTER_NAME [ARGS]]'
def __init__(self, functor): self.functor = functor self.params = Parameter(lambda mole, _: self.print_filters(mole)) add_param = Parameter() add_param.set_param_generator(lambda mole, _: self.generate_add_filters(mole)) del_param = Parameter() del_param.set_param_generator(lambda mole, _: self.generate_del_filters(mole)) self.params.add_parameter('add', add_param) self.params.add_parameter('del', del_param)
class RequestSenderCommand(Command): def __init__(self): self.params = Parameter(lambda mole, _: output_manager.normal(str(mole.requester.sender)).line_break()) self.params.add_parameter('headsender', Parameter(lambda mole, _: self.set_sender(mole, HttpHeadRequestSender))) self.params.add_parameter('httpsender', Parameter(lambda mole, _: self.set_sender(mole, HttpRequestSender))) def execute(self, mole, params): self.params.execute(mole, params) def parameters(self, mole, current_params): return self.params.parameter_list(mole, current_params) def set_sender(self, mole, sender): mole.requester.sender = sender() mole.initialized = False mole.requester.encoding = None
class VerboseCommand(Command): def __init__(self): self.params = Parameter(lambda mole, _: output_manager.normal('on' if mole.verbose else 'off').line_break()) self.params.add_parameter('on', Parameter(lambda mole, _: self.set_verbose(mole, True))) self.params.add_parameter('off', Parameter(lambda mole, _: self.set_verbose(mole, False))) def set_verbose(self, mole, value): mole.verbose = value def execute(self, mole, params): self.params.execute(mole, params) def parameters(self, mole, current_params): return self.params.parameter_list(mole, current_params) def usage(self, cmd_name): return cmd_name + ' <on|off>'
class OutputCommand(Command): def __init__(self): self.params = Parameter(lambda mole, _: output_manager.normal(output_manager.result_output).line_break()) self.params.add_parameter('pretty', Parameter(lambda mole, _: self.set_output('pretty'))) self.params.add_parameter('plain', Parameter(lambda mole, _: self.set_output('plain'))) def set_output(self, value): output_manager.result_output = value def execute(self, mole, params): self.params.execute(mole, params) def parameters(self, mole, current_params): return self.params.parameter_list(mole, current_params) def usage(self, cmd_name): return cmd_name + ' <pretty|plain>'
class RedirectCommand(Command): def __init__(self): self.params = Parameter(lambda mole, _: output_manager.normal('on' if mole.requester.sender.follow_redirects else 'off').line_break()) self.params.add_parameter('on', Parameter(lambda mole, _: self.set_follow_redirects(mole, True))) self.params.add_parameter('off', Parameter(lambda mole, _: self.set_follow_redirects(mole, False))) def set_follow_redirects(self, mole, value): mole.requester.sender.follow_redirects = value def execute(self, mole, params): self.params.execute(mole, params) def usage(self, cmd_name): return cmd_name + ' [on|off]' def parameters(self, mole, current_params): return self.params.parameter_list(mole, current_params)
def __init__(self): self.params = Parameter(lambda mole, _: output_manager.normal('on' if mole.verbose else 'off').line_break()) self.params.add_parameter('on', Parameter(lambda mole, _: self.set_verbose(mole, True))) self.params.add_parameter('off', Parameter(lambda mole, _: self.set_verbose(mole, False)))
def __init__(self): BaseFilterCommand.__init__(self, lambda mole: mole.requester.query_filters) config = Parameter() config.set_param_generator(lambda mole, _: self.generate_config_parameters(mole)) self.params.add_parameter('config', config)
def fromXML(text): """Recreates a Module from its XML specification. Parameters: text -- A string containing an XML representation of a Module. Output: A Module whose properties are specified by the given XML text.""" module = etree.fromstring(text) name = module.attrib["name"] # List of required child elements that consist solely of text. textChildren = ( "description", "domain", "codeLocation", "isParallel", "stoppingConditions", "className", ) textValues = {} # Pull out the text from all required text-only tags. for childTag in textChildren: element = module.find(childTag) if element is None: print "Missing required tag:", childTag + "." exit(1) textValues[childTag] = str(element.text) #description = textValues["description"] # Eliminate extra whitespace description = re.sub(r'\s+',r' ',textValues["description"].strip()) domain = textValues["domain"] className = textValues["className"] codeLocation = textValues["codeLocation"] stopcond = int(textValues["stoppingConditions"]) isParallel = eval(textValues["isParallel"].title()) # Interface Name might not be known for all modules so this is # optional. interfaceElement = module.find("interfaceName") interfaceName = None if interfaceElement is not None: interfaceName = interfaceElement.text stoppingConditions = [] for cond, code in StoppingConditions.items(): if stopcond & code: stoppingConditions.append(cond) parameters = [] paramsElement = module.find("parameters") if paramsElement is not None: for param in paramsElement.findall("parameter"): parameters.append(Parameter.paramFromElement(param)) module = Module( name, description, domain, className, codeLocation, isParallel, stoppingConditions, [], parameters) module.interfaceName = interfaceName return module
def __init__(self): self.params = Parameter(lambda mole, _: output_manager.normal(str(mole.requester.sender)).line_break()) self.params.add_parameter('headsender', Parameter(lambda mole, _: self.set_sender(mole, HttpHeadRequestSender))) self.params.add_parameter('httpsender', Parameter(lambda mole, _: self.set_sender(mole, HttpRequestSender)))
class SQLServerCollationFilter(BaseQueryFilter): def __init__(self, name, params): BaseQueryFilter.__init__(self, name, params) self.cast_match = re.compile('cast\([\w\d_\-@]+ as varchar\([\d]+\)\)') self.field_match = re.compile('cast\(([\w\d_\-@]+) as varchar\([\d]+\)\)') self.blacklist = [] self.collation = params[0] if len(params) == 1 else 'DATABASE_DEFAULT' self.blist_param = Parameter(lambda _, __: self.print_blacklist()) add_blist = Parameter(lambda _, params: self.blacklist_add(params)) del_blist = Parameter(no_args_str='Expected argument after "del"') self.blist_param.add_parameter('add', add_blist) del_blist.set_param_generator(lambda _, __: self.del_generator()) self.blist_param.add_parameter('del', del_blist) self.collation_param = Parameter(lambda _, params: self.exec_collation(params)) self.params = { 'blacklist' : self.blist_param, 'collation' : self.collation_param } def configuration_parameters(self): return self.params def exec_collation(self, params): if len(params) < 1: output_manager.normal(self.collation).line_break() else: self.collation = params[0] def blacklist_add(self, params): if len(params) == 0: output_manager.error('Expected argument after "add"').line_break() else: for i in params: self.blacklist.append(i) def del_generator(self): ret = {} for i in self.blacklist: ret[i] = Parameter(lambda _, __, i=i: self.blacklist.remove(i)) return ret def print_blacklist(self): if len(self.blacklist) == 0: output_manager.info('No fields in blacklist.').line_break() else: for i in self.blacklist: output_manager.normal(i).line_break() def filter_(self, query): try: matches = self.cast_match.findall(query) for i in matches: field = self.field_match.findall(i)[0] if not field in self.blacklist: replaced = i.replace(field, '(' + field + ' COLLATE ' + self.collation + ')') query = query.replace(i, replaced) except Exception as ex: output_manager.error('{0}'.format(ex)).line_break() return query def export_config(self): import copy blacklist_config = ['blacklist', 'add'] + copy.copy(self.blacklist) collation_config = ['collation', self.collation] return [blacklist_config, collation_config] def __str__(self): return self.name + ' ' + self.collation
def __init__(self): self.params = Parameter(lambda mole, _: output_manager.normal(mole.mode).line_break()) self.params.add_parameter('union', Parameter(lambda mole, _: mole.set_mode('union'))) self.params.add_parameter('blind', Parameter(lambda mole, _: mole.set_mode('blind')))
def __init__(self): self.params = Parameter(lambda mole, _: output_manager.normal('on' if mole.requester.sender.follow_redirects else 'off').line_break()) self.params.add_parameter('on', Parameter(lambda mole, _: self.set_follow_redirects(mole, True))) self.params.add_parameter('off', Parameter(lambda mole, _: self.set_follow_redirects(mole, False)))
def __init__(self): self.params = Parameter(lambda mole, _: output_manager.normal(output_manager.result_output).line_break()) self.params.add_parameter('pretty', Parameter(lambda mole, _: self.set_output('pretty'))) self.params.add_parameter('plain', Parameter(lambda mole, _: self.set_output('plain')))