def get_start_namespace(self):
"""Load all default and custom modules"""
from aiida import load_dbenv, is_dbenv_loaded
from aiida.backends import settings
if not is_dbenv_loaded():
load_dbenv(profile=settings.AIIDADB_PROFILE)
from aiida.common.setup import get_property
user_ns = {}
# load default modules
for app_mod, model_name, alias in default_modules_list:
user_ns[alias] = getattr(__import__(app_mod, {}, {},
model_name), model_name)
# load custom modules
custom_modules_list = [(str(e[0]), str(e[2])) for e in
[p.rpartition('.') for p in get_property(
'verdishell.modules', default="").split(
':')]
if e[1] == '.']
for app_mod, model_name in custom_modules_list:
try:
user_ns[model_name] = getattr(
__import__(app_mod, {}, {}, model_name), model_name)
except AttributeError:
# if the module does not exist, we ignore it
pass
return user_ns
def get_start_namespace():
"""Load all default and custom modules"""
from aiida.cmdline.utils.shell import DEFAULT_MODULES_LIST
from aiida.common.setup import get_property
user_ns = {}
# load default modules
for app_mod, model_name, alias in DEFAULT_MODULES_LIST:
user_ns[alias] = getattr(__import__(app_mod, {}, {}, model_name),
model_name)
# load custom modules
custom_modules_list = [(str(e[0]), str(e[2])) for e in [
p.rpartition('.')
for p in get_property('verdishell.modules', default="").split(':')
] if e[1] == '.']
for app_mod, model_name in custom_modules_list:
try:
user_ns[model_name] = getattr(
__import__(app_mod, {}, {}, model_name), model_name)
except AttributeError:
# if the module does not exist, we ignore it
pass
return user_ns
def run_listproperties(self, *args):
"""
List all found global AiiDA properties.
"""
import argparse
from aiida.common.setup import (
_property_table, exists_property, get_property)
parser = argparse.ArgumentParser(
prog=self.get_full_command_name(),
description='List all custom properties stored in the user configuration file.')
parser.add_argument('-a', '--all',
dest='all', action='store_true',
help="Show all properties, even if not explicitly defined, if they "
"have a default value.")
parser.set_defaults(all=False)
parsed_args = parser.parse_args(args)
show_all = parsed_args.all
for prop in sorted(_property_table.keys()):
try:
# To enforce the generation of an exception, even if
# there is a default value
if show_all or exists_property(prop):
val = get_property(prop)
print "{} = {}".format(prop, val)
except KeyError:
pass
def test_set_property(self):
"""Test the `verdi devel setproperty` command."""
property_name = 'daemon.timeout'
property_values = [10, 20]
for property_value in property_values:
options = [property_name, str(property_value)]
result = self.runner.invoke(cmd_devel.devel_setproperty, options)
self.assertIsNone(result.exception)
self.assertEquals(get_property(property_name), property_value)
def devel_listproperties(all_entries):
"""List all the properties that are explicitly set for the current profile."""
from aiida.common.setup import _property_table, exists_property, get_property
for prop in sorted(_property_table.keys()):
try:
# To enforce the generation of an exception, even if there is a default value
if all_entries or exists_property(prop):
val = get_property(prop)
echo.echo('{} = {}'.format(prop, val))
except KeyError:
pass
def devel_getproperty(prop):
"""Get the global PROPERTY from the configuration file."""
from aiida.common.setup import get_property
try:
value = get_property(prop)
except ValueError:
echo.echo_critical('property {} not found'.format(prop))
except Exception as exception: # pylint: disable=broad-except
echo.echo_critical('{} while getting the property: {}'.format(
type(exception).__name__, exception.message))
else:
echo.echo('{}'.format(value))
def run_getproperty(self, *args):
"""
Get a global AiiDA property from the config file in .aiida.
"""
from aiida.common.setup import get_property
if len(args) != 1:
print >> sys.stderr, ("usage: {} PROPERTYNAME".format(
self.get_full_command_name()))
sys.exit()
try:
value = get_property(args[0])
except Exception as e:
print >> sys.stderr, ("{} while getting the "
"property: {}".format(type(e).__name__, e.message))
sys.exit(1)
print "{}".format(value)
import warnings
from aiida.common.log import configure_logging
from aiida.common.setup import get_property
__copyright__ = u"Copyright (c), This file is part of the AiiDA platform. For further information please visit http://www.aiida.net/. All rights reserved."
__license__ = "MIT license, see LICENSE.txt file."
__version__ = "1.0.0a2"
__authors__ = "The AiiDA team."
__paper__ = """G. Pizzi, A. Cepellotti, R. Sabatini, N. Marzari, and B. Kozinsky, "AiiDA: automated interactive infrastructure and database for computational science", Comp. Mat. Sci 111, 218-230 (2016); http://dx.doi.org/10.1016/j.commatsci.2015.09.013 - http://www.aiida.net."""
__paper_short__ = """G. Pizzi et al., Comp. Mat. Sci 111, 218 (2016)."""
# Configure the default logging
configure_logging()
if get_property("warnings.showdeprecations"):
# print out the warnings coming from deprecation
# in Python 2.7 it is suppressed by default
warnings.simplefilter('default', DeprecationWarning)
def try_load_dbenv(*argc, **argv):
"""
Run `load_dbenv` unless the dbenv has already been loaded.
"""
if not is_dbenv_loaded():
load_dbenv(*argc, **argv)
return True
return False
def run_tests(self, *args):
import unittest
from aiida.common.setup import get_property
from aiida.backends import settings
from aiida.backends.djsite.settings import settings_profile
db_test_list = []
test_folders = []
do_db = False
if args:
for arg in args:
if arg in self.allowed_test_folders:
dbtests = self.allowed_test_folders[arg]
# Anything that has been added is a DB test
if dbtests is not None:
do_db = True
for dbtest in dbtests:
db_test_list.append(dbtest)
else:
test_folders.append(arg)
else:
print >> sys.stderr, (
"{} is not a valid test. "
"Allowed test folders are:".format(arg))
print >> sys.stderr, "\n".join(
' * {}'.format(a)
for a in sorted(self.allowed_test_folders.keys()))
sys.exit(1)
else:
# Without arguments, run all tests
do_db = True
for k, v in self.allowed_test_folders.iteritems():
if v is None:
# Non-db tests
test_folders.append(k)
else:
# DB test
for dbtest in v:
db_test_list.append(dbtest)
for test_folder in test_folders:
print "v" * 75
print ">>> Tests for module {} <<<".format(test_folder.ljust(50))
print "^" * 75
testsuite = unittest.defaultTestLoader.discover(
test_folder, top_level_dir=os.path.dirname(aiida.__file__))
test_runner = unittest.TextTestRunner()
test_runner.run(testsuite)
if do_db:
# As a first thing, I want to set the correct flags.
# This allow to work on temporary DBs and a temporary repository.
## Setup a sqlite3 DB for tests (WAY faster, since it remains in-memory
## and not on disk.
# if you define such a variable to False, it will use the same backend
# that you have already configured also for tests. Otherwise,
# Setup a sqlite3 DB for tests (WAY faster, since it remains in-memory)
# The prefix is then checked inside get_profile_config and stripped
# but it is needed to know if this is a test or not
if get_property('tests.use_sqlite'):
profile_prefix = 'testsqlite_'
else:
profile_prefix = 'test_'
profile = "{}{}".format(
profile_prefix, settings.AIIDADB_PROFILE
if settings.AIIDADB_PROFILE is not None else 'default')
settings_profile.aiida_test_list = db_test_list
print "v" * 75
print(
">>> Tests for django db application "
" <<<")
print "^" * 75
pass_to_django_manage([execname, 'test', 'db'], profile=profile)
'datefmt': '%m/%d/%Y %I:%M:%S %p',
},
},
'handlers': {
'console': {
'level': 'DEBUG',
'class': 'logging.StreamHandler',
'formatter': 'halfverbose',
},
'dblogger': {
# get_property takes the property from the config json file
# The key used in the json, and the default value, are
# specified in the _property_table inside aiida.common.setup
# NOTE: To modify properties, use the 'verdi devel setproperty'
# command and similar ones (getproperty, describeproperties, ...)
'level': get_property('logging.db_loglevel'),
'class': 'aiida.utils.logger.DBLogHandler',
},
},
'loggers': {
'aiida': {
'handlers': ['console', 'dblogger'],
'level': get_property('logging.aiida_loglevel'),
'propagate': False,
},
'paramiko': {
'handlers': ['console'],
'level': get_property('logging.paramiko_loglevel'),
'propagate': False,
},
},
def deposit(what,
type,
author_name=None,
author_email=None,
url=None,
title=None,
username=None,
password=False,
user_email=None,
code_label=default_options['code'],
computer_name=None,
replace=None,
message=None,
**kwargs):
"""
Launches a
:py:class:`aiida.orm.implementation.general.calculation.job.AbstractJobCalculation`
to deposit data node to \*COD-type database.
:return: launched :py:class:`aiida.orm.implementation.general.calculation.job.AbstractJobCalculation`
instance.
:raises ValueError: if any of the required parameters are not given.
"""
from aiida.common.setup import get_property
parameters = {}
if not what:
raise ValueError("Node to be deposited is not supplied")
if not type:
raise ValueError("Deposition type is not supplied. Should be "
"one of the following: 'published', "
"'prepublication' or 'personal'")
if not username:
username = get_property('tcod.depositor_username')
if not username:
raise ValueError("Depositor username is not supplied")
if not password:
parameters['password'] = get_property('tcod.depositor_password')
if not parameters['password']:
raise ValueError("Depositor password is not supplied")
if not user_email:
user_email = get_property('tcod.depositor_email')
if not user_email:
raise ValueError("Depositor email is not supplied")
parameters['deposition-type'] = type
parameters['username'] = username
parameters['user_email'] = user_email
if type == 'published':
pass
elif type in ['prepublication', 'personal']:
if not author_name:
author_name = get_property('tcod.depositor_author_name')
if not author_name:
raise ValueError("Author name is not supplied")
if not author_email:
author_email = get_property('tcod.depositor_author_email')
if not author_email:
raise ValueError("Author email is not supplied")
if not title:
raise ValueError("Publication title is not supplied")
else:
raise ValueError("Unknown deposition type '{}' -- should be "
"one of the following: 'published', "
"'prepublication' or 'personal'".format(type))
if replace:
if str(int(replace)) != replace or int(replace) < 10000000 \
or int(replace) > 99999999:
raise ValueError("ID of the replaced structure ({}) does not "
"seem to be valid TCOD ID: must be in "
"range [10000000,99999999]".format(replace))
elif message:
raise ValueError("Message is given while the structure is not "
"redeposited -- log message is relevant to "
"redeposition only")
kwargs['additional_tags'] = {}
if title:
kwargs['additional_tags']['_publ_section_title'] = title
if author_name:
kwargs['additional_tags']['_publ_author_name'] = author_name
if replace:
kwargs['additional_tags']['_tcod_database_code'] = replace
kwargs['datablock_names'] = [replace]
cif = export_cifnode(what, store=True, **kwargs)
from aiida.orm.code import Code
from aiida.orm.computer import Computer
from aiida.orm.data.parameter import ParameterData
from aiida.common.exceptions import NotExistent
code = Code.get_from_string(code_label)
computer = None
if computer_name:
computer = Computer.get(computer_name)
calc = code.new_calc(computer=computer)
calc.set_resources({'num_machines': 1, 'num_mpiprocs_per_machine': 1})
if password:
import getpass
parameters['password'] = getpass.getpass("Password: ")
if author_name:
parameters['author_name'] = author_name
if author_email:
parameters['author_email'] = author_email
if url:
parameters['url'] = url
if replace:
parameters['replace'] = True
if message:
parameters['log-message'] = str(message)
pd = ParameterData(dict=parameters)
calc.use_cif(cif)
calc.use_parameters(pd)
calc.store_all()
calc.submit()
return calc
def calculation_list(self, *args):
"""
Return a list of calculations on screen.
"""
if not is_dbenv_loaded():
load_dbenv()
from aiida.common.datastructures import calc_states
import argparse
from aiida.orm.calculation.job import JobCalculation as C
from aiida.common.setup import get_property
parser = argparse.ArgumentParser(
prog=self.get_full_command_name(),
description='List AiiDA calculations.')
# The default states are those that are shown if no option is given
parser.add_argument('-s', '--states', nargs='+', type=str,
help="show only the AiiDA calculations with given state",
default=[calc_states.WITHSCHEDULER,
calc_states.NEW,
calc_states.TOSUBMIT,
calc_states.SUBMITTING,
calc_states.COMPUTED,
calc_states.RETRIEVING,
calc_states.PARSING,
])
parser.add_argument('-p', '--past-days', metavar='N',
help="add a filter to show only calculations created in the past N days",
action='store', type=int)
parser.add_argument('-g', '--group', '--group-name',
metavar='GROUPNAME',
help="add a filter to show only calculations within a given group",
action='store', type=str)
parser.add_argument('-G', '--group-pk', metavar='GROUPPK',
help="add a filter to show only calculations within a given group",
action='store', type=int)
parser.add_argument('pks', type=int, nargs='*',
help="a list of calculations to show. If empty, all running calculations are shown. If non-empty, ignores the -p and -r options.")
parser.add_argument('-a', '--all-states',
dest='all_states', action='store_true',
help="Overwrite manual set of states if present, and look for calculations in every possible state")
parser.set_defaults(all_states=False)
parser.add_argument('-A', '--all-users',
dest='all_users', action='store_true',
help="Show calculations for all users, rather than only for the current user")
parser.set_defaults(all_users=False)
parser.add_argument('-t', '--absolute-time',
dest='relative_ctime', action='store_false', default=True,
help="Print the absolute creation time, rather than the relative creation time")
parser.add_argument('-l', '--limit',
type=int, default=None,
help='set a limit to the number of rows returned')
parser.add_argument('-o', '--order-by',
choices=['id', 'ctime'],
default='ctime',
help='order the results')
parser.add_argument('--project',
choices=(
'pk', 'state', 'ctime', 'sched', 'computer',
'type', 'description', 'label', 'uuid',
'mtime', 'user'
),
nargs='+',
default=get_property("verdishell.calculation_list"),
#('pk', 'ctime', 'state', 'sched', 'computer', 'type', 'label'),
help="Define the list of properties to show"
)
args = list(args)
parsed_args = parser.parse_args(args)
capital_states = [i.upper() for i in parsed_args.states]
parsed_args.states = capital_states
if parsed_args.all_states:
parsed_args.states = None
C._list_calculations(
states=parsed_args.states,
past_days=parsed_args.past_days,
pks=parsed_args.pks,
all_users=parsed_args.all_users,
group=parsed_args.group,
group_pk=parsed_args.group_pk,
relative_ctime=parsed_args.relative_ctime,
# with_scheduler_state=parsed_args.with_scheduler_state,
order_by=parsed_args.order_by,
limit=parsed_args.limit,
projections=parsed_args.project,
)
}
},
'handlers': {
'console': {
'level': 'DEBUG',
'class': 'logging.StreamHandler',
'formatter': 'halfverbose',
'filters': ['testing']
},
'dblogger': {
# setup.get_property takes the property from the config json file
# The key used in the json, and the default value, are
# specified in the _property_table inside aiida.common.setup
# NOTE: To modify properties, use the 'verdi devel setproperty'
# command and similar ones (getproperty, describeproperties, ...)
'level': setup.get_property('logging.db_loglevel'),
'class': 'aiida.common.log.DBLogHandler',
},
},
'loggers': {
'aiida': {
'handlers': ['console', 'dblogger'],
'level': setup.get_property('logging.aiida_loglevel'),
'propagate': False,
},
'paramiko': {
'handlers': ['console'],
'level': setup.get_property('logging.paramiko_loglevel'),
'propagate': False,
},
'alembic': {
def __init__(self, profile_name=None):
super(DaemonClient, self).__init__(profile_name)
self._SOCKET_DIRECTORY = None
self._DAEMON_TIMEOUT = get_property('daemon.timeout')
'level': 'ERROR',
'filters': ['require_debug_false'],
'class': 'django.utils.log.AdminEmailHandler'
},
'console': {
'level': 'DEBUG',
'class': 'logging.StreamHandler',
'formatter': 'halfverbose',
},
'dblogger': {
# get_property takes the property from the config json file
# The key used in the json, and the default value, are
# specified in the _property_table inside aiida.common.setup
# NOTE: To modify properties, use the 'verdi devel setproperty'
# command and similar ones (getproperty, describeproperties, ...)
'level': get_property('logging.db_loglevel'),
'class': 'aiida.backends.djsite.utils.DBLogHandler',
},
},
'loggers': {
'django.request': {
'handlers': ['mail_admins'],
'level': 'ERROR',
'propagate': True,
},
'aiida': {
'handlers': ['console', 'dblogger'],
'level': get_property('logging.aiida_loglevel'),
'propagate': False,
},
# ~ 'celery': {
# #
# The code is hosted on GitHub at https://github.com/aiidateam/aiida_core #
# For further information on the license, see the LICENSE.txt file #
# For further information please visit http://www.aiida.net #
###########################################################################
"""`verdi calculation` commands."""
import os
import click
from aiida.cmdline.commands.cmd_verdi import verdi
from aiida.cmdline.params import arguments, options, types
from aiida.cmdline.utils import decorators, echo
from aiida.common.setup import get_property
LIST_CMDLINE_PROJECT_DEFAULT = get_property('verdishell.calculation_list')
LIST_CMDLINE_PROJECT_CHOICES = ('pk', 'state', 'ctime', 'job_state',
'calculation_state', 'scheduler_state',
'computer', 'type', 'description', 'label',
'uuid', 'mtime', 'user', 'sealed')
@verdi.group('calculation')
def verdi_calculation():
"""Inspect and manage calculations."""
pass
@verdi_calculation.command('gotocomputer')
@arguments.CALCULATION(
type=types.CalculationParamType(sub_classes=('aiida.calculations:job',
def setUp(self):
self.init_alemb_log_level = get_property('logging.alembic_loglevel')
set_property('logging.alembic_loglevel',
logging.getLevelName(logging.ERROR))
self.migrate_db_with_non_testing_migrations("base")
