def get_valid_transports(cls):
"""
:return: a list of existing plugin names
"""
from aiida.common.pluginloader import all_plugins
return all_plugins('transports')
def test_existing_workflows(self):
"""
Test listing all preinstalled workflows
"""
workflows = all_plugins('workflows')
self.assertIsInstance(workflows, list)
for i in workflows:
self.assertTrue(issubclass(WorkflowFactory(i), Workflow))
def test_existing_transports(self):
"""
Test listing all preinstalled transports
"""
transports = all_plugins('transports')
self.assertIsInstance(transports, list)
for i in transports:
self.assertTrue(issubclass(TransportFactory(i), Transport))
def test_existing_schedulers(self):
"""
Test listing all preinstalled schedulers
"""
schedulers = all_plugins('schedulers')
self.assertIsInstance(schedulers, list)
for i in schedulers:
self.assertTrue(issubclass(SchedulerFactory(i), Scheduler))
def test_existing_data(self):
"""
Test listing all preinstalled data formats
"""
data = all_plugins('data')
self.assertIsInstance(data, list)
for i in data:
self.assertTrue(issubclass(DataFactory(i), Data))
def test_existing_data(self):
"""
Test listing all preinstalled data classes
"""
data = all_plugins('data')
self.assertIsInstance(data, list)
for i in data:
cls = DataFactory(i)
self.assertTrue(
issubclass(cls, Data),
'Data plugin class {} is not subclass of {}'.format(cls, Data))
def test_existing_calculations(self):
"""
Test listing all preinstalled calculations
"""
calculations = all_plugins('calculations')
self.assertIsInstance(calculations, list)
for i in calculations:
self.assertTrue(
issubclass(CalculationFactory(i), JobCalculation),
'Calculation plugin class {} is not subclass of JobCalculation'.format(
CalculationFactory(i)))
def test_existing_schedulers(self):
"""
Test listing all preinstalled schedulers
"""
schedulers = all_plugins('schedulers')
self.assertIsInstance(schedulers, list)
for i in schedulers:
cls = SchedulerFactory(i)
self.assertTrue(
issubclass(cls, Scheduler),
'Scheduler plugin class {} is not subclass of {}'.format(
cls, Scheduler))
def test_existing_parsers(self):
"""
Test listing all preinstalled parsers
"""
parsers = all_plugins('parsers')
self.assertIsInstance(parsers, list)
for i in parsers:
cls = ParserFactory(i)
self.assertTrue(
issubclass(cls, Parser),
'Parser plugin class {} is not subclass of {}'.format(
cls, Parser))
def test_existing_tcod_plugins(self):
"""
Test listing all preinstalled tcod exporter plugins
"""
tcod_plugins = all_plugins('tools.dbexporters.tcod_plugins')
self.assertIsInstance(tcod_plugins, list)
for i in tcod_plugins:
cls = TcodExporterFactory(i)
self.assertTrue(
issubclass(cls, BaseTcodtranslator),
'TcodExporter plugin class {} is not subclass of {}'.format(
cls, BaseTcodtranslator))
def test_existing_workflows(self):
"""
Test listing all preinstalled workflows
"""
workflows = all_plugins('workflows')
self.assertIsInstance(workflows, list)
for i in workflows:
cls = WorkflowFactory(i)
self.assertTrue(
issubclass(cls, (Workflow, WorkChain)),
'Workflow plugin class {} is neither a subclass of {} nor {}'.
format(cls, Workflow, WorkChain))
def test_existing_transports(self):
"""
Test listing all preinstalled transports
"""
transports = all_plugins('transports')
self.assertIsInstance(transports, list)
for i in transports:
cls = TransportFactory(i)
self.assertTrue(
issubclass(cls, Transport),
'Transport plugin class {} is not subclass of {}'.format(
cls, Transport))
def complete_plugins(self, subargs_idx, subargs):
"""
Return the list of plugins of the JobCalculation subclass of Calculation
"""
if not is_dbenv_loaded():
load_dbenv()
from aiida.common.pluginloader import all_plugins
plugins = sorted(all_plugins('calculations'))
# Do not return plugins that are already on the command line
other_subargs = subargs[:subargs_idx] + subargs[subargs_idx + 1:]
return_plugins = [_ for _ in plugins if _ not in other_subargs]
# print >> sys.stderr, "*", subargs
return "\n".join(return_plugins)
def _input_plugin_validator(self, input_plugin):
"""
Validates the input_plugin, checking it is in the list of existing plugins.
"""
from aiida.common.exceptions import ValidationError
from aiida.orm import JobCalculation
from aiida.common.pluginloader import all_plugins
if input_plugin is None:
return
if input_plugin not in all_plugins('calculations'):
raise ValidationError(
"Invalid value '{}' for the input_plugin "
"variable, it is not among the existing plugins".format(
str(input_plugin)))
def calculation_plugins(self, *args):
if not is_dbenv_loaded():
load_dbenv()
from aiida.orm import CalculationFactory
from aiida.orm.calculation.job import JobCalculation
from aiida.common.pluginloader import all_plugins
from aiida.common.exceptions import MissingPluginError
if args:
for arg in args:
try:
C = CalculationFactory(arg)
print "* {}".format(arg)
docstring = C.__doc__
if docstring is None:
docstring = "(No documentation available)"
docstring = docstring.strip()
print "\n".join([
" {}".format(_.strip())
for _ in docstring.splitlines()
])
print " Inputs:"
for key, val in C._use_methods.iteritems():
try:
print " {}: {}".format(
key, val['valid_types'].__name__)
except AttributeError:
print " {}: {}".format(
key, ", ".join(
[i.__name__ for i in val['valid_types']]))
print(" Module location: {}".format(C.__module__))
except MissingPluginError:
print "! {}: NOT FOUND!".format(arg)
else:
plugins = sorted(all_plugins('calculations'))
if plugins:
print(
"## Pass as a further parameter one (or more) "
"plugin names to get more details on a given plugin.")
for plugin in plugins:
print "* {}".format(plugin)
else:
print "## No calculation plugins found"
def test_installed(self):
"""
Return wether the plugin is installed
First, this checks wether the package_name can be imported.
If not, we know that at least no new style plugin with
that name is installed.
Secondly, tests wether all the entry points are currently
found by the plugin loader. If not, it is considered not
installed.
potential failures:
* loading of the entry points is not tested
* not properly uninstalled plugins might show up as
installed if the entry points are still around.
* it does not distinguish between not installed and
an old version is installed
"""
from importlib import import_module
from pkg_resources import get_distribution
new_style = False
installed = True
iversion = None
try:
import_module(self.package_name)
new_style = True
iversion = get_distribution(self.package_name).version
except ImportError:
new_style = False
from aiida.common.pluginloader import all_plugins
if iversion == self.version or not new_style:
for cat, ep in self.entry_points.iteritems():
if not set(ep).issubset(set(all_plugins(cat))):
installed = False
return installed, new_style, iversion
def test_existing_tcod_plugins(self):
"""
Test listing all preinstalled tcod exporter plugins
"""
tcod_plugins = all_plugins('transports')
self.assertIsInstance(tcod_plugins, list)
def get_valid_schedulers(cls):
from aiida.common.pluginloader import all_plugins
return all_plugins('schedulers')
def _collect_tags(
node,
calc,
parameters=None,
dump_aiida_database=default_options['dump_aiida_database'],
exclude_external_contents=default_options['exclude_external_contents'],
gzip=default_options['gzip'],
gzip_threshold=default_options['gzip_threshold']):
"""
Retrieve metadata from attached calculation and pseudopotentials
and prepare it to be saved in TCOD CIF.
"""
from aiida.common.links import LinkType
import os, json
import aiida
tags = {
'_audit_creation_method': "AiiDA version {}".format(aiida.__version__)
}
# Recording the dictionaries (if any)
if len(conforming_dictionaries):
for postfix in ['name', 'version', 'location']:
key = '_audit_conform_dict_{}'.format(postfix)
if key not in tags:
tags[key] = []
for dictionary in conforming_dictionaries:
tags['_audit_conform_dict_name'].append(dictionary['name'])
tags['_audit_conform_dict_version'].append(dictionary['version'])
tags['_audit_conform_dict_location'].append(dictionary['url'])
# Collecting metadata from input files:
calc_data = []
if calc is not None:
calc_data = _collect_calculation_data(calc)
for tag in tcod_loops['_tcod_computation'] + tcod_loops['_tcod_file']:
tags[tag] = []
export_files = []
sn = 1
for step in calc_data:
tags['_tcod_computation_step'].append(sn)
tags['_tcod_computation_command'].append('cd {}; ./{}'.format(
sn, aiida_executable_name))
tags['_tcod_computation_reference_uuid'].append(step['uuid'])
if 'env' in step:
tags['_tcod_computation_environment'].append("\n".join(
["%s=%s" % (key, step['env'][key]) for key in step['env']]))
else:
tags['_tcod_computation_environment'].append('')
if 'stdout' in step and step['stdout'] is not None:
tags['_tcod_computation_stdout'].append(step['stdout'])
else:
tags['_tcod_computation_stdout'].append('')
if 'stderr' in step and step['stderr'] is not None:
tags['_tcod_computation_stderr'].append(step['stderr'])
else:
tags['_tcod_computation_stderr'].append('')
export_files.append({
'name': "{}{}".format(sn, os.sep),
'type': 'folder'
})
for f in step['files']:
f['name'] = os.path.join(str(sn), f['name'])
export_files.extend(step['files'])
sn = sn + 1
# Creating importable AiiDA database dump in CIF tags
if dump_aiida_database and node.is_stored:
import json
from aiida.common.exceptions import LicensingException
from aiida.common.folders import SandboxFolder
from aiida.orm.importexport import export_tree
with SandboxFolder() as folder:
try:
export_tree([node.dbnode],
folder=folder,
silent=True,
allowed_licenses=['CC0'])
except LicensingException as e:
raise LicensingException(e.message + \
". Only CC0 license is accepted.")
files = _collect_files(folder.abspath)
with open(folder.get_abs_path('data.json')) as f:
data = json.loads(f.read())
md5_to_url = {}
if exclude_external_contents:
for pk in data['node_attributes']:
n = data['node_attributes'][pk]
if 'md5' in n.keys() and 'source' in n.keys() and \
'uri' in n['source'].keys():
md5_to_url[n['md5']] = n['source']['uri']
for f in files:
f['name'] = os.path.join('aiida', f['name'])
if f['type'] == 'file' and f['md5'] in md5_to_url.keys():
f['uri'] = md5_to_url[f['md5']]
export_files.extend(files)
# Describing seen files in _tcod_file_* loop
encodings = list()
fn = 0
for f in export_files:
# ID and name
tags['_tcod_file_id'].append(fn)
tags['_tcod_file_name'].append(f['name'])
# Checksums
md5sum = None
sha1sum = None
if f['type'] == 'file':
md5sum = f['md5']
sha1sum = f['sha1']
else:
md5sum = '.'
sha1sum = '.'
tags['_tcod_file_md5sum'].append(md5sum)
tags['_tcod_file_sha1sum'].append(sha1sum)
# Content, encoding and URI
contents = '?'
encoding = None
if 'uri' in f.keys():
contents = '.'
tags['_tcod_file_URI'].append(f['uri'])
else:
tags['_tcod_file_URI'].append('?')
if f['type'] == 'file':
contents,encoding = \
cif_encode_contents(f['contents'],
gzip=gzip,
gzip_threshold=gzip_threshold)
else:
contents = '.'
if encoding is None:
encoding = '.'
elif encoding not in encodings:
encodings.append(encoding)
tags['_tcod_file_contents'].append(contents)
tags['_tcod_file_content_encoding'].append(encoding)
# Role
role = '?'
if 'role' in f.keys():
role = f['role']
tags['_tcod_file_role'].append(role)
fn = fn + 1
# Describing the encodings
if encodings:
for tag in tcod_loops['_tcod_content_encoding']:
tags[tag] = []
for encoding in encodings:
layers = encoding.split('+')
for i in range(0, len(layers)):
tags['_tcod_content_encoding_id'].append(encoding)
tags['_tcod_content_encoding_layer_id'].append(i + 1)
tags['_tcod_content_encoding_layer_type'].append(layers[i])
# Describing Brillouin zone (if used)
if calc is not None:
from aiida.orm.data.array.kpoints import KpointsData
kpoints_list = calc.get_inputs(KpointsData, link_type=LinkType.INPUT)
# TODO: stop if more than one KpointsData is used?
if len(kpoints_list) == 1:
kpoints = kpoints_list[0]
density, shift = kpoints.get_kpoints_mesh()
tags['_dft_BZ_integration_grid_X'] = density[0]
tags['_dft_BZ_integration_grid_Y'] = density[1]
tags['_dft_BZ_integration_grid_Z'] = density[2]
tags['_dft_BZ_integration_grid_shift_X'] = shift[0]
tags['_dft_BZ_integration_grid_shift_Y'] = shift[1]
tags['_dft_BZ_integration_grid_shift_Z'] = shift[2]
from aiida.common.exceptions import MultipleObjectsError
from aiida.common.pluginloader import all_plugins, get_plugin
category = 'tools.dbexporters.tcod_plugins'
plugins = list()
if calc is not None:
for entry_point in all_plugins(category):
plugin = get_plugin(category, entry_point)
if calc._plugin_type_string.endswith(plugin._plugin_type_string +
'.'):
plugins.append(plugin)
if len(plugins) > 1:
raise MultipleObjectsError('more than one plugin found for {}'.format(
calc._plugin_type_string))
if len(plugins) == 1:
plugin = plugins[0]
translated_tags = translate_calculation_specific_values(calc, plugin)
tags.update(translated_tags)
return tags
