1.2.0: Add support for validating Literals.

README.md

@@ -46,16 +46,21 @@ Variables without an annotation for type are not enforced.
     - Deeply nested types are supported too:
         - `dict[dict[int]]`
         - `list[set[]]`
-- Many of the `typing` (package) functions including:
-    - Standard generics:
+- Many of the `typing` (package) functions and methods including:
+    - Standard typing functions:
         - `List`, `Set`, `Dict`, `Tuple`
     - `Union`
-    - `Optional`
+    - `Optional` 
     - `Sized`
         - Essentially creates a union of: 
             - `list`, `tuple`, `dict`, `set`, `str`, `bytes`, `bytearray`, `memoryview`, `range`
         - Note: Can not have a nested type
             - Because this does not always meet the criteria for `Nested types` above
+    - `Literal`
+        - Only allow certain values to be passed. Operates slightly differently than other checks.
+        - e.g. `Literal['a', 'b']` will require any passed values that are equal (`==`) to `'a'` or `'b'`.
+            - This compares the value of the passed input and not the type of the passed input.
+        - Note: Multiple types can be passed in the same `Literal`.
     - Note: Other functions might have support, but there are not currently tests to validate them
         - Feel free to create an issue (or better yet a PR) if you want to add tests/support
 

pyproject.toml

@@ -12,7 +12,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "type_enforced"
-version = "1.1.1"
+version = "1.2.0"
 description = "A pure python type enforcer for python type annotations"
 authors = [
     {name="Connor Makowski", email="[email protected]"}

setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = type_enfoced
-version = 1.1.1
+version = 1.2.0
 description_file = README.md
 
 [options]

test/test_fn_13.py

@@ -0,0 +1,27 @@
+import type_enforced
+from typing import Literal
+
+
+@type_enforced.Enforcer
+def my_fn(a: Literal["a", "b"]):
+    pass
+
+
+success_1 = True
+try:
+    my_fn(a="a")
+    my_fn(a="b")
+except:
+    success_1 = False
+
+success_2 = False
+try:
+    my_fn(a="c")
+except Exception as e:
+    if "Type mismatch" in str(e):
+        success_2 = True
+
+if success_1 and success_2:
+    print("test_fn_13.py passed")
+else:
+    print("test_fn_13.py failed")

type_enforced/enforcer.py

@@ -1,5 +1,5 @@
 from types import FunctionType, MethodType, GenericAlias
-from typing import Type, Union, Sized
+from typing import Type, Union, Sized, Literal
 from functools import update_wrapper, wraps
 
 # Python 3.10+ has a UnionType object that is used to represent Union types
@@ -87,6 +87,14 @@ def __get_checkable_type__(self, item_annotation):
                     valid_types.update(
                         self.__get_checkable_type__(valid_type.__args__)
                     )
+                # Handle Literals
+                # Note: These will be handled separately in the self.__check_type__
+                # as the object is validated and not its type.
+                elif valid_type.__origin__ == Literal:
+                    valid_types = {
+                        Literal: {i: None for i in valid_type.__args__}
+                    }
+
                 # Handle Sized objects
                 elif valid_type == Sized:
                     valid_types = {
@@ -185,8 +193,20 @@ def __check_type__(self, obj, acceptable_types, key):
         else:
             passed_type = type(obj)
         if passed_type not in acceptable_types:
+            # Add special string to store any string to add before acceptable types
+            # in any exception message
+            pre_acceptable_types_str = ""
+            # Special check for Literals
+            if Literal in acceptable_types:
+                if obj in acceptable_types[Literal]:
+                    return
+                else:
+                    pre_acceptable_types_str = "Literal"
+                    acceptable_types = acceptable_types[Literal]
+                    passed_type = obj
+            # Raise the exception
             self.__exception__(
-                f"Type mismatch for typed variable `{key}`. Expected one of the following `{str(list(acceptable_types.keys()))}` but got `{passed_type}` instead."
+                f"Type mismatch for typed variable `{key}`. Expected one of the following `{pre_acceptable_types_str}{str(list(acceptable_types.keys()))}` but got `{passed_type}` instead."
             )
         sub_type = acceptable_types.get(passed_type)
         if sub_type is not None: