def load_backend_if_not_loaded():
"""Load the current profile if necessary while running the spinner to show command hasn't crashed."""
from aiida.manage.configuration import load_profile
from aiida.manage.manager import get_manager
with spinner():
load_profile()
get_manager().get_backend()
def convert(self, value, param, ctx):
"""Attempt to match the given value to a valid profile."""
from aiida.common.exceptions import MissingConfigurationError, ProfileConfigurationError
from aiida.manage.configuration import get_config, load_profile, Profile
value = super().convert(value, param, ctx)
try:
config = get_config(create=True)
profile = config.get_profile(value)
except (MissingConfigurationError,
ProfileConfigurationError) as exception:
if not self._cannot_exist:
self.fail(str(exception))
# Create a new empty profile
profile = Profile(value, {})
else:
if self._cannot_exist:
self.fail(str(f'the profile `{value}` already exists'))
if self._load_profile:
load_profile(profile.name)
return profile
def aiida(self, line='', local_ns=None):
"""Load AiiDA in ipython (checking if it was already loaded), and
inserts in the namespace the main AiiDA classes (the same that are
loaded in ``verdi shell``.
Usage::
%aiida [optional parameters]
.. todo:: implement parameters, e.g. for the profile to load.
"""
# pylint: disable=unused-argument,attribute-defined-outside-init
from aiida.manage.configuration import load_profile
from aiida.cmdline.utils.shell import get_start_namespace
self.is_warning = False
lcontent = line.strip()
if lcontent:
profile = load_profile(lcontent)
else:
profile = load_profile()
self.current_state = f'Loaded AiiDA DB environment - profile name: {profile.name}.'
user_ns = get_start_namespace()
for key, value in user_ns.items():
add_to_ns(local_ns, key, value)
return self
def alembic_cli(profile):
"""Simple wrapper around the alembic command line tool that first loads an AiiDA profile."""
from aiida.manage.configuration import load_profile
from aiida.manage.manager import get_manager
load_profile(profile=profile.name)
manager = get_manager()
manager._load_backend(schema_check=False) # pylint: disable=protected-access
def test_merge_deprecated_yaml(tmp_path):
"""Test that an existing 'cache_config.yml' is correctly merged into the main config.
An AiidaDeprecationWarning should also be raised.
"""
from aiida.common.warnings import AiidaDeprecationWarning
from aiida.manage import configuration
from aiida.manage.configuration import settings, load_profile, reset_profile, get_config_option
# Store the current configuration instance and config directory path
current_config = configuration.CONFIG
current_config_path = current_config.dirpath
current_profile_name = configuration.PROFILE.name
try:
reset_profile()
configuration.CONFIG = None
# Create a temporary folder, set it as the current config directory path
settings.AIIDA_CONFIG_FOLDER = str(tmp_path)
config_dictionary = json.loads(
Path(__file__).parent.joinpath(
'configuration/migrations/test_samples/reference/5.json').
read_text())
config_dictionary['profiles']['default'][
'AIIDADB_REPOSITORY_URI'] = f"file:///{tmp_path/'repo'}"
cache_dictionary = {
'default': {
'default': True,
'enabled': ['aiida.calculations:quantumespresso.pw'],
'disabled': ['aiida.calculations:templatereplacer']
}
}
tmp_path.joinpath('config.json').write_text(
json.dumps(config_dictionary))
tmp_path.joinpath('cache_config.yml').write_text(
yaml.dump(cache_dictionary))
with pytest.warns(AiidaDeprecationWarning, match='cache_config.yml'):
configuration.CONFIG = configuration.load_config()
load_profile('default')
assert get_config_option('caching.default_enabled') is True
assert get_config_option('caching.enabled_for') == [
'aiida.calculations:quantumespresso.pw'
]
assert get_config_option('caching.disabled_for') == [
'aiida.calculations:templatereplacer'
]
# should have now been moved to cache_config.yml.<DATETIME>
assert not tmp_path.joinpath('cache_config.yml').exists()
finally:
# Reset the config folder path and the config instance. Note this will always be executed after the yield no
# matter what happened in the test that used this fixture.
reset_profile()
settings.AIIDA_CONFIG_FOLDER = current_config_path
configuration.CONFIG = current_config
load_profile(current_profile_name)
def setup(
non_interactive, profile, email, first_name, last_name, institution, db_engine, db_backend, db_host, db_port,
db_name, db_username, db_password, repository
):
"""Setup a new profile."""
# pylint: disable=too-many-arguments,too-many-locals,unused-argument
from aiida import orm
from aiida.manage.configuration import get_config
profile.database_engine = db_engine
profile.database_backend = db_backend
profile.database_name = db_name
profile.database_port = db_port
profile.database_hostname = db_host
profile.database_username = db_username
profile.database_password = db_password
profile.repository_uri = 'file://' + repository
config = get_config()
# Creating the profile
config.add_profile(profile)
config.set_default_profile(profile.name)
# Load the profile
load_profile(profile.name)
echo.echo_success('created new profile `{}`.'.format(profile.name))
# Migrate the database
echo.echo_info('migrating the database.')
backend = get_manager()._load_backend(schema_check=False) # pylint: disable=protected-access
try:
backend.migrate()
except Exception as exception: # pylint: disable=broad-except
echo.echo_critical(
'database migration failed, probably because connection details are incorrect:\n{}'.format(exception)
)
else:
echo.echo_success('database migration completed.')
# Optionally setting configuration default user settings
config.set_option('user.email', email, override=False)
config.set_option('user.first_name', first_name, override=False)
config.set_option('user.last_name', last_name, override=False)
config.set_option('user.institution', institution, override=False)
# Create the user if it does not yet exist
created, user = orm.User.objects.get_or_create(
email=email, first_name=first_name, last_name=last_name, institution=institution
)
if created:
user.store()
profile.default_user = user.email
config.update_profile(profile)
config.store()
def temporary_config_instance():
"""Create a temporary AiiDA instance."""
current_config = None
current_config_path = None
current_profile_name = None
temporary_config_directory = None
from aiida.common.utils import Capturing
from aiida.manage import configuration
from aiida.manage.configuration import settings, load_profile, reset_profile
try:
from aiida.manage.configuration.settings import create_instance_directories
# Store the current configuration instance and config directory path
current_config = configuration.CONFIG
current_config_path = current_config.dirpath
current_profile_name = configuration.PROFILE.name
reset_profile()
configuration.CONFIG = None
# Create a temporary folder, set it as the current config directory path and reset the loaded configuration
profile_name = 'test_profile_1234'
temporary_config_directory = tempfile.mkdtemp()
settings.AIIDA_CONFIG_FOLDER = temporary_config_directory
# Create the instance base directory structure, the config file and a dummy profile
create_instance_directories()
# The constructor of `Config` called by `load_config` will print warning messages about migrating it
with Capturing():
configuration.CONFIG = configuration.load_config(create=True)
profile = create_mock_profile(
name=profile_name, repository_dirpath=temporary_config_directory)
# Add the created profile and set it as the default
configuration.CONFIG.add_profile(profile)
configuration.CONFIG.set_default_profile(profile_name, overwrite=True)
configuration.CONFIG.store()
load_profile()
yield configuration.CONFIG
finally:
# Reset the config folder path and the config instance
reset_profile()
settings.AIIDA_CONFIG_FOLDER = current_config_path
configuration.CONFIG = current_config
load_profile(current_profile_name)
# Destroy the temporary instance directory
if temporary_config_directory and os.path.isdir(
temporary_config_directory):
shutil.rmtree(temporary_config_directory)
def initialize(self):
"""Set internal attributes of the class.
Includes importing the process class.
"""
# pylint: disable=attribute-defined-outside-init
from aiida.manage.configuration import load_profile
load_profile()
self.class_name = self.arguments[0].split('(')[0]
self.module_name = self.options['module']
self.process_name = self.module_name + '.' + self.class_name
self.process = get_object_from_string(self.process_name)
self.process_spec = self.process.spec()
def load_backend_if_not_loaded():
"""Load the database backend environment for the currently loaded profile.
If no profile has been loaded yet, the default profile will be loaded first. A spinner will be shown during both
actions to indicate that the function is working and has not crashed, since loading can take a second.
"""
from aiida.manage.configuration import get_profile, load_profile
from aiida.manage.manager import get_manager
manager = get_manager()
if get_profile() is None or not manager.backend_loaded:
with spinner():
load_profile() # This will load the default profile if no profile has already been loaded
manager.get_backend() # This will load the backend of the loaded profile, if not already loaded
def create_host_plots_clean():
pn.extension('mathjax')
# load aiida if necessary
profile = load_profile(profile_name)
ase_atoms = prepare_plotting_structure()
strucview = create_structure_plot(ase_atoms, static_plot=True)
# create bandstructure plot
bandstruc_plot = plot_bandstruc()
# make DOS plot
dos_plot, ymax = plot_dos()
# add ef lines to bandstructure plot (needs to be done here since some values are otherwise not defined)
add_ef_lines_bandstruc(bandstruc_plot, ymax)
# put bandstructure and DOS plots together
layout = pn.Row(bandstruc_plot, dos_plot)
#struc_title = pn.pane.LaTeX("Thin film (6QL) of Sb$_2$Te$_3$")
#host_plots = pn.Row(pn.Column(struc_title, strucview), layout)
host_plots = pn.Row(strucview, layout)
return host_plots
def main(profile, command):
"""Simple wrapper around the Django command line tool that first loads an AiiDA profile."""
from django.core.management import execute_from_command_line
# Load the general load_dbenv.
from aiida.manage.configuration import load_profile
from aiida.manage.manager import get_manager
load_profile(profile=profile.name)
manager = get_manager()
manager._load_backend(schema_check=False)
# The `execute_from_command` expects a list of command line arguments where the first is the program name that one
# would normally call directly. Since this is now replaced by our `click` command we just spoof a random name.
argv = ['basename'] + list(command)
execute_from_command_line(argv)
def create_db(profile):
"""Create PostgreSQL database, if missing."""
dbinfo_su = {
'host': profile.database_hostname,
'port': profile.database_port,
'user': os.getenv("AIIDADB_SUPER_USER"),
'password': os.getenv("AIIDADB_SUPER_PASS"),
'database': 'template1',
}
postgres = Postgres(interactive=False, quiet=False,
dbinfo=dbinfo_su) #, determine_setup=False)
if not postgres.is_connected:
raise ConnectionError("Unable to connect as super user")
try:
if not postgres.dbuser_exists(dbuser=profile.database_username):
postgres.create_dbuser(dbuser=profile.database_username,
dbpass=profile.database_password)
if not postgres.db_exists(dbname=profile.database_name):
postgres.create_db(profile.database_username,
profile.database_name)
# Fill DB with vanilla content
load_profile(profile.name)
backend = get_manager()._load_backend(schema_check=False) # pylint: disable=protected-access
try:
backend.migrate()
except Exception as exception: # pylint: disable=broad-except
print(
'database migration failed, probably because connection details are incorrect:\n{}'
.format(exception))
# Create the user if it does not yet exist
created, user = orm.User.objects.get_or_create(
email=profile.default_user,
first_name='AiiDA',
last_name='EXPLORER',
institution='WEBSERVICE')
if created:
user.store()
profile.default_user = user.email
except:
print(traceback.format_exc())
def load_dbenv(profile=None):
"""Alias for `load_dbenv` from `aiida.backends.utils`
:param profile: name of the profile to load
:type profile: str
.. deprecated:: 1.0.0
Will be removed in `v2.0.0`, use :func:`aiida.manage.configuration.load_profile` instead.
"""
warnings.warn('function is deprecated, use `load_profile` instead', AiidaDeprecationWarning) # pylint: disable=no-member
current_profile = get_profile()
from aiida.common import InvalidOperation
if current_profile:
raise InvalidOperation('You cannot call load_dbenv multiple times!')
load_profile(profile)
def initialize(self):
"""Set internal attributes of the class.
Includes importing the process class.
"""
# pylint: disable=attribute-defined-outside-init
load_profile()
self.class_name = self.arguments[0].split('(')[0]
self.module_name = self.options['module']
self.process_name = f'{self.module_name}.{self.class_name}'
self.process = get_object_from_string(self.process_name)
try:
self.process_spec = self.process.spec()
except Exception as exc:
raise RuntimeError(
f"Error while building the spec for process '{self.process_name}': '{exc!r}.'"
) from exc
def initialize(self):
"""Set internal attributes of the class.
Includes importing the process class.
"""
# pylint: disable=attribute-defined-outside-init
from aiida.manage.configuration import load_profile
load_profile()
self.class_name = self.arguments[0].split('(')[0]
self.module_name = self.options['module']
self.process_name = self.module_name + '.' + self.class_name
self.process = get_object_from_string(self.process_name)
try:
self.process_spec = self.process.spec()
except Exception as exc:
raise RuntimeError(
"Error while building the spec for process '{}': '{!r}.'".
format(self.process_name, exc)) from exc
def empty_config(tmp_path) -> Config:
"""Create a temporary configuration instance.
This creates a temporary directory with a clean `.aiida` folder and basic configuration file. The currently loaded
configuration and profile are stored in memory and are automatically restored at the end of this context manager.
:return: a new empty config instance.
"""
from aiida.common.utils import Capturing
from aiida.manage import configuration
from aiida.manage.configuration import settings, reset_profile
# Store the current configuration instance and config directory path
current_config = configuration.CONFIG
current_config_path = current_config.dirpath
current_profile_name = configuration.PROFILE.name
reset_profile()
configuration.CONFIG = None
# Create a temporary folder, set it as the current config directory path and reset the loaded configuration
settings.AIIDA_CONFIG_FOLDER = str(tmp_path)
# Create the instance base directory structure, the config file and a dummy profile
settings.create_instance_directories()
# The constructor of `Config` called by `load_config` will print warning messages about migrating it
with Capturing():
configuration.CONFIG = configuration.load_config(create=True)
yield get_config()
# Reset the config folder path and the config instance. Note this will always be executed after the yield no
# matter what happened in the test that used this fixture.
reset_profile()
settings.AIIDA_CONFIG_FOLDER = current_config_path
configuration.CONFIG = current_config
load_profile(current_profile_name)
def _config_with_profile_factory(set_as_default=True, load=True, name='default', **kwargs):
"""Create a temporary configuration instance with one profile.
:param set_as_default: whether to set the one profile as the default.
:param load: whether to load the profile.
:param name: the profile name
:param kwargs: parameters that are forwarded to the `Profile` constructor.
:return: a config instance with a configured profile.
"""
profile = profile_factory(name=name, **kwargs)
config = empty_config
config.add_profile(profile)
if set_as_default:
config.set_default_profile(profile.name, overwrite=True)
config.store()
if load:
load_profile(profile.name)
return config
# Enable rtd mode via `export READTHEDOCS=True`
on_rtd = os.environ.get('READTHEDOCS', None) == 'True'
if not on_rtd: # only import and set the theme if we're building docs locally
try:
import sphinx_rtd_theme
html_theme = 'sphinx_rtd_theme'
html_theme_path = [sphinx_rtd_theme.get_html_theme_path()]
except ImportError:
# No sphinx_rtd_theme installed
pass
# Load the database environment by first loading the profile and then loading the backend through the manager
from aiida.manage.configuration import get_config, load_profile
from aiida.manage.manager import get_manager
config = get_config()
load_profile(config.default_profile_name)
get_manager().get_backend()
else:
# Back-end settings for readthedocs online documentation.
from aiida.manage import configuration
configuration.IN_RT_DOC_MODE = True
configuration.BACKEND = "django"
# -- General configuration ------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
needs_sphinx = '1.5'
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
# documentation root, use os.path.abspath to make it absolute, like shown here.
# Enable rtd mode via `export READTHEDOCS=True`
on_rtd = os.environ.get('READTHEDOCS', None) == 'True'
if not on_rtd: # only import and set the theme if we're building docs locally
import sphinx_rtd_theme
html_theme = 'sphinx_rtd_theme'
html_theme_path = [sphinx_rtd_theme.get_html_theme_path()]
# Back-end settings for readthedocs online documentation.
configuration.IN_RT_DOC_MODE = True
configuration.BACKEND = "django"
configuration.reset_config() # empty config was created when importing aiida
configuration.load_profile() # load dummy config for RTD
# load DB backend (no schema check since no DB)
get_manager()._load_backend(schema_check=False) # pylint: disable=protected-access
# -- General configuration ------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
needs_sphinx = '1.5'
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
extensions = [
'sphinx.ext.autodoc',
'sphinx.ext.mathjax',
'sphinx.ext.intersphinx',
email=profile.default_user,
first_name='AiiDA',
last_name='EXPLORER',
institution='WEBSERVICE')
if created:
user.store()
profile.default_user = user.email
except:
print(traceback.format_exc())
if os.getenv("AIIDADB_SUPER_USER"):
create_db(profile)
config.update_profile(profile)
load_profile(profile_name)
CONFIG_DIR = os.path.join(
os.path.split(os.path.abspath(aiida.restapi.__file__))[0], 'common')
(app, api) = run_api(api.App,
api.AiidaApi,
hostname="localhost",
port=5000,
config=CONFIG_DIR,
debug=False,
wsgi_profile=False,
hookup=False,
catch_internal_server=False)
import numpy as np
from aiida.manage.configuration import load_profile
from aiida.orm import Bool, Str, Code, Int, Float
from aiida.plugins import DataFactory, WorkflowFactory
from aiida.engine import submit
load_profile()
Dict = DataFactory('dict')
KpointsData = DataFactory("array.kpoints")
def launch_aiida_bulk_modulus(structure, code_string, resources,
label="AlN VASP relax calculation"):
incar_dict = {'incar': {
'PREC': 'Accurate',
'EDIFF': 1e-8,
'NELMIN': 5,
'NELM': 100,
'ENCUT': 500,
'IALGO': 38,
'ISMEAR': 0,
'SIGMA': 0.01,
'GGA': 'PS',
'LREAL': False,
'LCHARG': False,
'LWAVE': False,}
}
kpoints = KpointsData()
kpoints.set_kpoints_mesh([6, 6, 4], offset=[0, 0, 0.5])
# documentation root, use os.path.abspath to make it absolute, like shown here.
# Enable rtd mode via `export READTHEDOCS=True`
on_rtd = os.environ.get('READTHEDOCS', None) == 'True'
if not on_rtd: # only import and set the theme if we're building docs locally
try:
import sphinx_rtd_theme
html_theme = 'sphinx_rtd_theme'
html_theme_path = [sphinx_rtd_theme.get_html_theme_path()]
except ImportError:
# No sphinx_rtd_theme installed
pass
# Load the database environment by first loading the profile and then loading the backend through the manager
config = configuration.get_config()
configuration.load_profile(config.default_profile_name)
get_manager().get_backend()
else:
# Back-end settings for readthedocs online documentation.
configuration.IN_RT_DOC_MODE = True
configuration.BACKEND = "django"
configuration.reset_config() # empty config was created when importing aiida
configuration.load_profile() # load dummy config for RTD
# load DB backend (no schema check since no DB)
get_manager()._load_backend(schema_check=False) # pylint: disable=protected-access
# -- General configuration ------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
needs_sphinx = '1.5'