aiida.orm

Package Contents

Classes

Functions

Data

API

aiida.orm.ASCENDING = 'asc'
class aiida.orm.AbstractCode(default_calc_job_plugin: str | None = None, append_text: str = '', prepend_text: str = '', use_double_quotes: bool = False, is_hidden: bool = False, **kwargs)

Bases: aiida.orm.nodes.data.data.Data

Initialization

_KEY_ATTRIBUTE_DEFAULT_CALC_JOB_PLUGIN: str = 'input_plugin'
_KEY_ATTRIBUTE_APPEND_TEXT: str = 'append_text'
_KEY_ATTRIBUTE_PREPEND_TEXT: str = 'prepend_text'
_KEY_ATTRIBUTE_USE_DOUBLE_QUOTES: str = 'use_double_quotes'
_KEY_EXTRA_IS_HIDDEN: str = 'hidden'
abstractmethod can_run_on_computer(computer: aiida.orm.Computer) bool
abstractmethod get_executable() pathlib.PurePosixPath
get_executable_cmdline_params(cmdline_params: list[str] | None = None) list
get_prepend_cmdline_params(mpi_args: list[str] | None = None, extra_mpirun_params: list[str] | None = None) list[str]
validate_working_directory(folder: aiida.common.folders.Folder)
abstract property full_label: str
property label: str
property default_calc_job_plugin: str | None
property append_text: str
property prepend_text: str
property use_double_quotes: bool
property is_hidden: bool
get_builder() aiida.engine.ProcessBuilder
static cli_validate_label_uniqueness(_, __, value)
classmethod get_cli_options() collections.OrderedDict
classmethod _get_cli_options() dict
class aiida.orm.AbstractNodeMeta

Bases: abc.ABCMeta

__new__(name, bases, namespace, **kwargs)
class aiida.orm.ArrayData(*args, source=None, **kwargs)

Bases: aiida.orm.nodes.data.data.Data

Initialization

array_prefix = 'array|'
_cached_arrays = None
initialize()
delete_array(name)
get_arraynames()
_arraynames_from_files()
_arraynames_from_properties()
get_shape(name)
get_iterarrays()
get_array(name)
clear_internal_cache()
set_array(name, array)
_validate()
_get_array_entries()
_prepare_json(main_file_name='', comments=True)
class aiida.orm.AttributeManager(node)

Initialization

__dir__()
__iter__()
_get_dict()
__getattr__(name)
__setattr__(name, value)
__getitem__(name)
class aiida.orm.AuthInfo(computer: aiida.orm.Computer, user: aiida.orm.User, backend: Optional[aiida.orm.implementation.StorageBackend] = None)

Bases: aiida.orm.entities.Entity[aiida.orm.implementation.BackendAuthInfo, aiida.orm.authinfos.AuthInfoCollection]

Initialization

_CLS_COLLECTION = None
PROPERTY_WORKDIR = 'workdir'
__str__() str
property enabled: bool
property computer: aiida.orm.Computer
property user: aiida.orm.User
get_auth_params() Dict[str, Any]
set_auth_params(auth_params: Dict[str, Any]) None
get_metadata() Dict[str, Any]
set_metadata(metadata: Dict[str, Any]) None
get_workdir() str
get_transport() aiida.transports.Transport
class aiida.orm.AutoGroup(label: Optional[str] = None, user: Optional[aiida.orm.User] = None, description: str = '', type_string: Optional[str] = None, backend: Optional[aiida.orm.implementation.StorageBackend] = None)

Bases: aiida.orm.groups.Group

Initialization

class aiida.orm.BandsData

Bases: aiida.orm.nodes.data.array.kpoints.KpointsData

set_kpointsdata(kpointsdata)
_validate_bands_occupations(bands, occupations=None, labels=None)
set_bands(bands, units=None, occupations=None, labels=None)
property array_labels
property units
_set_pbc(value)
get_bands(also_occupations=False, also_labels=False)
_get_bandplot_data(cartesian, prettify_format=None, join_symbol=None, get_segments=False, y_origin=0.0)
_prepare_agr_batch(main_file_name='', comments=True, prettify_format=None)
_prepare_dat_multicolumn(main_file_name='', comments=True)
_prepare_dat_blocks(main_file_name='', comments=True)
_matplotlib_get_dict(main_file_name='', comments=True, title='', legend=None, legend2=None, y_max_lim=None, y_min_lim=None, y_origin=0.0, prettify_format=None, **kwargs)
_prepare_mpl_singlefile(*args, **kwargs)
_prepare_mpl_withjson(main_file_name='', *args, **kwargs)
_prepare_mpl_pdf(main_file_name='', *args, **kwargs)
_prepare_mpl_png(main_file_name='', *args, **kwargs)
static _get_mpl_body_template(paths)
show_mpl(**kwargs)
_prepare_gnuplot(main_file_name=None, title='', comments=True, prettify_format=None, y_max_lim=None, y_min_lim=None, y_origin=0.0)
_prepare_agr(main_file_name='', comments=True, setnumber_offset=0, color_number=1, color_number2=2, legend='', title='', y_max_lim=None, y_min_lim=None, y_origin=0.0, prettify_format=None)
_get_band_segments(cartesian)
_prepare_json(main_file_name='', comments=True)
class aiida.orm.BaseType(value=None, **kwargs)

Bases: aiida.orm.nodes.data.data.Data

Initialization

property value
__str__()
__eq__(other)
new(value=None)
class aiida.orm.Bool

Bases: aiida.orm.nodes.data.base.BaseType

_type = None
__int__()
__bool__()
class aiida.orm.CalcFunctionNode

Bases: aiida.orm.utils.mixins.FunctionCalculationMixin, aiida.orm.nodes.process.calculation.calculation.CalculationNode

class aiida.orm.CalcJobNode

Bases: aiida.orm.nodes.process.calculation.calculation.CalculationNode

