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