def _parse_param_symbol_subscript_slice(x, size):
x = stringutils.remove_white_space(x).strip('[]')
x += ':' * (2 - x.count(':'))
strt_str, stop_str, step_str = x.split(':')
strt = int(strt_str) if strt_str else None
stop = int(stop_str) if stop_str else None
step = int(step_str) if step_str else None
return tuple(range(*slice(strt, stop, step).indices(size)))
def parse_param_symbol(x, vector_size=None):
x = stringutils.remove_white_space(x)
name, subscript = parse_param_symbol_into_name_and_subscript_str(x)
valid_indices = None
invalid_indices = None
if vector_size is not None and not subscript:
subscript = '[:]'
if subscript:
indices = parse_param_symbol_subscript(subscript, vector_size)
valid_indices, invalid_indices = iterutils.validate_sequence_indices(
indices, vector_size)
valid_indices = iterutils.unwrap_sequence_indices(
valid_indices, vector_size)
return name, valid_indices, invalid_indices
def parse_param_symbol_into_name_and_subscript_str(x):
x = stringutils.remove_white_space(x)
name = x[:x.find('[')].strip() if '[' in x else x
sbsc = x[x.find('['):].strip() if '[' in x else None
return name, sbsc
def _parse_param_symbol_subscript_aindx(x):
x = stringutils.remove_white_space(x).strip('[],')
return tuple([int(i) for i in x.split(',')])
def _parse_param_symbol_subscript_bindx(x):
x = stringutils.remove_white_space(x).strip('[]')
return int(x),
def parse_param_keys(
params, descs,
silent_errors=False,
silent_warnings=False,
throw_on_errors=True,
throw_on_warnings=False,
invalid_keys_syntax=None,
invalid_keys_unknown=None,
invalid_keys_repeated=None,
invalid_keys_bad_scalar=None,
invalid_keys_bad_vector=None):
if params is None:
params = {}
if invalid_keys_syntax is None:
invalid_keys_syntax = []
if invalid_keys_unknown is None:
invalid_keys_unknown = []
if invalid_keys_repeated is None:
invalid_keys_repeated = {}
if invalid_keys_bad_scalar is None:
invalid_keys_bad_scalar = []
if invalid_keys_bad_vector is None:
invalid_keys_bad_vector = {}
rkeys = []
skeys = []
values = []
param_names = []
param_indices = []
eparams_to_keys = collections.defaultdict(list)
for rkey, value in params.items():
skey = stringutils.remove_white_space(rkey)
# Skip keys with invalid syntax
if not is_param_symbol(rkey):
invalid_keys_syntax.append(rkey)
continue
# Extract parameter name and subscript as strings
# The latter will be None if key has scalar syntax
name, subscript = parse_param_symbol_into_name_and_subscript_str(rkey)
# Skip keys with unknown parameters
desc = descs.get(name)
if not desc:
invalid_keys_unknown.append(rkey)
continue
if isinstance(desc, ParamScalarDesc):
# Skip keys which are supposed to be scalars,
# but have a subscript
if subscript is not None:
invalid_keys_bad_scalar.append(rkey)
continue
# Scalars are exploded already
eparams_to_keys[skey].append(rkey)
# Scalars do not have indices
indices = None
else:
size = desc.size()
# Explicitly define vector syntax if subscript is missing
if subscript is None:
subscript = '[:]'
# Extract indices
indices = parse_param_symbol_subscript(subscript, size)
# Validate indices
indices, invalid_indices = iterutils.validate_sequence_indices(
indices, size)
# Skip keys with invalid indices
if invalid_indices:
invalid_keys_bad_vector[rkey] = invalid_indices
continue
# Ensure positive indices
indices = iterutils.unwrap_sequence_indices(indices, size)
# Explode vector
for i in indices:
eparams_to_keys[make_param_symbol(name, i)].append(rkey)
# We differentiate basic indexing from slicing or advanced
# indexing by using an integer instead of a list of integers
if is_param_symbol_subscript_bindx(subscript):
indices = indices[0]
# This is a valid key-value pair
rkeys.append(rkey)
skeys.append(skey)
values.append(value)
param_names.append(name)
param_indices.append(indices)
# Collect all keys that refer to repeated exploded parameters
invalid_keys_repeated_ = collections.defaultdict(list)
for eparam, parents in eparams_to_keys.items():
if len(parents) > 1:
for parent in parents:
invalid_keys_repeated_[parent].append(eparam)
invalid_keys_repeated.update(invalid_keys_repeated_)
# Remove all information related to repeated keys
for rkey in invalid_keys_repeated:
i = rkeys.index(rkey)
del rkeys[i]
del skeys[i]
del values[i]
del param_names[i]
del param_indices[i]
if invalid_keys_unknown:
_log_msg(
logging.WARNING,
silent_warnings,
throw_on_warnings,
f"keys with unknown parameters found: "
f"{str(invalid_keys_unknown)}")
if invalid_keys_syntax:
_log_msg(
logging.ERROR,
silent_errors,
throw_on_errors,
f"keys with invalid syntax found: "
f"{str(invalid_keys_syntax)}")
if invalid_keys_repeated:
_log_msg(
logging.ERROR,
silent_errors,
throw_on_errors,
f"keys with repeated parameters found: "
f"{str(invalid_keys_repeated)}")
if invalid_keys_bad_scalar:
_log_msg(
logging.ERROR,
silent_errors,
throw_on_errors,
f"scalar parameter keys with vector syntax found: "
f"{str(invalid_keys_bad_scalar)}")
if invalid_keys_bad_vector:
_log_msg(
logging.ERROR,
silent_errors,
throw_on_errors,
f"vector parameter keys with out-of-range indices found: "
f"{str(invalid_keys_bad_vector)}")
return skeys, values, param_names, param_indices