CALC_JOB_STATE_KEY = 'state'
IMMIGRATED_KEY = 'imported'
REMOTE_WORKDIR_KEY = 'remote_workdir'
RETRIEVE_LIST_KEY = 'retrieve_list'
RETRIEVE_TEMPORARY_LIST_KEY = 'retrieve_temporary_list'
SCHEDULER_JOB_ID_KEY = 'job_id'
SCHEDULER_STATE_KEY = 'scheduler_state'
SCHEDULER_LAST_CHECK_TIME_KEY = 'scheduler_lastchecktime'
SCHEDULER_LAST_JOB_INFO_KEY = 'last_job_info'
SCHEDULER_DETAILED_JOB_INFO_KEY = 'detailed_job_info'
_tools = None
property tools: aiida.tools.calculations.CalculationTools
_updatable_attributes() Tuple[str, ...]
_hash_ignored_attributes() Tuple[str, ...]
get_builder_restart() aiida.engine.processes.builder.ProcessBuilder
property is_imported: bool
get_option(name: str) Optional[Any]
set_option(name: str, value: Any) None
get_options() Dict[str, Any]
set_options(options: Dict[str, Any]) None
get_state() Optional[aiida.common.datastructures.CalcJobState]
set_state(state: aiida.common.datastructures.CalcJobState) None
delete_state() None
set_remote_workdir(remote_workdir: str) None
get_remote_workdir() Optional[str]
static _validate_retrieval_directive(directives: Sequence[Union[str, Tuple[str, str, str]]]) None
set_retrieve_list(retrieve_list: Sequence[Union[str, Tuple[str, str, str]]]) None
get_retrieve_list() Optional[Sequence[Union[str, Tuple[str, str, str]]]]
set_retrieve_temporary_list(retrieve_temporary_list: Sequence[Union[str, Tuple[str, str, str]]]) None
get_retrieve_temporary_list() Optional[Sequence[Union[str, Tuple[str, str, str]]]]
set_job_id(job_id: Union[int, str]) None
get_job_id() Optional[str]
set_scheduler_state(state: aiida.schedulers.datastructures.JobState) None
get_scheduler_state() Optional[aiida.schedulers.datastructures.JobState]
get_scheduler_lastchecktime() Optional[datetime.datetime]
set_detailed_job_info(detailed_job_info: Optional[dict]) None
get_detailed_job_info() Optional[dict]
set_last_job_info(last_job_info: aiida.schedulers.datastructures.JobInfo) None
get_last_job_info() Optional[aiida.schedulers.datastructures.JobInfo]
get_authinfo() aiida.orm.authinfos.AuthInfo
get_transport() aiida.transports.Transport
get_parser_class() Optional[Type[aiida.parsers.Parser]]
get_retrieved_node() Optional[aiida.orm.FolderData]
property res: aiida.orm.utils.calcjob.CalcJobResultManager
get_scheduler_stdout() Optional[AnyStr]
get_scheduler_stderr() Optional[AnyStr]
get_description() str
class aiida.orm.CalcJobResultManager(node)

Initialization

property node
_load_results()
get_results()
__dir__()
__iter__()
__getattr__(name)
__getitem__(name)
class aiida.orm.CalculationEntityLoader

Bases: aiida.orm.utils.loaders.OrmEntityLoader

orm_base_class()
classmethod _get_query_builder_label_identifier(identifier, classes, operator='==', project='*')
class aiida.orm.CalculationNode(backend: Optional[aiida.orm.implementation.StorageBackend] = None, user: Optional[aiida.orm.users.User] = None, computer: Optional[aiida.orm.computers.Computer] = None, **kwargs: Any)

Bases: aiida.orm.nodes.process.process.ProcessNode

Initialization

_storable = True
_cachable = True
_unstorable_message = 'storing for this node has been disabled'
property inputs: aiida.orm.utils.managers.NodeLinksManager
property outputs: aiida.orm.utils.managers.NodeLinksManager
class aiida.orm.CifData(ase=None, file=None, filename=None, values=None, scan_type=None, parse_policy=None, **kwargs)

Bases: aiida.orm.nodes.data.singlefile.SinglefileData

Initialization

_SET_INCOMPATIBILITIES = [('ase', 'file'), ('ase', 'values'), ('file', 'values')]
_SCAN_TYPES = ('standard', 'flex')
_SCAN_TYPE_DEFAULT = 'standard'
_PARSE_POLICIES = ('eager', 'lazy')
_PARSE_POLICY_DEFAULT = 'eager'
_values = None
_ase = None
static read_cif(fileobj, index=-1, **kwargs)
classmethod from_md5(md5, backend=None)
classmethod get_or_create(filename, use_first=False, store_cif=True)
property ase
get_ase(**kwargs)
set_ase(aseatoms)
property values
set_values(values)
parse(scan_type=None)
store(*args, **kwargs)
set_file(file, filename=None)
set_scan_type(scan_type)
set_parse_policy(parse_policy)
get_formulae(mode='sum', custom_tags=None)
get_spacegroup_numbers()
property has_partial_occupancies
property has_attached_hydrogens
property has_undefined_atomic_sites
property has_atomic_sites
property has_unknown_species
generate_md5()
get_structure(converter='pymatgen', store=False, **kwargs)
_prepare_cif(**kwargs)
_get_object_ase()
_get_object_pycifrw()
_validate()
class aiida.orm.Code(remote_computer_exec=None, local_executable=None, input_plugin_name=None, files=None, **kwargs)

Bases: aiida.orm.nodes.data.code.abstract.AbstractCode

Initialization

HIDDEN_KEY = 'hidden'
can_run_on_computer(computer: aiida.orm.Computer) bool
get_executable() pathlib.PurePosixPath
hide()
reveal()
property hidden
set_files(files)
__str__()
get_computer_label()
property full_label
relabel(new_label)
get_description()
classmethod get_code_helper(label, machinename=None, backend=None)
classmethod get(pk=None, label=None, machinename=None)
classmethod get_from_string(code_string)
classmethod list_for_plugin(plugin, labels=True, backend=None)
_validate()
validate_remote_exec_path()
set_prepend_text(code)
get_prepend_text()
set_input_plugin_name(input_plugin)
get_input_plugin_name()
set_use_double_quotes(use_double_quotes: bool)
get_use_double_quotes() bool
set_append_text(code)
get_append_text()
set_local_executable(exec_name)
get_local_executable()
set_remote_computer_exec(remote_computer_exec)
get_remote_exec_path()
get_remote_computer()
_set_local()
_set_remote()
is_local()
can_run_on(computer)
get_execname()
class aiida.orm.CodeEntityLoader

Bases: aiida.orm.utils.loaders.OrmEntityLoader

orm_base_class()
classmethod _get_query_builder_label_identifier(identifier, classes, operator='==', project='*')
class aiida.orm.Collection(entity_class: Type[aiida.orm.entities.EntityType], backend: Optional[aiida.orm.implementation.StorageBackend] = None)

