current

Author: edan-bainglass

src/aiida/cmdline/commands/cmd_code.py

@@ -35,7 +35,7 @@ def verdi_code():
 def create_code(ctx: click.Context, cls, **kwargs) -> None:
     """Create a new `Code` instance."""
     try:
-        instance = cls._from_model(cls.Model(**kwargs))
+        instance = cls.from_model(cls.Model(**kwargs))
     except (TypeError, ValueError) as exception:
         echo.echo_critical(f'Failed to create instance `{cls}`: {exception}')
 

src/aiida/common/datastructures.py

@@ -167,8 +167,8 @@ class CalcInfo(DefaultFieldsAttributeDict):
         max_wallclock_seconds: None | int
         max_memory_kb: None | int
         rerunnable: bool
-        retrieve_list: None | list[str | tuple[str, str, str]]
-        retrieve_temporary_list: None | list[str | tuple[str, str, str]]
+        retrieve_list: None | list[str | tuple[str, str, int]]
+        retrieve_temporary_list: None | list[str | tuple[str, str, int]]
         local_copy_list: None | list[tuple[str, str, str]]
         remote_copy_list: None | list[tuple[str, str, str]]
         remote_symlink_list: None | list[tuple[str, str, str]]

src/aiida/common/pydantic.py

@@ -75,7 +75,7 @@ class Model(BaseModel):
     :param model_to_orm: Optional callable to convert the value of a field from a model instance to an ORM instance.
     :param exclude_to_orm: When set to ``True``, this field value will not be passed to the ORM entity constructor
         through ``Entity.from_model``.
-    :param exclude_to_orm: When set to ``True``, this field value will not be exposed on the CLI command that is
+    :param exclude_from_cli: When set to ``True``, this field value will not be exposed on the CLI command that is
         dynamically generated to create a new instance.
     :param is_attribute: Whether the field is stored as an attribute.
     :param is_subscriptable: Whether the field can be indexed like a list or dictionary.

src/aiida/engine/processes/calcjobs/calcjob.py

@@ -216,7 +216,7 @@ def validate_additional_retrieve_list(additional_retrieve_list: Any, _: Any) ->
 class CalcJob(Process):
     """Implementation of the CalcJob process."""
 
-    _node_class = orm.CalcJobNode
+    _node_class = orm.CalcJobNode  # type: ignore[assignment]
     _spec_class = CalcJobProcessSpec
     link_label_retrieved: str = 'retrieved'
     KEY_CACHE_VERSION: str = 'cache_version'

src/aiida/orm/comments.py

@@ -88,19 +88,22 @@ class Model(entities.Entity.Model):
             is_attribute=False,
             exclude_to_orm=True,
         )
