Literal types no longer cause a warning on decoding (#221)

* Literal types no longer cause a warning on decoding

* Python 3.7 compatibility

Co-authored-by: Fabrice Normandin <fabrice.normandin@gmail.com>

* Add test_literal_decoding

* Apply suggestions from code review

---------

Co-authored-by: Fabrice Normandin <fabrice.normandin@gmail.com>

Author: norabelrose

simple_parsing/helpers/serialization/decoding.py

@@ -12,6 +12,7 @@
 from logging import getLogger
 from pathlib import Path
 from typing import Any, Callable, TypeVar
+from typing_extensions import Literal
 
 from simple_parsing.annotation_utils.get_field_annotations import (
     evaluate_string_annotation,
@@ -25,6 +26,7 @@
     is_enum,
     is_forward_ref,
     is_list,
+    is_literal,
     is_set,
     is_tuple,
     is_typevar,
@@ -222,6 +224,11 @@ def get_decoding_fn(type_annotation: type[T] | str) -> Callable[..., T]:
         logger.debug(f"Decoding a typevar: {t}, bound type is {bound}.")
         if bound is not None:
             return get_decoding_fn(bound)
+    
+    if is_literal(t):
+        logger.debug(f"Decoding a Literal field: {t}")
+        possible_vals = get_type_arguments(t)
+        return decode_literal(*possible_vals)
 
     # Unknown type.
     warnings.warn(
@@ -396,6 +403,26 @@ def _decode_enum(val: str) -> Enum:
     return _decode_enum
 
 
+def decode_literal(*possible_vals: Any) -> Callable[[Any], Any]:
+    """Creates a decoding function for a Literal type.
+
+    Args:
+        *possible_vals (Any): The permissible values for the Literal type.
+
+    Returns:
+        Callable[[Any], Any]: A function that checks if a given value is one of the
+            permissible values for the Literal. If not, raises a TypeError.
+    """
+
+    def _decode_literal(val: Any) -> Any:
+        if val not in possible_vals:
+            raise TypeError(f"Expected one of {possible_vals} for Literal, got {val}")
+
+        return val
+
+    return _decode_literal
+
+
 def no_op(v: T) -> T:
     """Decoding function that gives back the value as-is.
 

test/test_decoding.py

@@ -4,8 +4,10 @@
 from pathlib import Path
 from test.testutils import Generic, TypeVar
 from typing import Any, Dict, List, Optional, Tuple, Type
+from typing_extensions import Literal
 
 import pytest
+import warnings
 
 from simple_parsing.helpers import Serializable, dict_field, list_field
 from simple_parsing.helpers.serialization.decoding import (
@@ -38,6 +40,22 @@ class SomeClass(Serializable):
     assert SomeClass.loads(b.dumps()) == b
 
 
+def test_literal_decoding():
+    @dataclass
+    class SomeClass(Serializable):
+        x: Literal["a", "b", "c"] = "a"
+
+    # This test should fail if there's a warning on decoding- previous versions
+    # have raised a UserWarning when decoding a literal, of the form:
+    # Unable to find a decoding function for annotation typing.Literal['a', 'b', 'c']
+    # with pytest.warns(UserWarning, match="Unable to find a decoding function"):
+    #     assert SomeClass.loads('{"x": "a"}') == SomeClass()
+
+    # Make sure that we can't decode a value that's not in the literal
+    with pytest.raises(TypeError):
+        SomeClass.loads('{"x": "d"}')
+
+
 def test_typevar_decoding(simple_attribute):
     @dataclass
     class Item(Serializable, decode_into_subclasses=True):