def _set_param_config_depend(target_arg: argument.Argument, value: float, d_func: Callable): if d_func is None: print("Depending function (d_func) is required.") return target_arg.set_status(argument.ArgStatus.DEPEND) target_arg.set_depend_function(d_func) if value is not None: print("Value is ignored.")
def from_file(self, path): if os.path.isfile(path+".sqlite"): kb = Argument.from_database(path+".sqlite") # Bit of bad factoring. print("Labelled DB detected. Using that.") else: kb = Argument.from_file(path) print("Loaded into DB, Labelling.", time.process_time()) Labelling.grounded(kb) return Game(kb)
def from_tokens(cls, pred_token, neg, subj_token, obj_token, pobj_token_list): pred = Predicate.from_token(pred_token, neg=neg) subj = Argument.from_token(subj_token) \ if subj_token is not None else None obj = Argument.from_token(obj_token) if obj_token is not None else None pobj_list = [(prep, Argument.from_token(pobj)) for prep, pobj in pobj_token_list] return cls(pred, subj, obj, pobj_list)
def test_arg_modifier(args: Argument, user_args): args.CUDA_VISIBLE_DEVICES = -1 args.OMP_NUM_THREADS = 1 args.num_agent = user_args.num_agent args.seed = user_args.seed args.model_type = user_args.model_type args.beta = user_args.beta if user_args.num_agent == 4: args.bsize = 20 args.num_history = 5 args.num_rollout = 15 return args
def generate_arguments(num_practical, num_epistemic): """ Generate the Argument pool set. """ args = set() # Add practical arguments (prefix argument text with `P') for idx_arg in range(num_practical): text = "P" + str(idx_arg) args.add(Argument(PEtype='practical', text=text)) # Add epistemic arguments (prefix argument text with `E') for idx_arg in range(num_epistemic): text = "E" + str(idx_arg) args.add(Argument(PEtype='epistemic', text=text)) return args
def get_arguments(argumentList, variableDict): # TODO: Try/Catch for this section argumentArray = [] XMLNamespace = re.match('\{.*\}', argumentList.tag).group(0) for argumentNode in argumentList.findall(XMLNamespace + 'argument'): name = argumentNode.find(XMLNamespace + 'name') if name is not None: name = name.text direction = argumentNode.find(XMLNamespace + 'direction') if direction is not None: direction = direction.text relatedStateVariable = argumentNode.find(XMLNamespace + 'relatedStateVariable') if relatedStateVariable is not None: relatedStateVariable = relatedStateVariable.text # If we already know what that variable is, we can grab the datatype and the default value! if relatedStateVariable in variableDict: relatedStateVariable = variableDict[relatedStateVariable] else: # Otherwise put them both down as unknown relatedStateVariable = Variable(relatedStateVariable, "?", "?") argumentArray.append(Argument(name, direction, relatedStateVariable)) return argumentArray
def from_tokens(cls, pred_token, subj_token, obj_token, pobj_token_list, neg=False, prt=''): pred = Predicate.from_token(pred_token, neg=neg, prt=prt) subj = None if subj_token is not None: subj = Argument.from_token(subj_token) obj = None if obj_token is not None: obj = Argument.from_token(obj_token) pobj_list = [(prep, Argument.from_token(pobj_token)) for prep, pobj_token in pobj_token_list] return cls(pred, subj, obj, pobj_list)
def make_single_argument(arg_tuple, toprule): """given a set of possible ways to create an argument, creates an argument from one of them. Note that there is a modification over the standard def - a rule is only allowed to be used once in an argument.""" subargs = set([i for i in arg_tuple]) for i in arg_tuple: subargs = subargs.union(i.subarguments) if len( set(filter(lambda x: x.toprule == toprule, subargs)) ) > 0: #remove this bit to allow a rule to be used more than once in an argument. return set() return Argument(toprule, subargs)
def make_relations(self, i, arguments): reason_i = arguments[i].reason tok_i = arguments[i].reason relations = [] if reason_i is not None: for r in reason_i: rel = ArgumentRelation() rel.add_argument(arguments[i]) rel.set_connection() if REASON_ID_PATTERN.match(r): reasons = r.split("_") new_argument = Argument() new_argument.tokens = [] new_argument.text = "" new_argument.posTagging = [] for c in reasons: new_argument.text = " " + propositions[int(c)].tokens new_argument.tokens.extend(propositions[int(c)].tokens) new_argument.posTagging.extend(propositions[int(c)].posTagging) rel.add_argument(new_argument) elif NUM_PATTERN.match(r): rel.add_argument(propositions[int(r)]) relations.append(rel) else: for p in propositions: if p != i: rel = ArgumentRelation() rel.add_argument(propositions[i]) rel.add_argument(propostions[int(p)]) rel.unset_connection() relations.append(rel) return relations
def str2predicate(string_repr): lpar_index = string_repr.index('(') rpar_index = string_repr.index(')') vars_ = string_repr[lpar_index + 1:rpar_index].split(',') variables = [] for var in vars_: if var[0] == '"' and var[-1] == '"': variables.append(Argument(var[1:-1], True, True, None)) else: variables.append(Argument(var, False, True, None)) if string_repr[0] == '~': name = string_repr[1:lpar_index] isneg = True else: name = string_repr[:lpar_index] isneg = False return PredicateTemplate(name, variables, isneg, True)
def from_text(cls, text): parts = [p for p in re.split(' :(?:SUBJ|OBJ|POBJ): ', text)] if len(parts) < 3: raise ParseEventError( 'expected at least 3 parts, separated by ::, ' 'got {}: {}'.format(len(parts), text)) pred = Predicate.from_text(parts[0]) subj = None if parts[1] != 'NONE': subj = Argument.from_text(parts[1]) obj = None if parts[2] != 'NONE': obj = Argument.from_text(parts[2]) pobj_list = [] if len(parts) > 3: for part in parts[3:]: prep, pobj = part.split(' : ') if prep != '': pobj_list.append((prep, Argument.from_text(pobj))) return cls(pred, subj, obj, pobj_list)
def generate_arguments(p, ruleset, seen): """Given a ruleset and a proposition, uses backwards chaining to create all arguments for the proposition.""" arguments = set() if p in seen: return set() valid_rules = filter(lambda x: x.con == p, ruleset) for r in valid_rules: added = False args_for_pre = {} for pre in r.pre: args_for_pre[pre] = generate_arguments(pre, ruleset, seen.union([p])) prod = itertools.product(*[a for (_, a) in args_for_pre.items()]) for sa in prod: added = True a = Argument(r, set(sa)) for sub in sa: a.subarguments = a.subarguments.union(sub.subarguments) arguments.add(a) return arguments
def from_text(cls, text): # TODO: change OBJ to DOBJ to avoid confusion parts = [p for p in re.split(' :(?:SUBJ|OBJ|POBJ): ', text)] assert len(parts) >= 3, \ 'expected at least 3 parts, separated by :(SUBJ|OBJ|POBJ):, ' \ 'found {}'.format(len(parts)) pred = Predicate.from_text(parts[0]) subj = None if parts[1] != 'NONE': subj = Argument.from_text(parts[1]) obj = None if parts[2] != 'NONE': obj = Argument.from_text(parts[2]) pobj_list = [] if len(parts) > 3: for part in parts[3:]: prep, pobj = part.split(' : ') if prep != '': pobj_list.append((prep, Argument.from_text(pobj))) return cls(pred, subj, obj, pobj_list)
def up_complete_update(self): counter = 0 while True: counter += 1 legally_IN = set([a for a in self.UNDEC if self.isLegallyIN(a)]) Argument.set_all_labels(legally_IN, "In", counter) legally_OUT = set([a for a in self.UNDEC if self.isLegallyOUT(a)]) Argument.set_all_labels(legally_OUT, "Out", counter) if not legally_IN and not legally_OUT: for a in self.UNDEC: if a not in self.steps: self.steps[a] = counter return self self.IN |= legally_IN self.OUT |= legally_OUT self.UNDEC -= legally_IN self.UNDEC -= legally_OUT # assign the number of the step to the updated arguments this_step = legally_IN | legally_OUT for a in this_step: if a not in self.steps: self.steps[a] = counter
def command_builder(input_args): (ip, transport_layer_protocol, time_per_test, reversed_transmission_direction, store_in_db, buffer_length, window_size, maximum_segment_size) = input_args if reversed_transmission_direction: transmission_direction_arg = reversed_transmission_direction_flag else: transmission_direction_arg = '' command_prefix = [command, device_type, ip, time_per_test_flag, str(time_per_test), transmission_direction_arg] if transport_layer_protocol == 'udp': opt_args = [Argument(name='buffer_length', flag=udp_args[0], min_val=udp_args_domains[0][0], max_val=udp_args_domains[0][1], get_next_value_method='multiply', default_val=udp_args_default_values[0])] command_prefix+=udp_args_extra elif transport_layer_protocol == 'tcp': opt_args = [] if window_size: opt_args.append(Argument(name='window_size', flag=tcp_args[1], min_val=tcp_args_domains[1][0], max_val=tcp_args_domains[1][1], get_next_value_method='multiply')) if buffer_length: opt_args.append(Argument(name='buffer_length', flag=tcp_args[0], min_val=tcp_args_domains[0][0], max_val=tcp_args_domains[0][1], get_next_value_method='multiply', default_val=tcp_args_default_values[0])) if maximum_segment_size: opt_args.append(Argument(name='maximum_segment_size', flag=tcp_args[2], min_val=tcp_args_domains[2][0], max_val=tcp_args_domains[2][1], get_next_value_method='add', default_val=tcp_args_default_values[2])) command_prefix += tcp_args_extra if len(opt_args) == 0: print('Impossible to optimize throughput without any parameters.') exit(-1) args = (time_per_test, transport_layer_protocol, reversed_transmission_direction, store_in_db) return command_prefix, opt_args, args
def process_argument(self, arg): """ Given a argument as a dictionary type, it appends the pairs of reasons to the list of data_list. Each pair is a Data object. """ # iterating through propositions arg_dict = {} for p in arg: id_p = p["id"] text_p = p["text"] reason_p = p["reasons"] arg_dict[id_p] = Argument(text_p, reason_p) arg_dict.process() return arg_dict
def eval_models(args: Argument): args.mode = 'test' dc, lc, tc, model_dir = get_config_list(args) modes = ['test'] dataloader = { 'test': get_trajectory_data_loader(dc, test=True, batch_size=args.bsize, num_workers=args.num_workers, shuffle=True) } run_every = {'test': 1} gn_wrapper = fetch_model_iterator(lc, args) trainer = train.Trainer(gn_wrapper, modes, dataloader, run_every, tc) output = trainer.eval(dataloader['test']) return trainer.num_iter, output
def next_move(self): "Bot plays the move" if not self.game.last_argument: proposed_arg = Argument.get_random() return "has_to_be", proposed_arg # Proponents first move possible_args = self.game.last_argument.minus() args = [a for a in possible_args if (a not in self.game.complete_arguments and a not in self.game.arguments and a.label == "In")] if not args: args = [a for a in possible_args if (a not in self.game.complete_arguments and a not in self.game.arguments)] if not args: # I hate python return None, None args.sort(key=lambda arg: arg.step if arg.step else 1000) proposed_arg = args[0] return "has_to_be", proposed_arg
def test(model, dataset, path = None, beam = False, beam_size = 4, k = 6, test_mode = True) : if path != None : model.load_state_dict(torch.load(path)) args = Argument() model.eval() loader = dataset.test_iter preds = [] targets = [] loss = 0 example_num = 0 with torch.no_grad() : for idx, batch in enumerate(tqdm(loader, position = 0)) : if idx == 0 : continue if beam : beam = model.beam_generate(batch, beam_size, k) beam.sort() gen = beam.finished_nodes[0].words out = torch.nn.functional.one_hot(torch.Tensor(gen).long(), num_classes = args.output_vocab_size).unsqueeze(0) out = out[1:, :].unsqueeze(0) #(1, seq_len, num_classes) else : out = model(batch) out = out [:, 1: , :] gen = out[0].argmax(dim = 1) target = batch.target[:, 1:] sen = "GEN\n" + create_sentence(dataset, gen) + "\n" tgt = "GOLD\n" + create_sentence(dataset, target[0]) + "\n" preds.append(sen) targets.append(tgt) if idx % 100 == 1 : print(sen) print(tgt) if test_mode : print(sen) print(tgt) if idx == 10 : break result = {"GOLD" : targets, "GEN" : preds} if path == None : path = "./outputs/test_result_" + "beam_size-" + str(beam_size) + "_k-" + str(k) + ".tsv" if beam else "./outputs/test_result.tsv" pd.DataFrame(result, columns = ["GOLD", "GEN"]).to_csv(path, sep = "\t", mode = "w") return preds, targets
def train_model(args: Argument): args.mode = 'train' dc, lc, tc, _ = get_config_list(args) gn_wrapper = fetch_model_iterator(lc, args) modes = ['train', 'test'] dataloader = { m: get_trajectory_data_loader(dc, test=m == 'train', batch_size=args.bsize, num_workers=args.num_workers, shuffle=True) for m in modes } run_every = {'train': 1, 'test': args.test_every} trainer = train.Trainer(gn_wrapper, modes, dataloader, run_every, tc) train_winding = False train_trajectory = True trainer.train(train_winding, train_trajectory) trainer.save(train_winding, train_trajectory)
def merge( path, special, verbose, silent, name_template, title, video_codec, audio_codec, save_path, additional_args, only_compile, parse_name, ): container_list, attach_list = __scan(path, special, verbose, silent) command_list = [] for i, container in enumerate(container_list, start=1): meta_container = MetaContainer(container, attach_list, name_template, title, parse_name=parse_name) command = Argument.compile_mkv(meta_container, video_codec=video_codec, audio_codec=audio_codec, additional_args=additional_args, save_path=save_path) command_list.append(command) if not silent: click.echo("Container â„–{} - {}".format(i, meta_container.name)) if only_compile: click.echo("Command: ") click.echo(command) if verbose: click.echo("Streams: ") for stream in meta_container.stream_list: print(stream) if not only_compile: run(command)
def make_relations(self, i, arguments): reason_i = arguments[i].reason tok_i = arguments[i].reason relations = [] if reason_i is not None: for r in reason_i: rel = ArgumentRelation() rel.add_argument(arguments[i]) rel.set_connection() if REASON_ID_PATTERN.match(r): reasons = r.split("_") new_argument = Argument() new_argument.tokens = [] new_argument.text = "" new_argument.posTagging = [] for c in reasons: new_argument.text = " " + propositions[int(c)].tokens new_argument.tokens.extend(propositions[int(c)].tokens) new_argument.posTagging.extend( propositions[int(c)].posTagging) rel.add_argument(new_argument) elif NUM_PATTERN.match(r): rel.add_argument(propositions[int(r)]) relations.append(rel) else: for p in propositions: if p != i: rel = ArgumentRelation() rel.add_argument(propositions[i]) rel.add_argument(propostions[int(p)]) rel.unset_connection() relations.append(rel) return relations
from data import DataHelper from model import AutoRec from argument import Argument import tensorflow as tf import math import time print("begin!") args = Argument() tf.set_random_seed(args.random_seed) data_name = 'ml-1m' data_path = "./%s" % data_name datahelper = DataHelper() datahelper.read(data_path) train_R, train_mask_R, test_R, test_mask_R = datahelper.split(args.ratio) num_users = datahelper.get_num_user() num_items = datahelper.get_num_item() for _ in range(args.repeat_number): tf.reset_default_graph() with tf.Session() as sess: autoRec = AutoRec(sess, args, num_users, num_items, train_R, train_mask_R, test_R, test_mask_R) autoRec.run()
def from_af(cls, arguments, attack_relations): kb = Argument.from_af(arguments, attack_relations) Labelling.grounded(kb) return Game(kb)
def addArg(self, arg, question=None): self.args.append(arg) if question: self.questions[question] = self.questions.get( question, []) + [Argument(arg)]
def concede(self, argument_name): argument = Argument.find(argument_name) return self.game.concede(argument)
def retract(self, argument_name): argument = Argument.find(argument_name) return self.game.retract(argument)
def _process_parsed_arg(self, articles, which='test'): arg_feat_name = FILE_PATH + '/../tmp/arg.feat' arg_feat_file = codecs.open(arg_feat_name, 'w', 'utf-8') arg_checked = [] argParser = Argument() for art in articles: for rel in art.exp_relations: arg_checked.append(argParser.print_features(rel, which, arg_feat_file)) arg_feat_file.close() arg_pred_name = FILE_PATH + '/../tmp/arg.pred' Corpus.test_with_opennlp(arg_feat_name, argParser.model_file, arg_pred_name) arg_res = [l.strip().split()[-1] for l in codecs.open(arg_pred_name, 'r', 'utf-8')] tmp_feat_name = FILE_PATH+'/../tmp/arg.prev.feat' tmp_file = codecs.open(tmp_feat_name, 'w', 'utf-8') for art in articles: for rel in art.exp_relations: conn_sid = rel.conn_leaves[0].goto_tree().sent_id if conn_sid > 0: prev_tree = rel.article.sentences[conn_sid-1].tree if not prev_tree.is_null(): prev_root = prev_tree.root argParser.print_features(rel, which, tmp_file, prev_root) tmp_file.close() tmp_pred_name = FILE_PATH + '/../tmp/arg.prev.pred' Corpus.test_with_opennlp(tmp_feat_name, argParser.model_file, tmp_pred_name) arg_prev_res = [l.strip().split()[-1] for l in codecs.open(tmp_pred_name, 'r', 'utf-8')] rid = 0 s = 0 index = 0 for art in articles: for rel in art.exp_relations: args = arg_checked[rid] labels = arg_res[s:s+len(args)] rid += 1 s += len(args) merge_result = argParser.merge(rel, args, labels) rel.arg1_leaves = merge_result['arg1'] if 'arg1' in merge_result else [] conn_sid = args[0].goto_tree().sent_id # if current sentence couldn't resovle any arg1 leaves, we # consider previous root if len(rel.arg1_leaves) == 0 and conn_sid > 0 and arg_prev_res[index] == 'arg1': rel.arg1_leaves = rel.article.sentences[conn_sid-1].leaves if conn_sid > 0: index += 1 rel.arg1_leaves = self.remove_leading_tailing_punc(rel.arg1_leaves) rel.arg1_addr = [n.leaf_id for n in rel.arg1_leaves] rel.arg1_sid = rel.arg1_leaves[-1].goto_tree().sent_id if len(rel.arg1_leaves) > 0 else -1 rel.arg1_text = ' '.join(n.value for n in rel.arg1_leaves) rel.arg2_leaves = merge_result['arg2'] if 'arg2' in merge_result else [] rel.arg2_leaves = self.remove_leading_tailing_punc(rel.arg2_leaves) rel.arg2_addr = [n.leaf_id for n in rel.arg2_leaves] rel.arg2_sid = rel.arg2_leaves[0].goto_tree().sent_id if len(rel.arg2_leaves) > 0 else -1 rel.arg2_text = ' '.join(n.value for n in rel.arg2_leaves) assert len(arg_prev_res) == index, 'arg prev size not match' assert len(arg_res) == s, 'arg candidate size not match'
def parse_yaml_rules(self, nodelist, base_class=None): abstract_nodes = [] nodes = [] for node in nodelist: # name of the ast class and it's properties as dictionary class_name, properties = next(iter(node.items())) # no need to process empty nodes if properties is None: continue args = Argument() args.url = properties.get('url', None) args.class_name = class_name args.brief = properties.get('brief', '') args.description = properties.get('description', '') # yaml file has abstract classes and their subclasses with children as a property if 'children' in properties: # recursively parse all sub-classes of current abstract class child_abstract_nodes, child_nodes = self.parse_yaml_rules( properties['children'], class_name) # append all parsed subclasses abstract_nodes.extend(child_abstract_nodes) nodes.extend(child_nodes) # classes like Ast which don't have base class # are not added (we print Ast class separately) if base_class is not None: args.base_class = base_class node = Node(args) abstract_nodes.append(node) nodes.insert(0, node) if self.debug: print('Abstract {}'.format(node)) else: args.base_class = base_class if base_class else 'Ast' # check if we need token for the node # todo : we will have token for every node args.has_token = LanguageParser.is_token(class_name) # name of the node while printing back to NMODL args.nmodl_name = properties[ 'nmodl'] if 'nmodl' in properties else None # create tree node and add to the list node = Node(args) nodes.append(node) if self.debug: print('Class {}'.format(node)) # now process all children specification if 'members' in properties: for child in properties['members']: args = self.parse_child_rule(child) node.add_child(args) # update the abstract nodes for absnode in abstract_nodes: for node in nodes: if absnode.class_name == node.class_name: node.is_abstract = True break return abstract_nodes, nodes
except Exception as err: Verbose.print_ln("Something went bad \nError: ", err) if first_run or db_updated: try: db_df.to_pickle('result.pkl') except Exception as err: Verbose.print_ln("Was not able to create new pkl file, Error:", err) self.create_or_update_view() Verbose.print_ln("update the view and the pkl") else: Verbose.print_ln('No changes, database table status remained same.') """ Documentation: create_or_update_view Description: a method used to create new view "vw_AllSurveyDataPython" and store all survey data we got from procedure object. """ def create_or_update_view(self): procedure = Procedure(self.db) final_query = ' CREATE OR ALTER VIEW vw_AllSurveyData AS ' + procedure.get_all_survey_data() self.db.create(final_query) Verbose.print_ln("View updated.") if __name__ == '__main__': args = Argument.get() Verbose.show_messages(args.verbose) starter = Starter() starter.main()
def has_to_be(self, argument_name): argument = Argument.find(argument_name) return self.game.has_to_be(argument)
import json from argument import Argument from jenkinsutils import Job from database import DBSession, ColumnNotFoundException from converters import Converter from retry import retry configuration = dict(json.loads(open('configuration.json').read())) arguments_dict = dict(json.loads(open('arguments.json').read())) argument_objects = [] for argument_name, argument_information in arguments_dict.items(): argument_objects.append( Argument(name=argument_name, **argument_information)) parsed_args, unparsed_remainder_args = Argument.ARGUMENTS.parse_known_args() remainder_args = Argument.parse_unknown_args( remainder_list=unparsed_remainder_args) db = DBSession(user=configuration['databaseUser'], password=configuration['databasePass'], host=configuration['hostName'], port=configuration['port'], database=configuration['databaseName']) if parsed_args.create_table_only: job = Job(configuration['jobName']) db.execute_query(query=job.create_table_query())
from argument import Argument if __name__ == '__main__': import sys if len(sys.argv) != 2: sys.exit(1) with open(sys.argv[1]) as f: print Argument(f.read()).compile()
trees[(env, ceco)] = lambda p: 'Environment' trees[(time, ceco)] = trees[(time, fit)] = lambda p: 'Time' trees[(ceco, com)] = trees[(env, com)] = trees[(time, com)] = lambda p: 'Comfort' trees[(peco, ceco)] = lambda p: 'Personal Economy' trees[(env, time)] = lambda p: 'Environment' if p.A <= 3.75 else 'Time' trees[( peco, saf )] = lambda p: 'Personal Economy' if p.O <= 4.25 and P.A > 4.75 else 'Safety' trees[(saf, hea)] = lambda p: 'Safety' if p.C <= 4.75 else 'Health' trees[( com, fit )] = lambda p: 'Fitness' if p.N > 3.75 and p.O > 4.25 and p.O <= 6.25 and p.C <= 6.25 else 'Comfort' trees[(peco, com)] = pecocom init = Argument('init', 'Why don\'t you cycle from home to work?', 'init') g2 = Argument( 'g2', 'We won\'t be able to persuade you to cycle to work. However, do you have any objection to the city investing in initiatives to increase cycling?', 'g2') arg1 = Argument('arg1', 'people cycle 8 miles on average to go to work', fit, time) arg2 = Argument('arg2', 'pollution is everyone\'s problem', env) arg3 = Argument('arg3', 'I live further than 8 miles away', time) arg4 = Argument('arg4', 'I am not fit enough', fit) # arg4 = Argument('arg4', 'I am not fit enough because of my weight', fit) arg5 = Argument( 'arg5', 'many companies now have secure bike parking for the employees not to waste time on looking for one', time) # arg6 = Argument('arg6', 'My home is too small to store a bike', peco)
# test # unit test class Agent(object): def __init__(self, name): self.name = name def open(self, arg): print("open") def close(self, arg): print("close") def __repr__(self): return self.name master = Agent("a master") slave = Agent("a slave") # create arg arg = Argument() arg.insert("sharability", "inner_sharable") # create action item ai = ActionItem() ai.set_owner(slave) ai.set_action("open") ai.do() # create a chain-action chain_action0 = ChainAction(master, "Monday", ai, arg) print(chain_action0)
def parse_child_rule(self, child): """parse child specification and return argument as properties Child specification has additional option like list, optional, getName method etc. """ # there is only one key and it has one value varname, properties = next(iter(child.items())) args = Argument() args.varname = varname # type i.e. class of the variable args.class_name = properties['type'] if self.debug: print('Child {}, {}'.format(args.varname, args.class_name)) # if there is add method for member in the class if 'add' in properties: args.add_method = properties['add'] # if variable is an optional member if 'optional' in properties: args.is_optional = properties['optional'] # if variable is vector, the separator to use while # printing back to nmodl if 'separator' in properties: args.separator = properties['separator'] # if variable is public member if 'public' in properties: args.is_public = properties['public'] # if variable if of vector type if 'vector' in properties: args.is_vector = properties['vector'] # if get_node_name method required if 'node_name' in properties: args.get_node_name = properties['node_name'] # brief description of member variable if 'brief' in properties: args.brief = properties['brief'] # description of member variable if 'description' in properties: args.description = properties['description'] # if getter method required if 'getter' in properties: if 'name' in properties['getter']: args.getter_method = properties['getter']['name'] if 'override' in properties['getter']: args.getter_override = properties['getter']['override'] # if there is nmodl name if 'nmodl' in properties: args.nmodl_name = properties['nmodl'] # prefix while printing back to NMODL if 'prefix' in properties: args.prefix = properties['prefix']['value'] # if prefix is compulsory to print in NMODL then make suffix empty if 'force' in properties['prefix']: if properties['prefix']['force']: args.force_prefix = args.prefix args.prefix = "" # suffix while printing back to NMODL if 'suffix' in properties: args.suffix = properties['suffix']['value'] # if suffix is compulsory to print in NMODL then make suffix empty if 'force' in properties['suffix']: if properties['suffix']['force']: args.force_suffix = args.suffix args.suffix = "" return args
def __init__(self): self.argument = Argument({})
def _set_param_config_free_or_freeze(target_arg: argument.Argument, value: float, d_func: Callable): if value is not None: target_arg.set_value(value) if d_func is not None: print("Depending function is ignored.")
def __init__(self): args = Argument.get() self.db = Connection(args.driver, args.server, args.database, args.userid, args.password)