def __init__(self, calculation):
"""Initialize the instance of YamboParser"""
from aiida.common import AIIDA_LOGGER
self._logger = AIIDA_LOGGER.getChild('parser').getChild(
self.__class__.__name__)
# check for valid input
if calculation.process_type == 'aiida.calculations:yambo.yambo':
yambo_parent = True
else:
raise OutputParsingError(
"Input calculation must be a YamboCalculation, not {}".format(
calculation.process_type))
self._calc = calculation
self.last_job_info = self._calc.get_last_job_info()
self._eels_array_linkname = 'array_eels'
self._eps_array_linkname = 'array_eps'
self._alpha_array_linkname = 'array_alpha'
self._qp_array_linkname = 'array_qp'
self._ndb_linkname = 'array_ndb'
self._ndb_QP_linkname = 'array_ndb_QP'
self._ndb_HF_linkname = 'array_ndb_HFlocXC'
self._lifetime_bands_linkname = 'bands_lifetime'
self._quasiparticle_bands_linkname = 'bands_quasiparticle'
self._parameter_linkname = 'output_parameters'
self._system_info_linkname = 'system_info'
super(YamboParser, self).__init__(calculation)
def __init__(self, **kwargs): # pylint: disable=unused-argument
super(BaseFileParser, self).__init__()
self._logger = aiidalogger.getChild(self.__class__.__name__)
self._exit_code = None
self._parsable_items = self.PARSABLE_ITEMS
self._parsed_data = {}
if 'file_path' in kwargs:
self._data_obj = SingleFile(path=kwargs['file_path'])
elif 'data' in kwargs:
self._data_obj = SingleFile(data=kwargs['data'])
else:
self._data_obj = None
def __init__(self, *args, **kwargs): # pylint: disable=unused-argument
"""
__init__ method of the Transport base class.
"""
from aiida.common import AIIDA_LOGGER
self._safe_open_interval = kwargs.pop('safe_interval',
self._DEFAULT_SAFE_OPEN_INTERVAL)
self._logger = AIIDA_LOGGER.getChild('transport').getChild(
self.__class__.__name__)
self._logger_extra = None
self._is_open = False
self._enters = 0
def __init__(self, calc_parser_cls=None, **kwargs): # pylint: disable=unused-argument
super(BaseFileParser, self).__init__()
self._logger = aiidalogger.getChild(self.__class__.__name__)
self._vasp_parser = calc_parser_cls
self.settings = None
if calc_parser_cls is not None:
calc_parser_cls.get_quantity.append(self.get_quantity)
self.settings = calc_parser_cls.settings
self.parsable_items = {}
self._parsed_data = {}
self._data_obj = None
def __init__(self, *args, **kwargs): # pylint: disable=unused-argument
"""
__init__ method of the Transport base class.
:param safe_interval: (optional, default self._DEFAULT_SAFE_OPEN_INTERVAL)
Minimum time interval in seconds between opening new connections.
:param use_login_shell: (optional, default True)
if False, do not use a login shell when executing command
"""
from aiida.common import AIIDA_LOGGER
self._safe_open_interval = kwargs.pop('safe_interval',
self._DEFAULT_SAFE_OPEN_INTERVAL)
self._use_login_shell = kwargs.pop('use_login_shell', True)
if self._use_login_shell:
self._bash_command_str = 'bash -l '
else:
self._bash_command_str = 'bash '
self._logger = AIIDA_LOGGER.getChild('transport').getChild(
self.__class__.__name__)
self._logger_extra = None
self._is_open = False
self._enters = 0
import os
from six.moves import zip
from aiida.common import AIIDA_LOGGER, exceptions
from aiida.common.datastructures import CalcJobState
from aiida.common.folders import SandboxFolder
from aiida.common.links import LinkType
from aiida.orm import FolderData
from aiida.orm.utils.log import get_dblogger_extra
from aiida.plugins import DataFactory
from aiida.schedulers.datastructures import JobState
REMOTE_WORK_DIRECTORY_LOST_FOUND = 'lost+found'
execlogger = AIIDA_LOGGER.getChild('execmanager')
def upload_calculation(node,
transport,
calc_info,
script_filename,
dry_run=False):
"""Upload a `CalcJob` instance
:param node: the `CalcJobNode`.
:param transport: an already opened transport to use to submit the calculation.
:param calc_info: the calculation info datastructure returned by `CalcJobNode.presubmit`
:param script_filename: the job launch script returned by `CalcJobNode.presubmit`
:return: tuple of ``calc_info`` and ``script_filename``
"""
# For further information please visit http://www.aiida.net #
###########################################################################
"""Data structures used by `Scheduler` instances.
In particular, there is the definition of possible job states (job_states),
the data structure to be filled for job submission (JobTemplate), and
the data structure that is returned when querying for jobs in the scheduler
(JobInfo).
"""
import abc
import enum
from aiida.common import AIIDA_LOGGER
from aiida.common.extendeddicts import AttributeDict, DefaultFieldsAttributeDict
SCHEDULER_LOGGER = AIIDA_LOGGER.getChild('scheduler')
__all__ = (
'JobState', 'JobResource', 'JobTemplate', 'JobInfo', 'NodeNumberJobResource', 'ParEnvJobResource', 'MachineInfo'
)
class JobState(enum.Enum):
"""Enumeration of possible scheduler states of a CalcJob.
There is no FAILED state as every completed job is put in DONE, regardless of success.
"""
UNDETERMINED = 'undetermined'
QUEUED = 'queued'
QUEUED_HELD = 'queued held'
def __init__(self):
self._cache = {}
self._logger = AIIDA_LOGGER.getChild('plugin_version_provider')
from tempfile import NamedTemporaryFile
from typing import Any, List, Optional, Mapping as MappingType, Tuple, Union
from aiida.common import AIIDA_LOGGER, exceptions
from aiida.common.datastructures import CalcInfo
from aiida.common.folders import SandboxFolder
from aiida.common.links import LinkType
from aiida.orm import load_node, CalcJobNode, Code, FolderData, Node, RemoteData
from aiida.orm.utils.log import get_dblogger_extra
from aiida.plugins import DataFactory
from aiida.schedulers.datastructures import JobState
from aiida.transports import Transport
REMOTE_WORK_DIRECTORY_LOST_FOUND = 'lost+found'
EXEC_LOGGER = AIIDA_LOGGER.getChild('execmanager')
def _find_data_node(inputs: MappingType[str, Any],
uuid: str) -> Optional[Node]:
"""Find and return the node with the given UUID from a nested mapping of input nodes.
:param inputs: (nested) mapping of nodes
:param uuid: UUID of the node to find
:return: instance of `Node` or `None` if not found
"""
data_node = None
for input_node in inputs.values():
if isinstance(input_node, Mapping):
data_node = _find_data_node(input_node, uuid)