Fix computer type

Author: edan-bainglass

src/aiida/cmdline/groups/dynamic.py

@@ -179,11 +179,7 @@ def list_options(self, entry_point: str) -> list[t.Callable[[FC], FC]]:
 
             default = field_info.default_factory if field_info.default is PydanticUndefined else field_info.default
 
-            option_type = get_metadata(field_info, 'option_type', None)
-
-            if option_type is not None:
-                field_type = option_type
-            elif hasattr(field_info.annotation, '__args__'):
+            if hasattr(field_info.annotation, '__args__'):
                 # If the annotation has the ``__args__`` attribute it is an instance of a type from ``typing`` and
                 # the real type can be gotten from the arguments. For example it could be ``typing.Union[str, None]``
                 # calling ``typing.Union[str, None].__args__`` will return the tuple ``(str, NoneType)``. So to get

src/aiida/common/pydantic.py

@@ -34,7 +34,6 @@ def MetadataField(  # noqa: N802
     priority: int = 0,
     short_name: str | None = None,
     option_cls: t.Any | None = None,
-    option_type: type | None = None,
     orm_class: type[Entity] | str | None = None,
     orm_to_model: t.Callable[[Entity, Path], t.Any] | None = None,
     model_to_orm: t.Callable[['BaseModel'], t.Any] | None = None,
@@ -66,9 +65,6 @@ class Model(BaseModel):
     :param priority: Used to order the list of all fields in the model. Ordering is done from small to large priority.
     :param short_name: Optional short name to use for an option on a command line interface.
     :param option_cls: The :class:`click.Option` class to use to construct the option.
-    :param option_type: The type to use for the option on the command line interface. This is typically a built-in type
-        such as ``str``, ``int``, ``float``, or ``bool``. If not specified, the type will be inferred from the type
-        annotation of the field.
     :param orm_class: The class, or entry point name thereof, to which the field should be converted. If this field is
         defined, the value of this field should accept an integer which will automatically be converted to an instance
         of said ORM class using ``orm_class.collection.get(id={field_value})``. This is useful, for example, where a
@@ -90,7 +86,6 @@ class Model(BaseModel):
         ('priority', priority),
         ('short_name', short_name),
         ('option_cls', option_cls),
-        ('option_type', option_type),
         ('orm_class', orm_class),
         ('orm_to_model', orm_to_model),
         ('model_to_orm', model_to_orm),

src/aiida/orm/nodes/data/code/installed.py

@@ -19,8 +19,6 @@
 import pathlib
 from typing import cast
 
-from pydantic import field_validator
-
 from aiida.common import exceptions
 from aiida.common.lang import type_check
 from aiida.common.log import override_log_level
@@ -44,13 +42,12 @@ class InstalledCode(Code):
     class Model(AbstractCode.Model):
         """Model describing required information to create an instance."""
 
-        computer: int = MetadataField(
+        computer: str = MetadataField(
             title='Computer',
-            description='The remote computer on which the executable resides.',
+            description='The label of the remote computer on which the executable resides.',
             is_attribute=False,
-            orm_to_model=lambda node, _: cast('InstalledCode', node).computer.pk,
-            orm_class=Computer,
-            option_type=str,
+            orm_to_model=lambda node, _: cast('InstalledCode', node).computer.label,
+            model_to_orm=lambda model: cast('InstalledCode.Model', model).load_computer(),
             short_name='-Y',
             priority=2,
         )
@@ -62,24 +59,16 @@ class Model(AbstractCode.Model):
             priority=1,
         )
 
-        @field_validator('computer', mode='before')
-        @classmethod
-        def validate_computer(cls, value: str | int) -> int:
-            """Validate computer input.
-
-            If provided a string (e.g., via CLI computer setup), try to load the computer and return its PK.
+        def load_computer(self) -> Computer:
+            """Load the computer instance.
 
-            :param value: The input value, either a string or an integer
-            :return: The PK of the computer
-            :raises ValueError: If the computer does not exist
+            :return: The computer instance.
+            :raises ValueError: If the computer does not exist.
             """
             from aiida.orm import load_computer
 
-            if isinstance(value, int):
-                return value
-
             try:
-                return cast(int, load_computer(value).pk)
+                return load_computer(self.computer)
             except exceptions.NotExistent as exception:
                 raise ValueError(exception) from exception
 

src/aiida/orm/nodes/node.py

@@ -262,17 +262,17 @@ class Model(Entity.Model):
             is_subscriptable=True,
             exclude_from_cli=True,
         )
-        computer: Optional[int] = MetadataField(
+        computer: Optional[str] = MetadataField(
             None,
-            description='The PK of the computer',
+            description='The label of the computer',
             is_attribute=False,
-            orm_to_model=lambda node, _: cast('Node', node).computer.pk if cast('Node', node).computer else None,
-            orm_class=Computer,
+            orm_to_model=lambda node, _: cast('Node', node).computer.label if cast('Node', node).computer else None,  # type: ignore[union-attr]
+            model_to_orm=lambda model: cast('Node.Model', model).load_computer(),
             exclude_from_cli=True,
             exclude_to_orm=True,
         )
         user: int = MetadataField(
-            default_factory=lambda: User.collection.get_default().pk,
+            default_factory=lambda: User.collection.get_default().pk,  # type: ignore[union-attr]
             description='The PK of the user who owns the node',
             is_attribute=False,
             orm_to_model=lambda node, _: cast('Node', node).user.pk,
@@ -293,6 +293,19 @@ class Model(Entity.Model):
             exclude_to_orm=True,
         )
 
+        def load_computer(self) -> Computer:
+            """Load the computer instance.
+
+            :return: The computer instance.
+            :raises ValueError: If the computer does not exist.
+            """
+            from aiida.orm import load_computer
+
+            try:
+                return load_computer(self.computer)
+            except exceptions.NotExistent as exception:
+                raise ValueError(exception) from exception
+
     def __init__(
         self,
         backend: Optional['StorageBackend'] = None,