Rename InputModel and as_input_model to CreateModel and as_create_model

Author: edan-bainglass

src/aiida/cmdline/commands/cmd_code.py

@@ -40,7 +40,7 @@ def verdi_code():
 def create_code(ctx: click.Context, cls: Code, **kwargs) -> None:
     """Create a new `Code` instance."""
     try:
-        model = cls.InputModel(**kwargs)
+        model = cls.CreateModel(**kwargs)
         instance = cls.from_model(model)  # type: ignore[arg-type]
     except (TypeError, ValueError) as exception:
         echo.echo_critical(f'Failed to create instance `{cls}`: {exception}')

src/aiida/cmdline/groups/dynamic.py

@@ -97,7 +97,7 @@ def call_command(self, ctx: click.Context, cls: t.Any, non_interactive: bool, **
 
         if hasattr(cls, 'Model'):
             # The plugin defines a pydantic model: use it to validate the provided arguments
-            Model = cls.InputModel if hasattr(cls, 'InputModel') else cls.Model  # noqa: N806
+            Model = cls.CreateModel if hasattr(cls, 'CreateModel') else cls.Model  # noqa: N806
             try:
                 Model(**kwargs)
             except ValidationError as exception:
@@ -169,7 +169,7 @@ def list_options(self, entry_point: str) -> list[t.Callable[[FC], FC]]:
             options_spec = self.factory(entry_point).get_cli_options()  # type: ignore[union-attr]
             return [self.create_option(*item) for item in options_spec]
 
-        Model = cls.InputModel if hasattr(cls, 'InputModel') else cls.Model  # noqa: N806
+        Model = cls.CreateModel if hasattr(cls, 'CreateModel') else cls.Model  # noqa: N806
 
         options_spec = {}
 

src/aiida/orm/entities.py

@@ -206,41 +206,41 @@ def __pydantic_init_subclass__(cls, **kwargs: Any) -> None:
             cls.model_config['title'] = cls.__qualname__.replace('.', '')
 
         @classmethod
-        def as_input_model(cls: Type[EntityModelType]) -> Type[EntityModelType]:
-            """Return a derived model class with read-only fields removed.
+        def as_create_model(cls: Type[EntityModelType]) -> Type[EntityModelType]:
+            """Return a derived creation model class with read-only fields removed.
 
             This also removes any serializers/validators defined on those fields.
 
-            :return: The derived input model class.
+            :return: The derived creation model class.
             """
 
-            # Derive the input model from the original model
-            new_name = cls.__qualname__.replace('.Model', 'InputModel')
-            InputModel = create_model(  # noqa: N806
+            # Derive the creation model from the original model
+            new_name = cls.__qualname__.replace('.Model', 'CreateModel')
+            CreateModel = create_model(  # noqa: N806
                 new_name,
                 __base__=cls,
-                __doc__=f'Input version of {cls.__name__}.',
+                __doc__=f'Creation version of {cls.__name__}.',
             )
-            InputModel.__qualname__ = new_name
-            InputModel.__module__ = cls.__module__
+            CreateModel.__qualname__ = new_name
+            CreateModel.__module__ = cls.__module__
 
             # Identify read-only fields
             readonly_fields = [
                 name
-                for name, field in InputModel.model_fields.items()
+                for name, field in CreateModel.model_fields.items()
                 if hasattr(field, 'json_schema_extra')
                 and isinstance(field.json_schema_extra, dict)
                 and field.json_schema_extra.get('readOnly')
             ]
 
             # Remove read-only fields
             for name in readonly_fields:
-                InputModel.model_fields.pop(name, None)
-                if hasattr(InputModel, name):
-                    delattr(InputModel, name)
+                CreateModel.model_fields.pop(name, None)
+                if hasattr(CreateModel, name):
+                    delattr(CreateModel, name)
 
             # Prune field validators/serializers referring to read-only fields
-            decorators = InputModel.__pydantic_decorators__
+            decorators = CreateModel.__pydantic_decorators__
 
             def _prune_field_decorators(field_decorators: dict[str, Any]) -> dict[str, Any]:
                 return {
@@ -252,15 +252,15 @@ def _prune_field_decorators(field_decorators: dict[str, Any]) -> dict[str, Any]:
             decorators.field_validators = _prune_field_decorators(decorators.field_validators)
             decorators.field_serializers = _prune_field_decorators(decorators.field_serializers)
 
-            return InputModel
+            return CreateModel
 
     @classproperty
-    def InputModel(cls) -> Type[Model]:  # noqa: N802, N805
-        """Return the input version of the model class for this entity.
+    def CreateModel(cls) -> Type[Model]:  # noqa: N802, N805
+        """Return the creation version of the model class for this entity.
 
-        :return: The input model class, with read-only fields removed.
+        :return: The creation model class, with read-only fields removed.
         """
-        return cls.Model.as_input_model()
+        return cls.Model.as_create_model()
 
     @classmethod
     def model_to_orm_fields(cls) -> dict[str, FieldInfo]:
@@ -316,7 +316,7 @@ def to_model(
             with `exclude_to_orm=True`.
         :return: An instance of the entity's model class.
         """
-        Model = self.InputModel if unstored else self.Model  # noqa: N806
+        Model = self.CreateModel if unstored else self.Model  # noqa: N806
         fields = self._collect_model_field_values(
             repository_path=repository_path,
             serialize_repository_content=serialize_repository_content,
@@ -387,7 +387,7 @@ def from_serialized(cls, serialized: dict[str, Any], unstored: bool = False) ->
         cls._logger.warning(
             'Serialization through pydantic is still an experimental feature and might break in future releases.'
         )
-        Model = cls.InputModel if unstored else cls.Model  # noqa: N806
+        Model = cls.CreateModel if unstored else cls.Model  # noqa: N806
         return cls.from_model(Model(**serialized))
 
     @classproperty
@@ -533,7 +533,7 @@ def _collect_model_field_values(
         """
         fields: dict[str, Any] = {}
 
-        Model = self.InputModel if unstored else self.Model  # noqa: N806
+        Model = self.CreateModel if unstored else self.Model  # noqa: N806
 
         for key, field in Model.model_fields.items():
             if skip_cli_excluded and get_metadata(field, 'exclude_from_cli'):