Bases: abc.ABC, typing.Generic[aiida.orm.entities.EntityType]

Initialization

abstractmethod static _entity_base_cls() Type[aiida.orm.entities.EntityType]
classmethod get_cached(entity_class: Type[aiida.orm.entities.EntityType], backend: aiida.orm.implementation.StorageBackend)
__call__(backend: aiida.orm.implementation.StorageBackend) aiida.orm.entities.CollectionType
property entity_type: Type[aiida.orm.entities.EntityType]
property backend: aiida.orm.implementation.StorageBackend
query(filters: Optional[aiida.orm.querybuilder.FilterType] = None, order_by: Optional[aiida.orm.querybuilder.OrderByType] = None, limit: Optional[int] = None, offset: Optional[int] = None) aiida.orm.querybuilder.QueryBuilder
get(**filters: Any) aiida.orm.entities.EntityType
find(filters: Optional[aiida.orm.querybuilder.FilterType] = None, order_by: Optional[aiida.orm.querybuilder.OrderByType] = None, limit: Optional[int] = None) List[aiida.orm.entities.EntityType]
all() List[aiida.orm.entities.EntityType]
count(filters: Optional[aiida.orm.querybuilder.FilterType] = None) int
class aiida.orm.Comment(node: aiida.orm.Node, user: aiida.orm.User, content: Optional[str] = None, backend: Optional[aiida.orm.implementation.StorageBackend] = None)

Bases: aiida.orm.entities.Entity[aiida.orm.implementation.BackendComment, aiida.orm.comments.CommentCollection]

Initialization

_CLS_COLLECTION = None
__str__() str
property uuid: str
property ctime: datetime.datetime
property mtime: datetime.datetime
set_mtime(value: datetime.datetime) None
property node: aiida.orm.Node
property user: aiida.orm.User
set_user(value: aiida.orm.User) None
property content: str
set_content(value: str) None
class aiida.orm.Computer(label: Optional[str] = None, hostname: str = '', description: str = '', transport_type: str = '', scheduler_type: str = '', workdir: Optional[str] = None, backend: Optional[aiida.orm.implementation.StorageBackend] = None)

Bases: aiida.orm.entities.Entity[aiida.orm.implementation.BackendComputer, aiida.orm.computers.ComputerCollection]

Initialization

_logger = None
PROPERTY_MINIMUM_SCHEDULER_POLL_INTERVAL = 'minimum_scheduler_poll_interval'
PROPERTY_MINIMUM_SCHEDULER_POLL_INTERVAL__DEFAULT = 10.0
PROPERTY_WORKDIR = 'workdir'
PROPERTY_SHEBANG = 'shebang'
_CLS_COLLECTION = None
__repr__()
__str__()
property uuid: str
property logger: logging.Logger
classmethod _label_validator(label: str) None
classmethod _hostname_validator(hostname: str) None
classmethod _description_validator(description: str) None
classmethod _transport_type_validator(transport_type: str) None
classmethod _scheduler_type_validator(scheduler_type: str) None
classmethod _prepend_text_validator(prepend_text: str) None
classmethod _append_text_validator(append_text: str) None
classmethod _workdir_validator(workdir: str) None
_mpirun_command_validator(mpirun_cmd: Union[List[str], Tuple[str, ...]]) None
validate() None
classmethod _default_mpiprocs_per_machine_validator(def_cpus_per_machine: Optional[int]) None
classmethod default_memory_per_machine_validator(def_memory_per_machine: Optional[int]) None
copy() aiida.orm.computers.Computer
store() aiida.orm.computers.Computer
property label: str
property description: str
property hostname: str
property scheduler_type: str
property transport_type: str
property metadata: Dict[str, Any]
delete_property(name: str, raise_exception: bool = True) None
set_property(name: str, value: Any) None
get_property(name: str, *args: Any) Any
get_prepend_text() str
set_prepend_text(val: str) None
get_append_text() str
set_append_text(val: str) None
get_use_double_quotes() bool
set_use_double_quotes(val: bool) None
get_mpirun_command() List[str]
set_mpirun_command(val: Union[List[str], Tuple[str, ...]]) None
get_default_mpiprocs_per_machine() Optional[int]
set_default_mpiprocs_per_machine(def_cpus_per_machine: Optional[int]) None
get_default_memory_per_machine() Optional[int]
set_default_memory_per_machine(def_memory_per_machine: Optional[int]) None
get_minimum_job_poll_interval() float
set_minimum_job_poll_interval(interval: float) None
get_workdir() str
set_workdir(val: str) None
get_shebang() str
set_shebang(val: str) None
get_authinfo(user: aiida.orm.User) aiida.orm.AuthInfo
property is_configured: bool
is_user_configured(user: aiida.orm.User) bool
is_user_enabled(user: aiida.orm.User) bool
get_transport(user: Optional[aiida.orm.User] = None) aiida.transports.Transport
get_transport_class() Type[aiida.transports.Transport]
get_scheduler() aiida.schedulers.Scheduler
configure(user: Optional[aiida.orm.User] = None, **kwargs: Any) aiida.orm.AuthInfo
get_configuration(user: Optional[aiida.orm.User] = None) Dict[str, Any]
class aiida.orm.ComputerEntityLoader

Bases: aiida.orm.utils.loaders.OrmEntityLoader

orm_base_class()
classmethod _get_query_builder_label_identifier(identifier, classes, operator='==', project='*')
class aiida.orm.ContainerizedCode(engine_command: str, image_name: str, **kwargs)

Bases: aiida.orm.nodes.data.code.installed.InstalledCode

Initialization

_KEY_ATTRIBUTE_ENGINE_COMMAND: str = 'engine_command'
_KEY_ATTRIBUTE_IMAGE_NAME: str = 'image_name'
property filepath_executable: pathlib.PurePosixPath
property engine_command: str
property image_name: str
get_prepend_cmdline_params(mpi_args: list[str] | None = None, extra_mpirun_params: list[str] | None = None) list[str]
classmethod _get_cli_options() dict
aiida.orm.DESCENDING = 'desc'
class aiida.orm.Data(*args, source=None, **kwargs)

Bases: aiida.orm.nodes.node.Node

Initialization

