def check_if_substitution_key(self, section_name, property_names):
result = [(property_name, False) for property_name in property_names]
if not self.is_substitution_allowed():
return result
section_name = JSONSchema.format_section_name(section_name).lower()
property_names = [
JSONSchema.format_property_name(property_name)
for property_name in property_names
]
section_property_name = self.get_property_default_value(
section_name, JSONSchema.NAME)
section_property_name = self.get_section_property(
section_name, JSONSchema.NAME, section_property_name)
for key in self._substitutions.keys():
key_items = key.split('.')
if len(key_items) == 3 and \
key_items[0] == section_name and \
key_items[1] == section_property_name and \
key_items[2] in property_names:
result[property_names.index(key_items[2])] = (key_items[2],
True)
continue
return result
def post_set_section_property(self, section_name, property_name):
property_name = JSONSchema.format_property_name(property_name)
if property_name == JSONSchema.NAME:
section_name = JSONSchema.format_section_name(section_name).lower()
value = self.get_section_property(section_name, property_name)
if InputParser.OPERATOR == section_name:
self._update_operator_input_schema()
elif JSONSchema.PROBLEM == section_name:
self._update_operator_problem()
self._update_operator_input_schema()
# remove properties that are not valid for this operator
default_properties = self.get_section_default_properties(
InputParser.OPERATOR)
if isinstance(default_properties, dict):
properties = self.get_section_properties(
InputParser.OPERATOR)
for p_name in list(properties.keys()):
if p_name != JSONSchema.NAME and p_name not in default_properties:
self.delete_section_property(
InputParser.OPERATOR, p_name)
elif value is not None:
value = str(value).lower().strip()
if len(value) > 0 and self.section_is_driver(value):
self._update_driver_input_schemas()
self._update_driver_sections()
def validate(self, args_dict):
schema_dict = self.CONFIGURATION.get('input_schema', None)
if schema_dict is None:
return
jsonSchema = JSONSchema(schema_dict)
schema_property_names = jsonSchema.get_default_section_names()
json_dict = {}
for property_name in schema_property_names:
if property_name in args_dict:
json_dict[property_name] = args_dict[property_name]
jsonSchema.validate(json_dict)
def set_section_property(self, section_name, property_name, value):
section_name = JSONSchema.format_section_name(section_name).lower()
property_name = JSONSchema.format_property_name(property_name)
value = self._json_schema.check_property_value(section_name, property_name, value)
types = self.get_property_types(section_name, property_name)
sections_temp = copy.deepcopy(self._sections)
InputParser._set_section_property(sections_temp, section_name, property_name, value, types)
msg = self._json_schema.validate_property(sections_temp, section_name, property_name)
if msg is not None:
raise AquaError("{}.{}: Value '{}': '{}'".format(section_name, property_name, value, msg))
# check if this provider is loadable and valid
if JSONSchema.BACKEND == section_name and property_name == JSONSchema.PROVIDER:
get_backends_from_provider(value)
InputParser._set_section_property(self._sections, section_name, property_name, value, types)
if property_name == JSONSchema.NAME:
if InputParser.OPERATOR == section_name:
self._update_operator_input_schema()
# remove properties that are not valid for this section
default_properties = self.get_section_default_properties(section_name)
if isinstance(default_properties, dict):
properties = self.get_section_properties(section_name)
for property_name in list(properties.keys()):
if property_name != JSONSchema.NAME and property_name not in default_properties:
self.delete_section_property(section_name, property_name)
elif JSONSchema.PROBLEM == section_name:
self._update_algorithm_problem()
self._update_operator_problem()
elif JSONSchema.BACKEND == section_name:
self._json_schema.update_backend_schema()
elif InputParser.is_pluggable_section(section_name):
self._json_schema.update_pluggable_input_schemas(self)
# remove properties that are not valid for this section
default_properties = self.get_section_default_properties(section_name)
if isinstance(default_properties, dict):
properties = self.get_section_properties(section_name)
for property_name in list(properties.keys()):
if property_name != JSONSchema.NAME and property_name not in default_properties:
self.delete_section_property(section_name, property_name)
if section_name == PluggableType.ALGORITHM.value:
self._update_dependency_sections()
elif value is not None:
value = str(value).lower().strip()
if len(value) > 0 and self.section_is_driver(value):
self._update_driver_input_schemas()
self._update_driver_sections()
self._sections = self._order_sections(self._sections)
def post_set_section_property(self, section_name, property_name):
property_name = JSONSchema.format_property_name(property_name)
if property_name == JSONSchema.NAME:
section_name = JSONSchema.format_section_name(section_name).lower()
value = self.get_section_property(section_name, property_name)
if InputParser.OPERATOR == section_name:
self._update_operator_input_schema()
elif JSONSchema.PROBLEM == section_name:
self._update_operator_problem()
elif value is not None:
value = str(value).lower().strip()
if len(value) > 0 and self.section_is_driver(value):
self._update_driver_input_schemas()
self._update_driver_sections()
def validate(self, args_dict):
""" Validates the configuration against the input schema. N.B. Not in use at the moment. """
schema_dict = self.CONFIGURATION.get('input_schema', None)
if schema_dict is None:
return
jsonSchema = JSONSchema(schema_dict)
schema_property_names = jsonSchema.get_default_section_names()
json_dict = {}
for property_name in schema_property_names:
if property_name in args_dict:
json_dict[property_name] = args_dict[property_name]
jsonSchema.validate(json_dict)
def validate(self, args_dict):
schema_dict = self.CONFIGURATION.get('input_schema')
if schema_dict is None:
return
jsonSchema = JSONSchema(schema_dict)
schema_property_names = jsonSchema.get_default_section_names()
json_dict = {}
for property_name in schema_property_names:
if property_name in args_dict:
value = args_dict[property_name]
if isinstance(value, np.ndarray):
value = value.tolist()
json_dict[property_name] = value
jsonSchema.validate(json_dict)
def section_is_driver(self, section_name):
""" check if this section is a chemistry driver """
section_name = JSONSchema.format_section_name(section_name).lower()
InputParser._load_driver_names()
driver_names = InputParser._DRIVER_NAMES \
if isinstance(InputParser._DRIVER_NAMES, list) else []
return section_name in driver_names
def _load_parser_from_dict(self):
self._sections = OrderedDict()
for section_name, value in self._inputdict.items():
section_name = JSONSchema.format_section_name(section_name).lower()
if isinstance(value, dict):
self._sections[section_name] = OrderedDict(value)
elif isinstance(value, list) or isinstance(value, str):
if isinstance(value, list):
self._sections[section_name] = '\n'.join(str(e) for e in value)
else:
self._sections[section_name] = value
else:
raise QiskitChemistryError("Invalid parser input type for section {}".format(section_name))
def __init__(self, input=None):
"""Create Parser object."""
json_schema = JSONSchema(
os.path.join(os.path.dirname(__file__), 'input_schema.json'))
# get some properties from algorithms schema
json_schema.copy_section_from_aqua_schema(
PluggableType.ALGORITHM.value)
json_schema.copy_section_from_aqua_schema(JSONSchema.BACKEND)
json_schema.copy_section_from_aqua_schema(JSONSchema.PROBLEM)
json_schema.schema['properties'][JSONSchema.PROBLEM]['properties'][
InputParser.AUTO_SUBSTITUTIONS] = {
"type": "boolean",
"default": "true"
}
super().__init__(json_schema)
# limit Chemistry problems to energy and excited_states
chemistry_problems = [
problem
for problem in self.json_schema.get_property_default_values(
JSONSchema.PROBLEM, JSONSchema.NAME)
if any(problem == item.value for item in ChemistryProblem)
]
self.json_schema.schema['properties'][JSONSchema.PROBLEM]['properties'][JSONSchema.NAME]['oneOf'] = \
[{'enum': chemistry_problems}]
self._json_schema.commit_changes()
# ---
self._inputdict = None
if input is not None:
if isinstance(input, dict):
self._inputdict = input
elif isinstance(input, str):
self._filename = input
else:
raise QiskitChemistryError("Invalid parser input type.")
self._section_order = [
JSONSchema.NAME, JSONSchema.PROBLEM, InputParser.DRIVER,
InputParser._UNKNOWN, InputParser.OPERATOR,
PluggableType.ALGORITHM.value
]
for pluggable_type in local_pluggables_types():
if pluggable_type not in [
PluggableType.INPUT, PluggableType.ALGORITHM
]:
self._section_order.append(pluggable_type.value)
self._section_order.extend([JSONSchema.BACKEND, InputParser._UNKNOWN])
jsonfile = os.path.join(os.path.dirname(__file__),
'substitutions.json')
with open(jsonfile) as json_file:
self._substitutions = json.load(json_file)
def delete_section(self, section_name):
"""
Args:
section_name (str): the name of the section, case insensitive
"""
section_name = JSONSchema.format_section_name(section_name).lower()
driver_name = None
if section_name == InputParser.DRIVER:
driver_name = self.get_section_property(section_name,
JSONSchema.NAME)
if driver_name is not None:
driver_name = driver_name.strip().lower()
super().delete_section(section_name)
if driver_name is not None:
# delete correspondent driver name section
super().delete_section(driver_name)
self._update_driver_input_schemas()
self._update_operator_input_schema()
def _get_key_value(line):
stripLine = line.strip()
pos = -1
for start_comment in InputParser._START_COMMENTS:
pos = stripLine.find(start_comment)
if pos >= 0:
break
if pos == 0:
return (None, None)
if pos > 0:
stripLine = stripLine[:pos].strip()
pos = stripLine.find(InputParser._PROPVALUE_SEPARATOR)
if pos > 0:
key = stripLine[0:pos].strip()
value = stripLine[pos + 1:].strip()
return (key, JSONSchema.get_value(value))
return (None, None)
def section_is_driver(self, section_name):
section_name = JSONSchema.format_section_name(section_name).lower()
InputParser._load_driver_names()
return section_name in InputParser._DRIVER_NAMES
def section_is_driver(self, section_name):
section_name = JSONSchema.format_section_name(section_name).lower()
InputParser._load_driver_names()
driver_names = InputParser._DRIVER_NAMES if isinstance(
InputParser._DRIVER_NAMES, list) else []
return section_name in driver_names
