def __init__(self, value, rollback=False):
lg.error('-- VALIDATION ERROR: {}'.format(value))
self.value = value
if rollback == 'cd':
self._cruise_data_rollback()
elif rollback == 'cd_update':
self._cruise_data_update_rollback()
def set_oct_exe_path(self, path=None):
''' This method is run when
* The shared.json file already has a path set >> path in argument
* The octave path is set manually >> path in argument as well
'''
lg.info('-- SET OCT EXE PATH')
# lg.warning('>> MANUAL PATH: {}'.format(path))
if path is not None:
if sys.platform == 'win32':
if os.path.basename(path) != 'octave-cli.exe':
self.oct_exe_path = os.path.join(path, 'octave-cli.exe')
else:
self.oct_exe_path = path
else:
if os.path.basename(path) != 'octave-cli':
self.oct_exe_path = os.path.join(path, 'octave-cli')
else:
self.oct_exe_path = path
if self.oct_exe_path is not False:
os.environ['OCTAVE_EXECUTABLE'] = self.oct_exe_path
try:
oct2py_lib = importlib.import_module('oct2py')
self.oc = oct2py_lib.octave
self.oc.addpath(os.path.join(OCEAN_DATA_QC_PY, 'octave'))
self.oc.addpath(os.path.join(OCEAN_DATA_QC_PY, 'octave', 'CANYON-B'))
return {'octave_path': self.oct_exe_path }
except Exception as e:
lg.error('>> oct2py LIBRARY COULD NOT BE IMPORTED, OCTAVE PATH WAS NOT SET CORRECTLY')
return {'octave_path': False }
def update_flag_value(self,
flag_value=None,
flag_to_update=None,
row_indexes=[]):
lg.info('-- UPDATE FLAG VALUE')
self.env.bk_bridge.call_js({
'object': 'tools',
'function': 'show_wait_cursor',
})
if flag_value is None:
lg.error(
'>> An empty flag value got to `self.env.bk_flags.update_flag_value()`'
)
if flag_to_update is None:
flag_to_update = self.env.cur_flag
if row_indexes == []:
lg.error('>> NO row_indexes selected')
self.env.cruise_data.update_flag_values(
column=flag_to_update,
new_flag_value=flag_value,
row_indices=row_indexes,
)
new_values = np.array(self.env.source.data[flag_to_update],
dtype=int) # TODO: Int8 or Int64
new_values[row_indexes] = flag_value
self.env.source.data[flag_to_update] = new_values
self.env.bk_sources.cds_df[flag_to_update] = new_values
# Updating flag colors
self.env.doc.hold('collect')
self.env.bk_plots_handler.replot_color_circles()
# NOTE: update datatable and prof sources is needed because the new flag could be invisible,
# then the profiles should be invisible as well
# self.env.bk_table.update_dt_source()
self.env.bk_sources._upd_prof_srcs(force_selection=True)
self.env.doc.unhold()
self.env.bk_bridge.call_js({
'object': 'tools',
'function': 'show_default_cursor',
})
self.env.bk_bridge.call_js({
'object':
'tools',
'function':
'show_snackbar',
'params': [
'{} values of {} updated with the flag value {}'.format(
len(row_indexes),
flag_to_update,
flag_value,
)
],
})
def repl(match):
""" This function is run for each found ocurrence """
inner_word = match.group(0)
new_var = False
param_name = inner_word[2:-1] # removin characters: ${PARAM} >> PARAM
for elem in self.proj_settings_cps:
if elem['param_name'] == param_name:
new_var = '({})'.format(elem.get('equation', False))
if new_var is False:
lg.error('The computed parameter does not exist')
lg.info('>> INNER WORD: {} | NEW VAR: {}'.format(inner_word, new_var))
return new_var
def compute_equation(self, args):
try:
prec = int(args.get('precision', 5))
except Exception:
lg.error('Precision value could not be cast to integer value')
(eq, computed_param_name, precision) = (
args.get('eq', ''),
args.get('computed_param_name', 'AUX'),
prec
)
eq = re.sub(' ', '', eq) # remove spaces
if eq == '':
lg.error('ERROR: Empty equation')
def repl(match):
""" This function is run for each found ocurrence """
inner_word = match.group(0)
new_var = False
param_name = inner_word[2:-1] # removin characters: ${PARAM} >> PARAM
for elem in self.proj_settings_cps:
if elem['param_name'] == param_name:
new_var = '({})'.format(elem.get('equation', False))
if new_var is False:
lg.error('The computed parameter does not exist')
lg.info('>> INNER WORD: {} | NEW VAR: {}'.format(inner_word, new_var))
return new_var
while re.search(r'\$\{[a-zA-Z0-9_]+\}', eq) is not None:
eq = re.sub(r'\$\{[a-zA-Z0-9_]+\}', repl, eq)
if self.sandbox_funcs is None:
self.sandbox_funcs = self._get_sandbox_funcs(locals())
if self.sandbox_vars is None:
self.sandbox_vars = self._get_sandbox_vars(globals())
ids = self._get_eq_ids(eq)
# check if all the identifiers are in the df
for i in ids:
if i not in self.cruise_data.df.columns: # already calculated parameters also can be use as columns
return {
'success': False,
'msg': 'Some identifiers do not exist in the current dataframe: {}'.format(i),
}
eq = '{} = {}'.format(computed_param_name, eq)
# lg.info('>> EQUATION: {}'.format(eq))
try:
self.cruise_data.df.eval(
expr=eq,
engine='python', # NOTE: numexpr does not support custom functions
inplace=True,
local_dict=self.sandbox_funcs,
global_dict=self.sandbox_vars
)
except Exception as e:
# lg.warning('>> THE CP {} COULD NOT BE CALCULATED: {}'.format(computed_param_name, e))
return {
'success': False,
'msg': 'The equation could not be computed: {}'.format(eq),
'error': '{}'.format(e),
}
if computed_param_name == 'AUX' and 'AUX' in self.cruise_data.df.columns:
del self.cruise_data.df['AUX']
else:
self.cruise_data.df = self.cruise_data.df.round({computed_param_name: precision})
return {
'success': True,
}
def __init__(self, value):
lg.error('-- User error: {}'.format(value))
self.value = value
def get_different_values(self):
""" Structure of the different_values dictionary:
{
'param_name': {
'stt': [
{
'hash': '...',
'flag':
'old_param_value':
'new_param_value':
'old_flag_value':
'new_flag_value':
},
{
...
}
]
}
}
"""
lg.info('-- GET DIFFERENT VALUES')
HASH = 0
COL = 1
self.diff_values = {}
for pair in self.diff_val_pairs:
stt = str(int(self.env.cd_aux.df.loc[
pair[HASH], 'STNNBR'])) # the stt should be always integers?
col = pair[COL]
hash_id = pair[HASH]
param = ''
if FLAG_END in col:
param = col[:-7]
flag = col
else:
param = col
flag = col + FLAG_END
if param not in self.diff_values:
self.diff_values[param] = {}
if stt not in self.diff_values[param]:
self.diff_values[param][stt] = []
exist = len([
val for val in self.diff_values[param][stt]
if val["hash_id"] == hash_id
])
if exist == 0:
aux = {
'old_param_value': self.env.cruise_data.df.loc[hash_id,
param],
'new_param_value': self.env.cd_aux.df.loc[hash_id, param],
'old_flag_value': self.env.cruise_data.df.loc[hash_id,
flag],
'new_flag_value': self.env.cd_aux.df.loc[hash_id, flag],
}
# change = [flag, param, both ]
for key in aux:
lg.info('>> VALUE: {} | TYPE: {}'.format(
aux[key], type(aux[key])))
if isinstance(
aux[key],
(np.int8, np.int16, np.int32, np.int64
)): # they cannot be serialized with json.dumps
aux[key] = int(aux[key])
elif isinstance(aux[key], np.float64) and np.isnan(
aux[key]):
aux[key] = False
elif isinstance(aux[key], np.float64):
aux[key] = float(
aux[key]) # 15 decimal figures survive
# TODO: fix these comparisons as well
if aux['old_param_value'] != aux['new_param_value'] and aux[
'old_flag_value'] != aux['new_flag_value']:
changed = 'both'
elif aux['old_param_value'] != aux['new_param_value']:
changed = 'param'
elif aux['old_flag_value'] != aux['new_flag_value']:
changed = 'flag'
aux.update({
'hash_id':
hash_id,
'castno':
str(self.env.cruise_data.df.loc[hash_id, 'CASTNO']),
'btlnbr':
str(self.env.cruise_data.df.loc[hash_id, 'BTLNBR']),
'latitude':
str(self.env.cruise_data.df.loc[hash_id, 'LATITUDE']),
'longitude':
str(self.env.cruise_data.df.loc[hash_id, 'LONGITUDE']),
'changed':
changed,
})
for key in list(aux.keys()):
lg.info('>> AUX [{} =: {} | TYPE: {}'.format(
key, aux[key], type(aux[key])))
self.diff_values[param][stt].append(aux)
elif exist > 1:
lg.error(
'Repeated row for that value: PARAM: {} | HASH_ID: {}'.
format(param, hash_id))
self.diff_values = json.dumps(self.diff_values, sort_keys=True)
lg.info('>> DIFF VALUES JSON STRING: {}'.format(self.diff_values))
return self.diff_values