_source_attributes = ['db_name', 'db_uri', 'uri', 'id', 'version', 'extras', 'source_md5', 'description', 'license']
_export_format_replacements: Dict[str, str] = None
_storable = True
_unstorable_message = 'storing for this node has been disabled'
__copy__()
__deepcopy__(memo)
clone()
property source
set_source(source)
property creator
_exportcontent(fileformat, main_file_name='', **kwargs)
export(path, fileformat=None, overwrite=False, **kwargs)
_get_exporters()
classmethod get_export_formats()
importstring(inputstring, fileformat, **kwargs)
importfile(fname, fileformat=None)
_get_importers()
convert(object_format=None, *args)
_get_converters()
class aiida.orm.Dict(value=None, **kwargs)

Bases: aiida.orm.nodes.data.data.Data

Initialization

__getitem__(key)
__setitem__(key, value)
__eq__(other)
__contains__(key: str) bool
set_dict(dictionary)
update_dict(dictionary)
get_dict()
keys()
items()
property dict
class aiida.orm.Entity(backend_entity: aiida.orm.entities.BackendEntityType)

Bases: abc.ABC, typing.Generic[aiida.orm.entities.BackendEntityType, aiida.orm.entities.CollectionType]

Initialization

_CLS_COLLECTION: Type[aiida.orm.entities.CollectionType] = None
objects() aiida.orm.entities.CollectionType
collection() aiida.orm.entities.CollectionType
classmethod get(**kwargs)
classmethod from_backend_entity(backend_entity: aiida.orm.entities.BackendEntityType) aiida.orm.entities.EntityType
__getstate__()
initialize() None
property id: int
property pk: int
store() aiida.orm.entities.EntityType
property is_stored: bool
property backend: aiida.orm.implementation.StorageBackend
property backend_entity: aiida.orm.entities.BackendEntityType
class aiida.orm.EntityExtras(entity: Union[aiida.orm.nodes.node.Node, aiida.orm.groups.Group])

Initialization

__contains__(key: str) bool
property all: Dict[str, Any]
get(key: str, default: Any = _NO_DEFAULT) Any
get_many(keys: List[str]) List[Any]
set(key: str, value: Any) None
set_many(extras: Dict[str, Any]) None
reset(extras: Dict[str, Any]) None
delete(key: str) None
delete_many(keys: List[str]) None
clear() None
items() Iterable[Tuple[str, Any]]
keys() Iterable[str]
class aiida.orm.EntityTypes(*args, **kwds)

Bases: enum.Enum

Initialization

AUTHINFO = 'authinfo'
COMMENT = 'comment'
COMPUTER = 'computer'
GROUP = 'group'
LOG = 'log'
NODE = 'node'
USER = 'user'
GROUP_NODE = 'group_node'
class aiida.orm.EnumData(member: enum.Enum, *args, **kwargs)

Bases: aiida.orm.nodes.data.data.Data

Initialization

KEY_NAME = 'name'
KEY_VALUE = 'value'
KEY_IDENTIFIER = 'identifier'
property name: str
property value: Any
get_enum() Type[aiida.orm.nodes.data.enum.EnumType]
get_member() aiida.orm.nodes.data.enum.EnumType
__eq__(other: Any) bool
class aiida.orm.Float

Bases: aiida.orm.nodes.data.numeric.NumericType

_type = None
class aiida.orm.FolderData(**kwargs)

Bases: aiida.orm.nodes.data.data.Data

Initialization

class aiida.orm.Group(label: Optional[str] = None, user: Optional[aiida.orm.User] = None, description: str = '', type_string: Optional[str] = None, backend: Optional[aiida.orm.implementation.StorageBackend] = None)

Bases: aiida.orm.entities.Entity[aiida.orm.implementation.BackendGroup, aiida.orm.groups.GroupCollection]

Initialization

_type_string: ClassVar[Optional[str]] = None
_CLS_COLLECTION = None
base() aiida.orm.groups.GroupBase
__repr__() str
__str__() str
store() aiida.orm.groups.SelfType
entry_point() Optional[aiida.plugins.entry_point.EntryPoint]
property uuid: str
property label: str
property description: str
property type_string: str
property user: aiida.orm.User
count() int
property nodes: aiida.orm.convert.ConvertIterator
property is_empty: bool
clear() None
add_nodes(nodes: Union[aiida.orm.nodes.Node, Sequence[aiida.orm.nodes.Node]]) None
remove_nodes(nodes: Union[aiida.orm.nodes.Node, Sequence[aiida.orm.nodes.Node]]) None
is_user_defined() bool
_deprecated_extra_methods = None
__getattr__(name: str) Any
class aiida.orm.GroupEntityLoader

Bases: aiida.orm.utils.loaders.OrmEntityLoader

orm_base_class()
classmethod _get_query_builder_label_identifier(identifier, classes, operator='==', project='*')
class aiida.orm.ImportGroup(label: Optional[str] = None, user: Optional[aiida.orm.User] = None, description: str = '', type_string: Optional[str] = None, backend: Optional[aiida.orm.implementation.StorageBackend] = None)

Bases: aiida.orm.groups.Group

Initialization

class aiida.orm.InstalledCode(computer: aiida.orm.Computer, filepath_executable: str, **kwargs)

Bases: aiida.orm.nodes.data.code.legacy.Code

Initialization

_KEY_ATTRIBUTE_FILEPATH_EXECUTABLE: str = 'filepath_executable'
_validate()
validate_filepath_executable()
can_run_on_computer(computer: aiida.orm.Computer) bool
get_executable() pathlib.PurePosixPath
property computer: aiida.orm.Computer
property full_label: str
property filepath_executable: pathlib.PurePosixPath
static cli_validate_label_uniqueness(ctx, _, value)
classmethod _get_cli_options() dict
class aiida.orm.Int

Bases: aiida.orm.nodes.data.numeric.NumericType

_type = None
class aiida.orm.JsonableData(obj: aiida.orm.nodes.data.jsonable.JsonSerializableProtocol, *args, **kwargs)

Bases: aiida.orm.nodes.data.data.Data

Initialization

classmethod _deserialize_float_constants(data: Any)
_get_object() aiida.orm.nodes.data.jsonable.JsonSerializableProtocol
property obj: aiida.orm.nodes.data.jsonable.JsonSerializableProtocol
class aiida.orm.Kind(**kwargs)

Initialization