-        node: int = MetadataField(
+        node: Optional[int] = MetadataField(
+            None,
             description='Node PK that the comment is attached to',
             is_attribute=False,
             orm_class='core.node',
             orm_to_model=lambda comment, _: cast('Comment', comment).node.pk,
         )
-        user: int = MetadataField(
+        user: Optional[int] = MetadataField(
+            None,
             description='User PK that created the comment',
             is_attribute=False,
             orm_class='core.user',
             orm_to_model=lambda comment, _: cast('Comment', comment).user.pk,
         )
-        content: str = MetadataField(
+        content: Optional[str] = MetadataField(
+            None,
             description='Content of the comment',
             is_attribute=False,
         )
@@ -122,7 +125,11 @@ def __init__(
         :return: a Comment object associated to the given node and user
         """
         backend = backend or get_manager().get_profile_storage()
-        model = backend.comments.create(node=node.backend_entity, user=user.backend_entity, content=content)
+        model = backend.comments.create(
+            node=node.backend_entity,
+            user=user.backend_entity,
+            content=content,
+        )
         super().__init__(model)
 
     def __str__(self) -> str:

src/aiida/orm/computers.py

@@ -12,7 +12,7 @@
 
 import logging
 import os
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Optional
 
 from aiida.common import exceptions
 from aiida.common.pydantic import MetadataField
@@ -76,7 +76,8 @@ class Computer(entities.Entity['BackendComputer', ComputerCollection]):
     _CLS_COLLECTION = ComputerCollection
 
     class Model(entities.Entity.Model):
-        uuid: str = MetadataField(
+        uuid: Optional[str] = MetadataField(
+            None,
             description='The UUID of the computer',
             is_attribute=False,
             exclude_to_orm=True,
@@ -85,23 +86,28 @@ class Model(entities.Entity.Model):
             description='Label for the computer',
             is_attribute=False,
         )
-        description: str = MetadataField(
+        description: Optional[str] = MetadataField(
+            None,
             description='Description of the computer',
             is_attribute=False,
         )
-        hostname: str = MetadataField(
+        hostname: Optional[str] = MetadataField(
+            None,
             description='Hostname of the computer',
             is_attribute=False,
         )
-        transport_type: str = MetadataField(
+        transport_type: Optional[str] = MetadataField(
+            None,
             description='Transport type of the computer',
             is_attribute=False,
         )
-        scheduler_type: str = MetadataField(
+        scheduler_type: Optional[str] = MetadataField(
+            None,
             description='Scheduler type of the computer',
             is_attribute=False,
         )
-        metadata: dict[str, Any] = MetadataField(
+        metadata: Optional[dict[str, Any]] = MetadataField(
+            None,
             description='Metadata of the computer',
             is_attribute=False,
         )

src/aiida/orm/entities.py

@@ -152,16 +152,18 @@ def find(
         filters: 'FilterType' | None = None,
         order_by: 'OrderByType' | None = None,
         limit: int | None = None,
+        offset: int | None = None,
     ) -> list[EntityType]:
         """Find collection entries matching the filter criteria.
 
         :param filters: the keyword value pair filters to match
         :param order_by: a list of (key, direction) pairs specifying the sort order
         :param limit: the maximum number of results to return
+        :param offset: number of initial results to be skipped
 
         :return: a list of resulting matches
         """
-        query = self.query(filters=filters, order_by=order_by, limit=limit)
+        query = self.query(filters=filters, order_by=order_by, limit=limit, offset=offset)
         return query.all(flat=True)
 
     def all(self) -> list[EntityType]:
@@ -233,7 +235,7 @@ def model_to_orm_field_values(cls, model: Model) -> dict[str, Any]:
 
         return fields
 
-    def _to_model(self, repository_path: Path | None = None) -> Model:
+    def to_model(self, repository_path: Path | None = None) -> Model:
         """Return the entity instance as an instance of its model."""
         fields = {}
 
@@ -246,16 +248,17 @@ def _to_model(self, repository_path: Path | None = None) -> Model:
         return self.Model(**fields)
 
     @classmethod
-    def _from_model(cls: type[EntityType], model: Model) -> EntityType:
+    def from_model(cls: type[EntityType], model: Model) -> EntityType:
         """Return an entity instance from an instance of its model."""
         fields = cls.model_to_orm_field_values(model)
         return cls(**fields)
 
-    def serialize(self, repository_path: Path | None = None) -> dict[str, Any]:
+    def serialize(self, repository_path: Path | None = None, serialize_files: bool = False) -> dict[str, Any]:
         """Serialize the entity instance to JSON.
 
         :param repository_path: If the orm node has files in the repository, this path is used to dump the repository
             files to. If no path is specified a temporary path is created using the entities pk.
+        :param serialize_files: Whether to include files in the serialization. If False, only metadata is serialized.
         """
         self.logger.warning(
             'Serialization through pydantic is still an experimental feature and might break in future releases.'
@@ -270,15 +273,19 @@ def serialize(self, repository_path: Path | None = None) -> dict[str, Any]:
                 raise ValueError(f'The repository_path `{repository_path}` does not exist.')
             if not repository_path.is_dir():
                 raise ValueError(f'The repository_path `{repository_path}` is not a directory.')
-        return self._to_model(repository_path).model_dump()
+
+        exclude = set()
+        if not serialize_files:
+            exclude.add('repository_content')
+        return self.to_model(repository_path).model_dump(exclude=exclude)
 
     @classmethod
     def from_serialized(cls: type[EntityType], **kwargs: dict[str, Any]) -> EntityType:
         """Construct an entity instance from JSON serialized data."""
         cls._logger.warning(
             'Serialization through pydantic is still an experimental feature and might break in future releases.'
         )
-        return cls._from_model(cls.Model(**kwargs))  # type: ignore[arg-type]
+        return cls.from_model(cls.Model(**kwargs))  # type: ignore[arg-type]
 
     @classproperty
     def objects(cls: type[EntityType]) -> CollectionType:  # noqa: N805

src/aiida/orm/fields.py

@@ -354,6 +354,10 @@ class QbFields:
     def __init__(self, fields: t.Optional[t.Dict[str, QbField]] = None):
         self._fields = fields or {}
 
+    def keys(self) -> list[str]:
+        """Return the field keys, prefixed with 'attribute.' if field is an attribute."""
+        return [field.backend_key for field in self._fields.values()]
+
     def __repr__(self) -> str:
         return pformat({key: str(value) for key, value in self._fields.items()})
 
@@ -464,7 +468,7 @@ def __init__(cls, name, bases, classdict):
             for key, field in cls.Model.model_fields.items():
                 fields[key] = add_field(
                     key,
-                    alias=get_metadata(field, 'alias', None),
+                    alias=field.alias,
                     dtype=field.annotation,
                     doc=field.description,
                     is_attribute=get_metadata(field, 'is_attribute', False),

src/aiida/orm/groups.py

@@ -112,28 +112,42 @@ class Group(entities.Entity['BackendGroup', GroupCollection]):
     __type_string: ClassVar[str | None]
 
     class Model(entities.Entity.Model):
-        uuid: str = MetadataField(
+        uuid: Optional[str] = MetadataField(
+            None,
             description='The UUID of the group',
             is_attribute=False,
             exclude_to_orm=True,
         )
-        type_string: str = MetadataField(
+        type_string: Optional[str] = MetadataField(
+            None,
             description='The type of the group',
             is_attribute=False,
             exclude_to_orm=True,
         )
-        user: int = MetadataField(
+        user: Optional[int] = MetadataField(
+            None,
             description='The group owner',
             is_attribute=False,
             orm_class='core.user',
             orm_to_model=lambda group, _: cast('Group', group).user.pk,
         )
         time: Optional[datetime.datetime] = MetadataField(
-            description='The creation time of the node', is_attribute=False
+            None,
+            description='The creation time of the node',
+            is_attribute=False,
+        )
+        label: Optional[str] = MetadataField(
+            None,
+            description='The group label',
+            is_attribute=False,
+        )
+        description: Optional[str] = MetadataField(
+            None,
+            description='The group description',
+            is_attribute=False,
         )
-        label: str = MetadataField(description='The group label', is_attribute=False)
-        description: Optional[str] = MetadataField(description='The group description', is_attribute=False)
         extras: Optional[dict[str, Any]] = MetadataField(
+            None,
             description='The group extras',
             is_attribute=False,
             is_subscriptable=True,
@@ -173,7 +187,11 @@ def __init__(
         type_check(user, users.User)
 
         model = backend.groups.create(
-            label=label, user=user.backend_entity, description=description, type_string=self._type_string, time=time
+            label=label,
+            user=user.backend_entity,
+            description=description,
+            type_string=self._type_string,
+            time=time,
         )
         super().__init__(model)
         if extras is not None:

src/aiida/orm/logs.py

@@ -132,13 +132,35 @@ class Log(entities.Entity['BackendLog', LogCollection]):
     _CLS_COLLECTION = LogCollection
 
     class Model(entities.Entity.Model):
-        uuid: str = MetadataField(description='The UUID of the node', is_attribute=False, exclude_to_orm=True)
-        loggername: str = MetadataField(description='The name of the logger', is_attribute=False)
-        levelname: str = MetadataField(description='The name of the log level', is_attribute=False)
-        message: str = MetadataField(description='The message of the log', is_attribute=False)
-        time: datetime = MetadataField(description='The time at which the log was created', is_attribute=False)
-        metadata: dict[str, Any] = MetadataField(description='The metadata of the log', is_attribute=False)
-        dbnode_id: int = MetadataField(description='Associated node', is_attribute=False)
+        uuid: str = MetadataField(
+            description='The UUID of the node',
+            is_attribute=False,
+            exclude_to_orm=True,
+        )
+        loggername: str = MetadataField(
+            description='The name of the logger',
+            is_attribute=False,
+        )
+        levelname: str = MetadataField(
+            description='The name of the log level',
+            is_attribute=False,
+        )
+        message: str = MetadataField(
+            description='The message of the log',
+            is_attribute=False,
+        )
+        time: datetime = MetadataField(
+            description='The time at which the log was created',
+            is_attribute=False,
+        )
+        metadata: dict[str, Any] = MetadataField(
+            description='The metadata of the log',
+            is_attribute=False,
+        )
+        dbnode_id: int = MetadataField(
+            description='Associated node',
+            is_attribute=False,
+        )
 
     def __init__(
         self,