Improve load/save/to_dict (see description) (#233)

* Improve `load`/`save` functions (see desc.)

- Fixes #173
- `save` and `to_dict` now have a `save_dc_types` argument.
    - When set, this saves the types of dataclass attributes in a new
      entry in the dict. By default, this is saved in `"_type_"`.
- `load` has been improved:
    - When loading, if the `"_type_"` key is present, returns an
      instance of that type.
    - When `drop_extra_fields` is False, tries to use subclasses of
      the annotated type, rather than subclasses of Serializable.

      This means that dataclasses that don't subclass Serializable can
      still be dynamically found and used when loading a dataclass.
- `get_decoding_fn`'s `lru_cache` has been disabled. If this causes
   significant performance drops, let me know.

- Unit tests are no longer run twice (using the regular and 'simple'
  APIs). This was causing a lot of weird bugs, as some unit tests
  were leaking from one run to the other, particularly tests involving
  deserialization of dataclasses.
  - Updated the regression file names due to this

- Update some other test regression files

Signed-off-by: Fabrice Normandin <normandf@mila.quebec>

---------

Signed-off-by: Fabrice Normandin <normandf@mila.quebec>

Author: lebrice

simple_parsing/helpers/fields.py

@@ -18,7 +18,7 @@
     DEFAULT_NEGATIVE_PREFIX,
     BooleanOptionalAction,
 )
-from simple_parsing.utils import Dataclass, str2bool
+from simple_parsing.utils import DataclassT, str2bool
 
 # NOTE: backward-compatibility import because it was moved to a different file.
 from .subgroups import subgroups  # noqa: F401
@@ -344,7 +344,9 @@ def mutable_field(
 
 
 def subparsers(
-    subcommands: dict[str, type[Dataclass]], default: Dataclass | _MISSING_TYPE = MISSING, **kwargs
+    subcommands: dict[str, type[DataclassT]],
+    default: DataclassT | _MISSING_TYPE = MISSING,
+    **kwargs,
 ) -> Any:
     return field(
         metadata={

simple_parsing/helpers/serialization/decoding.py

@@ -8,7 +8,7 @@
 from collections.abc import Mapping
 from dataclasses import Field
 from enum import Enum
-from functools import lru_cache, partial
+from functools import partial
 from logging import getLogger
 from pathlib import Path
 from typing import Any, Callable, TypeVar
@@ -55,7 +55,12 @@ def decode_bool(v: Any) -> bool:
 _decoding_fns[bool] = decode_bool
 
 
-def decode_field(field: Field, raw_value: Any, containing_dataclass: type | None = None) -> Any:
+def decode_field(
+    field: Field,
+    raw_value: Any,
+    containing_dataclass: type | None = None,
+    drop_extra_fields: bool | None = None,
+) -> Any:
     """Converts a "raw" value (e.g. from json file) to the type of the `field`.
 
     When serializing a dataclass to json, all objects are converted to dicts.
@@ -84,10 +89,17 @@ def decode_field(field: Field, raw_value: Any, containing_dataclass: type | None
     if isinstance(field_type, str) and containing_dataclass:
         field_type = evaluate_string_annotation(field_type, containing_dataclass)
 
-    return get_decoding_fn(field_type)(raw_value)
+    decoding_function = get_decoding_fn(field_type)
 
+    if is_dataclass_type(field_type) and drop_extra_fields is not None:
+        # Pass the drop_extra_fields argument to the decoding function.
+        return decoding_function(raw_value, drop_extra_fields=drop_extra_fields)
 
-@lru_cache(maxsize=100)
+    return decoding_function(raw_value)
+
+
+# NOTE: Disabling the caching here might help avoid some bugs, and it's unclear if this has that
+# much of a performance impact.
 def get_decoding_fn(type_annotation: type[T] | str) -> Callable[..., T]:
     """Fetches/Creates a decoding function for the given type annotation.