get_raw()
reset_mass()
property name
set_automatic_kind_name(tag=None)
compare_with(other_kind)
property mass
property weights
get_symbols_string()
property symbol
property symbols
set_symbols_and_weights(symbols, weights)
property is_alloy
property has_vacancies
__repr__()
__str__()
class aiida.orm.KpointsData

Bases: aiida.orm.nodes.data.array.array.ArrayData

get_description()
property cell
_set_cell(value)
property pbc
_set_pbc(value)
property labels
_set_labels(value)
_change_reference(kpoints, to_cartesian=True)
set_cell_from_structure(structuredata)
set_cell(cell, pbc=None)
property reciprocal_cell
set_kpoints_mesh(mesh, offset=None)
get_kpoints_mesh(print_list=False)
set_kpoints_mesh_from_density(distance, offset=None, force_parity=False)
property _dimension
_validate_kpoints_weights(kpoints, weights)
set_kpoints(kpoints, cartesian=False, labels=None, weights=None, fill_values=0)
get_kpoints(also_weights=False, cartesian=False)
class aiida.orm.LinkManager(link_triples: List[aiida.orm.utils.links.LinkTriple])

Initialization

__iter__() Iterator[aiida.orm.utils.links.LinkTriple]
__next__() Generator[aiida.orm.utils.links.LinkTriple, None, None]
__bool__()
next() Generator[aiida.orm.utils.links.LinkTriple, None, None]
one() aiida.orm.utils.links.LinkTriple
first() Optional[aiida.orm.utils.links.LinkTriple]
all() List[aiida.orm.utils.links.LinkTriple]
all_nodes() List[aiida.orm.Node]
get_node_by_label(label: str) aiida.orm.Node
nested(sort=True)
class aiida.orm.LinkPair

Bases: typing.NamedTuple

class aiida.orm.LinkTriple

Bases: typing.NamedTuple

node: aiida.orm.Node = None
class aiida.orm.List(value=None, **kwargs)

Bases: aiida.orm.nodes.data.data.Data, collections.abc.MutableSequence

Initialization

_LIST_KEY = 'list'
__getitem__(item)
__setitem__(key, value)
__delitem__(key)
__len__()
__str__()
__eq__(other)
append(value)
extend(value)
insert(i, value)
remove(value)
pop(**kwargs)
index(value)
count(value)
sort(key=None, reverse=False)
reverse()
get_list()
set_list(data)
_using_list_reference()
class aiida.orm.Log(time: datetime.datetime, loggername: str, levelname: str, dbnode_id: int, message: str = '', metadata: Optional[Dict[str, Any]] = None, backend: Optional[aiida.orm.implementation.StorageBackend] = None)

Bases: aiida.orm.entities.Entity[aiida.orm.implementation.BackendLog, aiida.orm.logs.LogCollection]

Initialization

_CLS_COLLECTION = None
property uuid: str
property time: datetime.datetime
property loggername: str
property levelname: str
property dbnode_id: int
property message: str
property metadata: Dict[str, Any]
class aiida.orm.Node(backend: Optional[aiida.orm.implementation.StorageBackend] = None, user: Optional[aiida.orm.users.User] = None, computer: Optional[aiida.orm.computers.Computer] = None, **kwargs: Any)

Bases: aiida.orm.entities.Entity[aiida.orm.implementation.BackendNode, aiida.orm.nodes.node.NodeCollection]

Initialization

_CLS_COLLECTION = None
_CLS_NODE_CACHING = None
_plugin_type_string: ClassVar[str] = None
_query_type_string: ClassVar[str] = None
_logger: Optional[logging.Logger] = None
_updatable_attributes: Tuple[str, ...] = None
_hash_ignored_attributes: Tuple[str, ...] = None
_cachable = False
_storable = False
_unstorable_message = 'only Data, WorkflowNode, CalculationNode or their subclasses can be stored'
base() aiida.orm.nodes.node.NodeBase
_check_mutability_attributes(keys: Optional[List[str]] = None) None
__eq__(other: Any) bool
__hash__() int
__repr__() str
__str__() str
__copy__()
__deepcopy__(memo)
_validate() bool
_validate_storability() None
class_node_type() str
entry_point() Optional[aiida.plugins.entry_point.EntryPoint]
property logger: Optional[logging.Logger]
property uuid: str
property node_type: str
property process_type: Optional[str]
property label: str
property description: str
property computer: Optional[aiida.orm.computers.Computer]
property user: aiida.orm.users.User
property ctime: datetime.datetime
property mtime: datetime.datetime
store_all(with_transaction: bool = True) aiida.orm.nodes.node.Node
store(with_transaction: bool = True) aiida.orm.nodes.node.Node
_store(with_transaction: bool = True, clean: bool = True) aiida.orm.nodes.node.Node
_verify_are_parents_stored() None
_store_from_cache(cache_node: aiida.orm.nodes.node.Node, with_transaction: bool) None
_add_outputs_from_cache(cache_node: aiida.orm.nodes.node.Node) None
get_description() str
property is_valid_cache: bool
_deprecated_repo_methods = None
_deprecated_attr_methods = None
_deprecated_extra_methods = None
_deprecated_comment_methods = None
_deprecated_caching_methods = None
Collection()
__getattr__(name: str) Any
class aiida.orm.NodeAttributes(node: aiida.orm.nodes.node.Node)

Initialization

__contains__(key: str) bool
property all: Dict[str, Any]
get(key: str, default=_NO_DEFAULT) Any
get_many(keys: List[str]) List[Any]
set(key: str, value: Any) None
set_many(attributes: Dict[str, Any]) None
reset(attributes: Dict[str, Any]) None
delete(key: str) None
delete_many(keys: List[str]) None
clear() None
items() Iterable[Tuple[str, Any]]
keys() Iterable[str]
class aiida.orm.NodeEntityLoader

Bases: aiida.orm.utils.loaders.OrmEntityLoader

orm_base_class()
classmethod _get_query_builder_label_identifier(identifier, classes, operator='==', project='*')
class aiida.orm.NodeLinksManager(node, link_type, incoming)

Initialization

_namespace_separator = '__'
_construct_attribute_dict(incoming)
_get_keys()
__dir__()
__iter__()
__getattr__(name)
__contains__(key)
__getitem__(name)
__str__()
__repr__()
class aiida.orm.NodeRepository(node: aiida.orm.nodes.node.Node)

Initialization

