feat: add type hints checking for callable functions

- Introduced `checking_type_hints_for_callable` function to validate the presence of type hints in callable functions, including return type.
- Added `TypeHintsNotProvidedError` for handling missing type hints.
- Implemented unit tests to verify behavior:
  - Test for functions missing return type hints.
  - Test for functions with no arguments.
  - Test for correctly provided type hints.
  - Test for missing and mismatched argument type hints.

Author: William-W-Chen

py_spring/core/utils.py

@@ -1,7 +1,7 @@
 import importlib.util
 from inspect import isclass
 from pathlib import Path
-from typing import Iterable, Type
+from typing import Any, Callable, Iterable, Optional, Type, get_type_hints
 
 from loguru import logger
 
@@ -75,3 +75,24 @@ def dynamically_import_modules(
                 returned_target_classes.add(loaded_class)
 
     return returned_target_classes
+
+
+class TypeHintsNotProvidedError(Exception): ...
+
+def checking_type_hints_for_callable(func: Callable[..., Any]) -> None:
+    RETURN_ID = "return"
+    
+    argument_count = func.__code__.co_argcount + 1 # plue one is for return type, return type is not included in co_argcount
+    annotations = func.__annotations__
+    args_type_hints = get_type_hints(func)
+    full_type_hints = {**annotations, **args_type_hints}
+
+    if RETURN_ID not in full_type_hints:
+        raise TypeHintsNotProvidedError("Type hints for 'return type' not provided for the function")
+    if argument_count == 0:
+        return 
+    if len(full_type_hints) == 0:
+        raise TypeHintsNotProvidedError(f"Type hints not provided for the function, number of arguments: {argument_count} and type hints: {full_type_hints}")
+    
+    if len(full_type_hints) != argument_count:
+        raise TypeHintsNotProvidedError(f"Number of type hints does not match the number of arguments in the function: {full_type_hints}, number of arguments: {argument_count}")

tests/test_utils.py

@@ -0,0 +1,40 @@
+
+
+import pytest
+from py_spring.core.utils import checking_type_hints_for_callable, TypeHintsNotProvidedError
+
+
+class TestFrameworkUtils:
+
+    def test_function_with_argument_type_hints_but_no_return_type(self):
+        def test_func(a: int, b: str):
+            pass  # No return type hint
+        with pytest.raises(TypeHintsNotProvidedError, match="Type hints for 'return type' not provided for the function"):
+            checking_type_hints_for_callable(test_func)
+
+    def test_function_with_no_arguments(self):
+        def test_func() -> None:
+            pass
+        # No exception should be raised for a function with no arguments
+        checking_type_hints_for_callable(test_func)
+
+    def test_function_with_correct_type_hints(self):
+        def test_func(a: int, b: str) -> None:
+            pass
+        # No exception should be raised
+        checking_type_hints_for_callable(test_func)
+
+    def test_function_with_no_type_hints(self):
+        def test_func(a, b) -> None:
+            pass
+        with pytest.raises(TypeHintsNotProvidedError, match="Number of type hints does not match the number of arguments"):
+            checking_type_hints_for_callable(test_func)
+
+    def test_function_with_mismatched_type_hints(self):
+        def test_func(a: int, b, c) -> None:
+            pass
+        # Intentionally using only one type hint
+        
+        with pytest.raises(TypeHintsNotProvidedError, match="Number of type hints does not match the number of arguments in the function"):
+            checking_type_hints_for_callable(test_func)
+