def param_get(self, model, var_name=None, idx=None, sysbase=False):
"""
Get parameter from the loaded system
Parameters
----------
server_url
model
var_name
idx
sysbase
Returns
-------
"""
url = os.path.join(self.server_url, 'param')
params = {
'sysid': self.sysid,
'name': model,
'var': var_name,
'idx': idx,
'sysbase': sysbase
}
self.r = requests.get(url=url, params=params)
logger.debug('param_get requested with {}'.format(params))
if not self.r.ok:
logger.error(
'Get parameter error. Check if the params are correct.')
return False
else:
ret = to_number(self.r.text)
logger.info('param_get returns value <{}>'.format(ret))
return ret
def get_model_param():
sysid = request.args.get('sysid', None)
model_name = request.args.get('name', None)
var_name = request.args.get('var', None)
idx = request.args.get('idx', None)
value = request.args.get('value', None)
sysbase = request.args.get('sysbase', 'False')
if not sysid:
flask.abort(400)
if sysbase == 'False':
sysbase = False
elif sysbase == 'True':
sysbase = True
system = systems[sysid]
if request.method == 'GET':
if idx is not None:
idx = to_number(idx)
if request.method == 'GET':
if not model_name or (model_name not in system.devman.devices):
return 'Model name <{}> invalid or not loaded in system'.format(
model_name)
else: # with model_name
model_ref = system.__dict__[model_name]
if var_name: # with `var_name`
if var_name not in model_ref.__dict__:
return 'Error: variable <{}> not exist in <{}>'.format(
var_name, model_name)
if idx:
return jsonify(
model_ref.get_field(field=var_name, idx=idx))
elif not idx:
return jsonify(
list(model_ref.get_field(field=var_name)))
elif not var_name: # without `var_name`
if idx:
if idx not in model_ref.idx:
return 'Error: idx <{}> not exist in <{}>'.format(
idx, model_name)
return jsonify(model_ref.get_element_data(idx))
elif not idx:
return jsonify(model_ref.data_to_list())
elif request.method == 'POST':
if any([model_name, var_name, idx, value]) is None:
flask.abort(400)
model_ref = system.__dict__[model_name]
if var_name not in model_ref.__dict__:
flask.abort(404)
idx = to_number(idx)
if idx not in model_ref.idx:
flask.abort(404)
if sysbase == 'False':
sysbase = False
elif sysbase == 'True':
sysbase = True
model_ref.set_field(var_name, idx, value, sysbase)
model_ref.reload_new_param()
return jsonify(model_ref.get_field(var_name, idx))
def read(file, system):
"""Parse an ANDES card file into internal variables"""
try:
fid = open(file, 'r')
raw_file = fid.readlines()
except IOError:
print('* IOError while reading input card file.')
return
ret_dict = dict()
ret_dict['outfile'] = file.split('.')[0].lower() + '.py'
key, val = None, None
for idx, line in enumerate(raw_file):
line = line.strip()
if not line:
continue
if line.startswith('#'):
continue
elif '#' in line:
line = line.split('#')[0]
if '=' in line: # defining a field
key, val = line.split('=')
key, val = key.strip(), val.strip()
val = [] if val == '' else val
ret_dict.update({key: val})
if val:
val = val.split(';')
else:
val.extend(line.split(';'))
if val:
val = de_blank(val)
ret_dict[key] = val
ret_dict_ord = dict(ret_dict)
for key, val in ret_dict.items():
if not val:
continue
if type(val) == list:
if ':' in val[0]:
new_val = {} # return in a dictionary
new_val_ord = [
] # return in an ordered list with the dict keys at 0
for item in val:
try:
m, n = item.split(':')
except ValueError:
print('* Error: check line <{}>'.format(item))
return
m, n = m.strip(), n.strip()
if ',' in n:
n = n.split(',')
n = de_blank(n)
n = [to_number(i) for i in n]
else:
n = to_number(n)
new_val.update({m.strip(): n})
new_val_ord.append([m.strip(), n])
ret_dict[key] = new_val
ret_dict_ord[key] = new_val_ord
ret_dict['name'] = ret_dict['name'][0]
ret_dict['doc_string'] = ret_dict['doc_string'][0]
ret_dict['group'] = ret_dict['group'][0]
ret_dict['service_keys'] = list(ret_dict['service_eq'].keys())
ret_dict['consts'] = list(ret_dict['data'].keys()) + list(
ret_dict['service_eq'].keys())
ret_dict['init1_eq'] = ret_dict_ord['init1_eq']
ret_dict['service_eq'] = ret_dict_ord['service_eq']
ret_dict['ctrl'] = ret_dict_ord['ctrl']
copy_algebs = []
copy_states = []
for item in ret_dict['ctrl']:
key, val = item
if val[3] == 'y':
copy_algebs.append(key)
elif val[3] == 'x':
copy_states.append(key)
elif val[3] == 'c':
ret_dict['consts'].append(key)
ret_dict['copy_algebs'] = copy_algebs
ret_dict['copy_states'] = copy_states
return run(system, **ret_dict)