property metadata: Dict[str, Any]
_update_repository_metadata()
_check_mutability()
property _repository: aiida.repository.Repository
_store() None
_copy(repo: aiida.orm.nodes.repository.NodeRepository) None
_clone(repo: aiida.orm.nodes.repository.NodeRepository) None
serialize() Dict
hash() str
list_objects(path: Optional[str] = None) List[aiida.repository.File]
list_object_names(path: Optional[str] = None) List[str]
open(path: str, mode='r') Iterator[Union[BinaryIO, TextIO]]
get_object(path: Optional[aiida.orm.nodes.repository.FilePath] = None) aiida.repository.File
get_object_content(path: str, mode='r') Union[str, bytes]
put_object_from_bytes(content: bytes, path: str) None
put_object_from_filelike(handle: io.BufferedReader, path: str)
put_object_from_file(filepath: str, path: str)
put_object_from_tree(filepath: str, path: Optional[str] = None)
walk(path: Optional[aiida.orm.nodes.repository.FilePath] = None) Iterable[Tuple[pathlib.PurePosixPath, List[str], List[str]]]
glob() Iterable[pathlib.PurePosixPath]
copy_tree(target: Union[str, pathlib.Path], path: Optional[aiida.orm.nodes.repository.FilePath] = None) None
delete_object(path: str)
erase()
class aiida.orm.NumericType

Bases: aiida.orm.nodes.data.base.BaseType

__add__(other)
__radd__(other)
__sub__(other)
__rsub__(other)
__mul__(other)
__rmul__(other)
__div__(other)
__rdiv__(other)
__truediv__(other)
__rtruediv__(other)
__floordiv__(other)
__rfloordiv__(other)
__pow__(power)
__lt__(other)
__le__(other)
__gt__(other)
__ge__(other)
__mod__(other)
__rmod__(other)
__float__()
__int__()
class aiida.orm.OrbitalData

Bases: aiida.orm.nodes.data.data.Data

clear_orbitals()
get_orbitals(**kwargs)
set_orbitals(orbitals)
aiida.orm.OrderSpecifier(field, direction)
class aiida.orm.OrmEntityLoader
label_ambiguity_breaker = '!'
abstractmethod orm_base_class()
abstractmethod classmethod _get_query_builder_label_identifier(identifier, classes, operator='==', project='*')
classmethod _get_query_builder_id_identifier(identifier, classes)
classmethod _get_query_builder_uuid_identifier(identifier, classes, query_with_dashes)
classmethod get_query_builder(identifier, identifier_type=None, sub_classes=None, query_with_dashes=True, operator='==', project='*')
classmethod get_options(incomplete, project='*')
classmethod load_entity(identifier, identifier_type=None, sub_classes=None, query_with_dashes=True)
classmethod get_query_classes(sub_classes=None)
classmethod infer_identifier_type(value)
class aiida.orm.PortableCode(filepath_executable: str, filepath_files: pathlib.Path, **kwargs)

Bases: aiida.orm.nodes.data.code.legacy.Code

Initialization

_KEY_ATTRIBUTE_FILEPATH_EXECUTABLE: str = 'filepath_executable'
_validate()
can_run_on_computer(computer: aiida.orm.Computer) bool
get_executable() pathlib.PurePosixPath
validate_working_directory(folder: aiida.common.folders.Folder)
property full_label: str
property filepath_executable: pathlib.PurePosixPath
classmethod _get_cli_options() dict
class aiida.orm.ProcessNode(backend: Optional[aiida.orm.implementation.StorageBackend] = None, user: Optional[aiida.orm.users.User] = None, computer: Optional[aiida.orm.computers.Computer] = None, **kwargs: Any)

Bases: aiida.orm.utils.mixins.Sealable, aiida.orm.nodes.node.Node

Initialization

_CLS_NODE_CACHING = None
CHECKPOINT_KEY = 'checkpoints'
EXCEPTION_KEY = 'exception'
EXIT_MESSAGE_KEY = 'exit_message'
EXIT_STATUS_KEY = 'exit_status'
PROCESS_PAUSED_KEY = 'paused'
PROCESS_LABEL_KEY = 'process_label'
PROCESS_STATE_KEY = 'process_state'
PROCESS_STATUS_KEY = 'process_status'
_unstorable_message = 'only Data, WorkflowNode, CalculationNode or their subclasses can be stored'
__str__() str
_updatable_attributes() Tuple[str, ...]
property logger
get_builder_restart() aiida.engine.processes.builder.ProcessBuilder
property process_class: Type[aiida.engine.processes.Process]
set_process_type(process_type_string: str) None
property process_label: Optional[str]
set_process_label(label: str) None
property process_state: Optional[plumpy.process_states.ProcessState]
set_process_state(state: Union[str, plumpy.process_states.ProcessState, None])
property process_status: Optional[str]
set_process_status(status: Optional[str]) None
property is_terminated: bool
property is_excepted: bool
property is_killed: bool
property is_finished: bool
property is_finished_ok: bool
property is_failed: bool
property exit_status: Optional[int]
set_exit_status(status: Union[None, enum.Enum, int]) None
property exit_message: Optional[str]
set_exit_message(message: Optional[str]) None
property exception: Optional[str]
set_exception(exception: str) None
property checkpoint: Optional[Dict[str, Any]]
set_checkpoint(checkpoint: Dict[str, Any]) None
delete_checkpoint() None
property paused: bool
pause() None
unpause() None
property called: List[aiida.orm.nodes.process.process.ProcessNode]
property called_descendants: List[aiida.orm.nodes.process.process.ProcessNode]
property caller: Optional[aiida.orm.nodes.process.process.ProcessNode]
class aiida.orm.ProjectionData(*args, source=None, **kwargs)

Bases: aiida.orm.nodes.data.orbital.OrbitalData, aiida.orm.nodes.data.array.array.ArrayData

Initialization

_check_projections_bands(projection_array)
set_reference_bandsdata(value)
get_reference_bandsdata()
_find_orbitals_and_indices(**kwargs)
get_pdos(**kwargs)
get_projections(**kwargs)
static _from_index_to_arrayname(index)
set_projectiondata(list_of_orbitals, list_of_projections=None, list_of_energy=None, list_of_pdos=None, tags=None, bands_check=True)
abstractmethod set_orbitals(**kwargs)
class aiida.orm.QueryBuilder(backend: Optional[aiida.orm.implementation.StorageBackend] = None, *, debug: bool = False, path: Optional[Sequence[Union[str, Dict[str, Any], aiida.orm.querybuilder.EntityClsType]]] = (), filters: Optional[Dict[str, aiida.orm.querybuilder.FilterType]] = None, project: Optional[Dict[str, aiida.orm.querybuilder.ProjectType]] = None, limit: Optional[int] = None, offset: Optional[int] = None, order_by: Optional[aiida.orm.querybuilder.OrderByType] = None, distinct: bool = False)

