def get_valid_transports(cls):
"""
:return: a list of existing plugin names
"""
from aiida.common.pluginloader import existing_plugins
return existing_plugins(Transport, "aiida.transport.plugins")
def test_existing_workflows(self):
"""Test listing all preinstalled workflows"""
from aiida.orm import Workflow
work = pl.existing_plugins(Workflow, 'aiida.workflows')
self.assertIsInstance(work, list)
from aiida.orm import WorkflowFactory
for i in work:
self.assertTrue(issubclass(WorkflowFactory(i), Workflow))
def test_existing_data(self):
"""Test listing all preinstalled data formats"""
from aiida.orm.data import Data
data = pl.existing_plugins(Data, 'aiida.orm.data')
self.assertIsInstance(data, list)
from aiida.orm import DataFactory
for i in data:
self.assertTrue(issubclass(DataFactory(i), Data))
def test_existing_parsers(self):
"""Test listing all preinstalled parsers"""
from aiida.parsers import Parser
pars = pl.existing_plugins(Parser, 'aiida.parsers.plugins')
self.assertIsInstance(pars, list)
from aiida.parsers import ParserFactory
for i in pars:
self.assertTrue(issubclass(ParserFactory(i), Parser))
def test_existing_calculations(self):
"""Test listing all preinstalled calculations """
from aiida.orm.calculation.job import JobCalculation
calcs = pl.existing_plugins(JobCalculation,
'aiida.orm.calculation.job',
suffix='Calculation')
self.assertIsInstance(calcs, list)
from aiida.orm import CalculationFactory
for i in calcs:
self.assertTrue(issubclass(CalculationFactory(i), JobCalculation))
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 existing_plugins
from aiida.orm.calculation.job import JobCalculation
plugins = sorted(existing_plugins(JobCalculation,
'aiida.orm.calculation.job',
suffix='Calculation'))
# 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 existing_plugins
if input_plugin is None:
return
if input_plugin not in existing_plugins(JobCalculation,
'aiida.orm.calculation.job',
suffix='Calculation'):
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 existing_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():
print " {}: {}".format(key,
val['valid_types'].__name__)
except MissingPluginError:
print "! {}: NOT FOUND!".format(arg)
else:
plugins = sorted(
existing_plugins(JobCalculation,
'aiida.orm.calculation.job',
suffix='Calculation'))
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 get_valid_schedulers(cls):
from aiida.common.pluginloader import existing_plugins
return existing_plugins(Scheduler, "aiida.scheduler.plugins")
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.
"""
import os, json
tags = { '_audit_creation_method': "AiiDA version {}".format(__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 = 0
fn = 0
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:
if cif_encode_contents(step['stdout'])[1] is not None:
raise ValueError("Standard output of computation step {} "
"can not be stored in a CIF file: "
"encoding is required, but not currently "
"supported".format(sn))
tags['_tcod_computation_stdout'].append(step['stdout'])
else:
tags['_tcod_computation_stdout'].append('')
if 'stderr' in step and step['stderr'] is not None:
if cif_encode_contents(step['stderr'])[1] is not None:
raise ValueError("Standard error of computation step {} "
"can not be stored in a CIF file: "
"encoding is required, but not currently "
"supported".format(sn))
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)
# 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]
# Collecting code-specific data
from aiida.common.pluginloader import BaseFactory, existing_plugins
from aiida.tools.dbexporters.tcod_plugins import BaseTcodtranslator
plugin_path = "aiida.tools.dbexporters.tcod_plugins"
plugins = list()
if calc is not None:
for plugin in existing_plugins(BaseTcodtranslator, plugin_path):
cls = BaseFactory(plugin, BaseTcodtranslator, plugin_path)
if calc._plugin_type_string.endswith(cls._plugin_type_string + '.'):
plugins.append(cls)
from aiida.common.exceptions import MultipleObjectsError
if len(plugins) > 1:
raise MultipleObjectsError("more than one plugin found for "
"{}".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
def test_existing_tcod_plugins(self):
"""Test listing all preinstalled tcod exporter plugins"""
from aiida.tools.dbexporters.tcod_plugins import BaseTcodtranslator
tcpl = pl.existing_plugins(BaseTcodtranslator,
'aiida.tools.dbexporters.tcod_plugins')
self.assertIsInstance(tcpl, list)
def test_existing_transports(self):
"""Test listing all preinstalled transports"""
from aiida.transport import Transport
tran = pl.existing_plugins(Transport, 'aiida.transport.plugins')
self.assertIsInstance(tran, list)
def test_existing_schedulers(self):
"""Test listing all preinstalled schedulers"""
from aiida.scheduler import Scheduler
sche = pl.existing_plugins(Scheduler, 'aiida.scheduler.plugins')
self.assertIsInstance(sche, list)