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 PluggableType.INPUT.value == section_name:
self._update_algorithm_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_input_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()
self._sections = self._order_sections(self._sections)
def load_file(self, filename, parser_class, populate_defaults):
from qiskit.aqua.parser import JSONSchema
from qiskit.aqua import get_provider_from_backend, get_backends_from_provider
if filename is None:
return []
try:
self._parser = parser_class(filename)
self._parser.parse()
# before merging defaults attempts to find a provider for the backend
provider = self._parser.get_section_property(
JSONSchema.BACKEND, JSONSchema.PROVIDER)
if provider is None:
backend_name = self._parser.get_section_property(
JSONSchema.BACKEND, JSONSchema.NAME)
if backend_name is not None:
self._parser.set_section_property(
JSONSchema.BACKEND, JSONSchema.PROVIDER,
get_provider_from_backend(backend_name))
else:
try:
if provider not in self.providers:
self._custom_providers[
provider] = get_backends_from_provider(provider)
except Exception as e:
logger.debug(str(e))
if populate_defaults:
self._parser.validate_merge_defaults()
self._parser.commit_changes()
return self._parser.get_section_names()
except:
self._parser = None
raise
def set_section_property(self, section_name, property_name, value):
from qiskit.aqua.parser import BaseParser
from qiskit.aqua.parser import JSONSchema
from qiskit.aqua import get_backends_from_provider
if self._parser is None:
raise Exception('Input not initialized.')
self._parser.set_section_property(section_name, property_name, value)
if property_name == JSONSchema.NAME and BaseParser.is_pluggable_section(
section_name):
properties = self._parser.get_section_default_properties(
section_name)
if isinstance(properties, dict):
properties[JSONSchema.NAME] = value
self._parser.delete_section_properties(section_name)
for property_name, property_value in properties.items():
self._parser.set_section_property(section_name,
property_name,
property_value)
elif section_name == JSONSchema.BACKEND and property_name == JSONSchema.PROVIDER:
backends = get_backends_from_provider(value)
if value not in self.providers:
self._custom_providers[value] = backends
backend = backends[0] if len(backends) > 0 else ''
self._parser.set_section_property(section_name, JSONSchema.NAME,
backend)
def set_default_properties_for_name(self, section_name):
""" set default properties for name key """
from qiskit.aqua.parser import JSONSchema
from qiskit.aqua import get_backends_from_provider
if self._parser is None:
raise Exception('Input not initialized.')
# First get the properties that will remain
provider_name = None
name = self._parser.get_section_property(section_name, JSONSchema.NAME)
if JSONSchema.BACKEND == section_name:
provider_name = self._parser.get_section_property(
section_name, JSONSchema.PROVIDER)
if provider_name is not None:
backend_names = get_backends_from_provider(provider_name)
if name not in backend_names:
# use first backend available in provider
name = backend_names[0] if backend_names else None
# now delete all current properties
self._parser.delete_section_properties(section_name)
# set first the properties that remained
if provider_name is not None:
self._parser.set_section_property(section_name,
JSONSchema.PROVIDER,
provider_name)
if name is not None:
self._parser.set_section_property(section_name, JSONSchema.NAME,
name)
# now fetch all default properties from updated schema
value = self._parser.get_section_default_properties(section_name)
if isinstance(value, dict):
if JSONSchema.NAME in value:
# remove name from defaults to be updated, since it should remain intact
del value[JSONSchema.NAME]
if JSONSchema.BACKEND == section_name and JSONSchema.PROVIDER in value:
# remove provider name from defaults to be updated, since it should remain intact
del value[JSONSchema.PROVIDER]
# add all default properties
for property_name, property_value in value.items():
self._parser.set_section_property(section_name, property_name,
property_value)
else:
if value is None:
types = self._parser.get_section_types(section_name)
if 'null' not in types:
if 'string' in types:
value = ''
elif 'object' in types:
value = {}
elif 'array' in types:
value = []
self._parser.set_section_data(section_name, value)
def set_section_property(self, section_name, property_name, value):
""" set section property """
from qiskit.aqua.parser import BaseParser
from qiskit.aqua.parser import JSONSchema
from qiskit.aqua import get_backends_from_provider
if self._parser is None:
raise Exception('Input not initialized.')
self._parser.set_section_property(section_name, property_name, value)
value = self._parser.get_section_property(section_name, property_name)
# set default properties
if (section_name == JSONSchema.BACKEND and property_name in
[JSONSchema.PROVIDER, JSONSchema.NAME]) or \
(property_name == JSONSchema.NAME and BaseParser.is_pluggable_section(section_name)):
properties = self._parser.get_section_default_properties(
section_name)
if isinstance(properties, dict):
if section_name == JSONSchema.BACKEND:
properties[JSONSchema.PROVIDER] = \
self._parser.get_section_property(section_name, JSONSchema.PROVIDER)
properties[JSONSchema.NAME] = \
self._parser.get_section_property(section_name, JSONSchema.NAME)
# move name to top
if JSONSchema.NAME in properties:
properties.move_to_end(JSONSchema.NAME, last=False)
# move provider to top
if JSONSchema.PROVIDER in properties:
properties.move_to_end(JSONSchema.PROVIDER, last=False)
properties[property_name] = value
self._parser.delete_section_properties(section_name)
for prop_name, prop_value in properties.items():
self._parser.set_section_property(section_name, prop_name,
prop_value)
if section_name == JSONSchema.BACKEND and property_name == JSONSchema.PROVIDER:
# refresh backends for this provider
backends = get_backends_from_provider(value)
if value not in self.providers:
self._custom_providers[value] = backends
def load_model(self, filename, parser_class, populate_defaults):
""" load a model """
from qiskit.aqua.parser import JSONSchema
from qiskit.aqua import get_provider_from_backend, get_backends_from_provider
if filename is None:
return []
try:
self._parser = parser_class(filename)
self._parser.parse()
# check if there was any data, if there is no data, just return empty file
if not self.get_section_names():
return []
# before merging defaults attempts to find a provider for the backend
provider = self._parser.get_section_property(
JSONSchema.BACKEND, JSONSchema.PROVIDER)
if provider is None:
backend_name = \
self._parser.get_section_property(JSONSchema.BACKEND, JSONSchema.NAME)
if backend_name is not None:
self._parser.set_section_property(
JSONSchema.BACKEND, JSONSchema.PROVIDER,
get_provider_from_backend(backend_name))
else:
try:
if provider not in self.providers:
self._custom_providers[
provider] = get_backends_from_provider(provider)
except Exception as ex: # pylint: disable=broad-except
logger.debug(str(ex))
except Exception:
self._parser = None
raise
try:
if populate_defaults:
self._parser.validate_merge_defaults()
return self.get_section_names()
finally:
self._parser.commit_changes()
def _set_section_property_without_checking_defaults(self, section_name, property_name, value):
"""
Args:
section_name (str): the name of the section, case insensitive
property_name (str): the name of the property
value (obj): the value of the property
Returns:
Bool: True if value changed
"""
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)
BaseParser._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))
value_changed = False
old_value = None
if section_name not in self._sections:
value_changed = True
elif property_name not in self._sections[section_name]:
value_changed = True
else:
old_value = self.get_section_property(section_name, property_name)
value_changed = (old_value != value)
if not value_changed:
# nothing changed
return False
# check if the provider/backend is loadable and valid
backend_names = []
if JSONSchema.BACKEND == section_name and property_name in [JSONSchema.PROVIDER, JSONSchema.NAME]:
provider_name = value if property_name == JSONSchema.PROVIDER else self.get_section_property(section_name, JSONSchema.PROVIDER)
backend_names = get_backends_from_provider(provider_name)
if property_name == JSONSchema.NAME and value not in backend_names:
raise AquaError("Backend '{}' not valid for provider: '{}' backends: '{}'".format(value, provider_name, backend_names))
# update value internally
BaseParser._set_section_property(self._sections, section_name, property_name, value, types)
if JSONSchema.BACKEND == section_name and property_name in [JSONSchema.PROVIDER, JSONSchema.NAME]:
if property_name == JSONSchema.PROVIDER:
backend_name = self.get_section_property(section_name, JSONSchema.NAME)
if backend_name not in backend_names:
# use first backend available in provider
backend_name = backend_names[0] if len(backend_names) > 0 else ''
BaseParser._set_section_property(self._sections, section_name, JSONSchema.NAME, backend_name, ['string'])
self._json_schema.update_backend_schema(self)
return True
if property_name == JSONSchema.NAME:
if BaseParser.is_pluggable_section(section_name):
self._json_schema.update_pluggable_schemas(self)
self._update_dependency_sections(section_name)
# remove any previous pluggable sections not in new dependency list
old_dependencies = self._get_dependency_sections(section_name, old_value) if old_value is not None else set()
new_dependencies = self._get_dependency_sections(section_name, value) if value is not None else set()
for pluggable_name in old_dependencies.difference(new_dependencies):
if pluggable_name in self._sections:
del self._sections[pluggable_name]
# reorder sections
self._sections = self._order_sections(self._sections)
return True
if JSONSchema.PROBLEM == section_name:
self._update_algorithm_problem()
self.post_set_section_property(section_name, property_name)
return True
def set_section_property(self, section_name, property_name, value):
"""
Args:
section_name (str): the name of the section, case insensitive
property_name (str): the name of the property
value (obj): the value of the property
"""
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)
BaseParser._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))
value_changed = False
if section_name not in self._sections:
value_changed = True
elif property_name not in self._sections[section_name]:
value_changed = True
else:
old_value = self.get_section_property(section_name, property_name)
value_changed = (old_value != value)
if not value_changed:
# nothing changed
return
# check if this provider is loadable and valid
if JSONSchema.BACKEND == section_name and property_name == JSONSchema.PROVIDER:
get_backends_from_provider(value)
BaseParser._set_section_property(self._sections, section_name,
property_name, value, types)
if property_name == JSONSchema.NAME:
if JSONSchema.PROBLEM == section_name:
self._update_algorithm_problem()
elif JSONSchema.BACKEND == section_name:
self._json_schema.update_backend_schema()
elif BaseParser.is_pluggable_section(section_name):
self._json_schema.update_pluggable_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 p_name in list(properties.keys()):
if p_name != JSONSchema.NAME and p_name not in default_properties:
self.delete_section_property(section_name, p_name)
self._update_dependency_sections(section_name)
else:
self.post_set_section_property(section_name, property_name)
self._sections = self._order_sections(self._sections)