Initialization

_EDGE_TAG_DELIM = '--'
_VALID_PROJECTION_KEYS = ('func', 'cast')
property backend: aiida.orm.implementation.StorageBackend
as_dict(copy: bool = True) aiida.orm.implementation.querybuilder.QueryDictType
property queryhelp: aiida.orm.implementation.querybuilder.QueryDictType
classmethod from_dict(dct: Dict[str, Any]) aiida.orm.querybuilder.QueryBuilder
__repr__() str
__str__() str
__deepcopy__(memo) aiida.orm.querybuilder.QueryBuilder
get_used_tags(vertices: bool = True, edges: bool = True) List[str]
_get_unique_tag(classifiers: List[aiida.orm.querybuilder.Classifier]) str
append(cls: Optional[Union[aiida.orm.querybuilder.EntityClsType, Sequence[aiida.orm.querybuilder.EntityClsType]]] = None, entity_type: Optional[Union[str, Sequence[str]]] = None, tag: Optional[str] = None, filters: Optional[aiida.orm.querybuilder.FilterType] = None, project: Optional[aiida.orm.querybuilder.ProjectType] = None, subclassing: bool = True, edge_tag: Optional[str] = None, edge_filters: Optional[aiida.orm.querybuilder.FilterType] = None, edge_project: Optional[aiida.orm.querybuilder.ProjectType] = None, outerjoin: bool = False, joining_keyword: Optional[str] = None, joining_value: Optional[Any] = None, orm_base: Optional[str] = None, **kwargs: Any) aiida.orm.querybuilder.QueryBuilder
order_by(order_by: aiida.orm.querybuilder.OrderByType) aiida.orm.querybuilder.QueryBuilder
add_filter(tagspec: Union[str, aiida.orm.querybuilder.EntityClsType], filter_spec: aiida.orm.querybuilder.FilterType) aiida.orm.querybuilder.QueryBuilder
static _process_filters(filters: aiida.orm.querybuilder.FilterType) Dict[str, Any]
_add_node_type_filter(tagspec: str, classifiers: List[aiida.orm.querybuilder.Classifier], subclassing: bool)
_add_process_type_filter(tagspec: str, classifiers: List[aiida.orm.querybuilder.Classifier], subclassing: bool) None
_add_group_type_filter(tagspec: str, classifiers: List[aiida.orm.querybuilder.Classifier], subclassing: bool) None
add_projection(tag_spec: Union[str, aiida.orm.querybuilder.EntityClsType], projection_spec: aiida.orm.querybuilder.ProjectType) None
set_debug(debug: bool) aiida.orm.querybuilder.QueryBuilder
debug(msg: str, *objects: Any) None
limit(limit: Optional[int]) aiida.orm.querybuilder.QueryBuilder
offset(offset: Optional[int]) aiida.orm.querybuilder.QueryBuilder
distinct(value: bool = True) aiida.orm.querybuilder.QueryBuilder
inputs(**kwargs: Any) aiida.orm.querybuilder.QueryBuilder
outputs(**kwargs: Any) aiida.orm.querybuilder.QueryBuilder
children(**kwargs: Any) aiida.orm.querybuilder.QueryBuilder
parents(**kwargs: Any) aiida.orm.querybuilder.QueryBuilder
as_sql(inline: bool = False) str
analyze_query(execute: bool = True, verbose: bool = False) str
static _get_aiida_entity_res(value) Any
first(flat: bool = False) Optional[list[Any] | Any]
count() int
iterall(batch_size: Optional[int] = 100) Iterable[List[Any]]
iterdict(batch_size: Optional[int] = 100) Iterable[Dict[str, Dict[str, Any]]]
all(batch_size: Optional[int] = None, flat: bool = False) Union[List[List[Any]], List[Any]]
one() List[Any]
dict(batch_size: Optional[int] = None) List[Dict[str, Dict[str, Any]]]
class aiida.orm.RemoteData(remote_path=None, **kwargs)

Bases: aiida.orm.nodes.data.data.Data

Initialization

KEY_EXTRA_CLEANED = 'cleaned'
get_remote_path()
set_remote_path(val)
property is_empty
getfile(relpath, destpath)
listdir(relpath='.')
listdir_withattributes(path='.')
_clean(transport=None)
_validate()
get_authinfo()
class aiida.orm.RemoteStashData(stash_mode: aiida.common.datastructures.StashMode, **kwargs)

Bases: aiida.orm.nodes.data.data.Data

Initialization

_storable = False
property stash_mode: aiida.common.datastructures.StashMode
class aiida.orm.RemoteStashFolderData(stash_mode: aiida.common.datastructures.StashMode, target_basepath: str, source_list: List, **kwargs)

Bases: aiida.orm.nodes.data.remote.stash.base.RemoteStashData

Initialization

_storable = True
property target_basepath: str
property source_list: Union[List, Tuple]
class aiida.orm.SinglefileData(file, filename=None, **kwargs)

Bases: aiida.orm.nodes.data.data.Data

Initialization

DEFAULT_FILENAME = 'file.txt'
property filename
open(path=None, mode='r')
get_content()
set_file(file, filename=None)
_validate()
class aiida.orm.Site(**kwargs)

Initialization

get_raw()
get_ase(kinds)
property kind_name
property position
__repr__()
__str__()
class aiida.orm.Str

Bases: aiida.orm.nodes.data.base.BaseType

_type = None
class aiida.orm.StructureData(cell=None, pbc=None, ase=None, pymatgen=None, pymatgen_structure=None, pymatgen_molecule=None, **kwargs)

Bases: aiida.orm.nodes.data.data.Data

Initialization

