fix for issue-60

ormar/models/metaclass.py

@@ -214,7 +214,9 @@ def populate_pydantic_default_values(attrs: Dict) -> Tuple[Dict, Dict]:
         field.name = field_name
         attrs = populate_default_pydantic_field_value(field, field_name, attrs)
         model_fields[field_name] = field
-        attrs["__annotations__"][field_name] = field.__type__
+        attrs["__annotations__"][field_name] = (
+            field.__type__ if not field.nullable else Optional[field.__type__]
+        )
     return attrs, model_fields
 
 

ormar/models/model.py

@@ -104,6 +104,9 @@ class Model(NewBaseModel):
 
         instance: Optional[T] = None
         if item.get(cls.Meta.pkname, None) is not None:
+            item["__excluded__"] = cls.get_names_to_exclude(
+                fields=fields, exclude_fields=exclude_fields
+            )
             instance = cls(**item)
             instance.set_save_status(True)
         else:

ormar/models/modelproxy.py

@@ -124,6 +124,36 @@ class ModelTableProxy:
         }
         return self_fields
 
+    @classmethod
+    def get_names_to_exclude(
+        cls,
+        fields: Optional[Union[Dict, Set]] = None,
+        exclude_fields: Optional[Union[Dict, Set]] = None,
+    ) -> Set:
+        fields_names = cls.extract_db_own_fields()
+        if fields and fields is not Ellipsis:
+            fields_to_keep = {name for name in fields if name in fields_names}
+        else:
+            fields_to_keep = fields_names
+
+        fields_to_exclude = fields_names - fields_to_keep
+
+        if isinstance(exclude_fields, Set):
+            fields_to_exclude = fields_to_exclude.union(
+                {name for name in exclude_fields if name in fields_names}
+            )
+        elif isinstance(exclude_fields, Dict):
+            new_to_exclude = {
+                name
+                for name in exclude_fields
+                if name in fields_names and exclude_fields[name] is Ellipsis
+            }
+            fields_to_exclude = fields_to_exclude.union(new_to_exclude)
+
+        fields_to_exclude = fields_to_exclude - {cls.Meta.pkname}
+
+        return fields_to_exclude
+
     @classmethod
     def substitute_models_with_pks(cls, model_dict: Dict) -> Dict:  # noqa  CCR001
         for field in cls.extract_related_names():

ormar/models/newbasemodel.py

@@ -92,11 +92,13 @@ class NewBaseModel(
         )
 
         pk_only = kwargs.pop("__pk_only__", False)
+        excluded: Set[str] = kwargs.pop("__excluded__", set())
+
         if "pk" in kwargs:
             kwargs[self.Meta.pkname] = kwargs.pop("pk")
         # build the models to set them and validate but don't register
         try:
-            new_kwargs = {
+            new_kwargs: Dict[str, Any] = {
                 k: self._convert_json(
                     k,
                     self.Meta.model_fields[k].expand_relationship(
@@ -111,6 +113,11 @@ class NewBaseModel(
                 f"Unknown field '{e.args[0]}' for model {self.get_name(lower=False)}"
             )
 
+        # explicitly set None to excluded fields with default
+        # as pydantic populates them with default
+        for field_to_nullify in excluded:
+            new_kwargs[field_to_nullify] = None
+
         values, fields_set, validation_error = pydantic.validate_model(
             self, new_kwargs  # type: ignore
         )