Skip to content
Back to top
View this page

# `aiida.orm`

## Package Contents

### Classes

`AbstractCode` |
`AbstractNodeMeta` |
`ArrayData` |
`AttributeManager` |
`AuthInfo` |
`AutoGroup` |
`BandsData` |
`BaseType` |
`Bool` |
`CalcFunctionNode` |
`CalcJobNode` |
`CalcJobResultManager` |
`CalculationEntityLoader` |
`CalculationNode` |
`CifData` |
`Code` |
`CodeEntityLoader` |
`Collection` |
`Comment` |
`Computer` |
`ComputerEntityLoader` |
`ContainerizedCode` |
`Data` |
`Dict` |
`Entity` |
`EntityExtras` |
`EntityTypes` |
`EnumData` |
`Float` |
`FolderData` |
`Group` |
`GroupEntityLoader` |
`ImportGroup` |
`InstalledCode` |
`Int` |
`JsonableData` |
`Kind` |
`KpointsData` |
`LinkManager` |
`LinkPair` |
`LinkTriple` |
`List` |
`Log` |
`Node` |
`NodeAttributes` |
`NodeEntityLoader` |
`NodeLinksManager` |
`NodeRepository` |
`NumericType` |
`OrbitalData` |
`OrmEntityLoader` |
`PortableCode` |
`ProcessNode` |
`ProjectionData` |
`QueryBuilder` |
`RemoteData` |
`RemoteStashData` |
`RemoteStashFolderData` |
`SinglefileData` |
`Site` |
`Str` |
`StructureData` |
`TrajectoryData` |
`UpfData` |
`UpfFamily` |
`User` |
`WorkChainNode` |
`WorkFunctionNode` |
`WorkflowNode` |
`XyData` |

### Functions

`OrderSpecifier` |
`cif_from_ase` |
`find_bandgap` |
`get_loader` |
`get_query_type_from_type_string` |
`get_type_string_from_class` |
`has_pycifrw` |
`load_code` |
`load_computer` |
`load_entity` |
`load_group` |
`load_node` |
`load_node_class` |
`pycifrw_from_cif` |
`to_aiida_type` |
`validate_link` |

### Data

`ASCENDING` |
`DESCENDING` |

### 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`

  _CLS_NODE_LINKS = None

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]]
  property link_label_retrieved: str
  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'
  LINK = 'link'
  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]
  all_link_pairs() → List[aiida.orm.utils.links.LinkPair]
  all_link_labels() → List[str]
  get_node_by_label(label: str) → aiida.orm.Node
  nested(sort=True)

class aiida.orm.LinkPair

  Bases: `typing.NamedTuple`

  link_type: aiida.common.links.LinkType = None
  link_label: str = None

class aiida.orm.LinkTriple

  Bases: `typing.NamedTuple`

  node: aiida.orm.Node = None
  link_type: aiida.common.links.LinkType = None
  link_label: str = 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_LINKS = 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
  _deprecated_links_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()
  _get_node_by_link_label(label)
  __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_LINKS = None
  _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`

  _CLS_NODE_LINKS = None

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

  _CLS_NODE_LINKS = None
  _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)

aiida.orm.validate_link(source: aiida.orm.Node, target: aiida.orm.Node, link_type: aiida.common.links.LinkType, link_label: str, backend: Optional[aiida.orm.implementation.storage_backend.StorageBackend] = None) → None