_set_incompatibilities = [('ase', 'cell'), ('ase', 'pbc'), ('ase', 'pymatgen'), ('ase', 'pymatgen_molecule'), ('ase', 'pymatg...
_dimensionality_label = None
_internal_kind_tags = None
get_dimensionality()
set_ase(aseatoms)
set_pymatgen(obj, **kwargs)
set_pymatgen_molecule(mol, margin=5)
set_pymatgen_structure(struct)
_validate()
_prepare_xsf(main_file_name='')
_prepare_cif(main_file_name='')
_prepare_chemdoodle(main_file_name='')
_prepare_xyz(main_file_name='')
_parse_xyz(inputstring)
_adjust_default_cell(vacuum_factor=1.0, vacuum_addition=10.0, pbc=(False, False, False))
get_description()
get_symbols_set()
get_formula(mode='hill', separator='')
get_site_kindnames()
get_composition()
get_ase()
get_pymatgen(**kwargs)
get_pymatgen_structure(**kwargs)
get_pymatgen_molecule()
append_kind(kind)
append_site(site)
append_atom(**kwargs)
clear_kinds()
clear_sites()
property sites
property kinds
get_kind(kind_name)
get_kind_names()
property cell
set_cell(value)
reset_cell(new_cell)
reset_sites_positions(new_positions, conserve_particle=True)
property pbc
set_pbc(value)
property cell_lengths
abstractmethod set_cell_lengths(value)
property cell_angles
abstractmethod set_cell_angles(value)
property is_alloy
property has_vacancies
get_cell_volume()
get_cif(converter='ase', store=False, **kwargs)
_get_object_phonopyatoms()
_get_object_ase()
_get_object_pymatgen(**kwargs)
_get_object_pymatgen_structure(**kwargs)
_get_object_pymatgen_molecule(**kwargs)
class aiida.orm.TrajectoryData(structurelist=None, **kwargs)

Bases: aiida.orm.nodes.data.array.array.ArrayData

Initialization

_internal_validate(stepids, cells, symbols, positions, times, velocities)
set_trajectory(symbols, positions, stepids=None, cells=None, times=None, velocities=None)
set_structurelist(structurelist)
_validate()
property numsteps
property numsites
get_stepids()
get_times()
get_cells()
property symbols
get_positions()
get_velocities()
get_index_from_stepid(stepid)
get_step_data(index)
get_step_structure(index, custom_kinds=None)
_prepare_xsf(index=None, main_file_name='')
_prepare_cif(trajectory_index=None, main_file_name='')
get_structure(store=False, **kwargs)
get_cif(index=None, **kwargs)
_parse_xyz_pos(inputstring)
_parse_xyz_vel(inputstring)
show_mpl_pos(**kwargs)
show_mpl_heatmap(**kwargs)
class aiida.orm.UpfData(file, filename=None, **kwargs)

Bases: aiida.orm.nodes.data.singlefile.SinglefileData

Initialization

classmethod get_or_create(filepath, use_first=False, store_upf=True)
store(*args, **kwargs)
classmethod from_md5(md5, backend=None)
set_file(file, filename=None)
get_upf_family_names()
property element
property md5sum
_validate()
_prepare_upf(main_file_name='')
classmethod get_upf_group(group_label)
classmethod get_upf_groups(filter_elements=None, user=None, backend=None)
_prepare_json(main_file_name='')
class aiida.orm.UpfFamily(label: Optional[str] = None, user: Optional[aiida.orm.User] = None, description: str = '', type_string: Optional[str] = None, backend: Optional[aiida.orm.implementation.StorageBackend] = None)

Bases: aiida.orm.groups.Group

Initialization

class aiida.orm.User(email: str, first_name: str = '', last_name: str = '', institution: str = '', backend: Optional[aiida.orm.implementation.StorageBackend] = None)

Bases: aiida.orm.entities.Entity[aiida.orm.implementation.BackendUser, aiida.orm.users.UserCollection]

Initialization

_CLS_COLLECTION = None
__str__() str
static normalize_email(email: str) str
property email: str
property first_name: str
property last_name: str
property institution: str
get_full_name() str
get_short_name() str
property uuid: None
class aiida.orm.WorkChainNode

Bases: aiida.orm.nodes.process.workflow.workflow.WorkflowNode

STEPPER_STATE_INFO_KEY = 'stepper_state_info'
_updatable_attributes() Tuple[str, ...]
property stepper_state_info: Optional[str]
set_stepper_state_info(stepper_state_info: str) None
class aiida.orm.WorkFunctionNode

Bases: aiida.orm.utils.mixins.FunctionCalculationMixin, aiida.orm.nodes.process.workflow.workflow.WorkflowNode

class aiida.orm.WorkflowNode(backend: Optional[aiida.orm.implementation.StorageBackend] = None, user: Optional[aiida.orm.users.User] = None, computer: Optional[aiida.orm.computers.Computer] = None, **kwargs: Any)

Bases: aiida.orm.nodes.process.process.ProcessNode

Initialization

_storable = True
_unstorable_message = 'storing for this node has been disabled'
property inputs: aiida.orm.utils.managers.NodeLinksManager
property outputs: aiida.orm.utils.managers.NodeLinksManager
class aiida.orm.XyData

Bases: aiida.orm.nodes.data.array.array.ArrayData

static _arrayandname_validator(array, name, units)
set_x(x_array, x_name, x_units)
set_y(y_arrays, y_names, y_units)
get_x()
get_y()
aiida.orm.cif_from_ase(ase, full_occupancies=False, add_fake_biso=False)
aiida.orm.find_bandgap(bandsdata, number_electrons=None, fermi_energy=None)
aiida.orm.get_loader(orm_class)
aiida.orm.get_query_type_from_type_string(type_string)
aiida.orm.get_type_string_from_class(class_module, class_name)
aiida.orm.has_pycifrw()
aiida.orm.load_code(identifier=None, pk=None, uuid=None, label=None, sub_classes=None, query_with_dashes=True) aiida.orm.Code
aiida.orm.load_computer(identifier=None, pk=None, uuid=None, label=None, sub_classes=None, query_with_dashes=True) aiida.orm.Computer
aiida.orm.load_entity(entity_loader=None, identifier=None, pk=None, uuid=None, label=None, sub_classes=None, query_with_dashes=True)
aiida.orm.load_group(identifier=None, pk=None, uuid=None, label=None, sub_classes=None, query_with_dashes=True) aiida.orm.Group
aiida.orm.load_node(identifier=None, pk=None, uuid=None, label=None, sub_classes=None, query_with_dashes=True) aiida.orm.Node
aiida.orm.load_node_class(type_string)
aiida.orm.pycifrw_from_cif(datablocks, loops=None, names=None)
aiida.orm.to_aiida_type(value)