add argument validation

Author: ZeroIntensity

setup.py

@@ -6,7 +6,7 @@
 if __name__ == "__main__":
     setup(
         name="pointers.py",
-        version="1.3.6",
+        version="1.3.7",
         author="ZeroIntensity",
         author_email="<[email protected]>",
         description="Bringing the hell of pointers to Python.",

src/pointers/__init__.py

@@ -14,6 +14,7 @@
     DereferenceError,
     FreedMemoryError,
     InvalidSizeError,
+    InvalidBindingParameter,
 )
 from .calloc import calloc, CallocPointer
 from .frozen_pointer import to_const_ptr, FrozenPointer

src/pointers/bindings.py

@@ -20,10 +20,17 @@
     Dict,
     Type,
     Iterator,
+    Tuple,
+)
+from .c_pointer import (
+    VoidPointer,
+    TypedCPointer,
+    StructPointer,
+    _BaseCPointer,
 )
-from .c_pointer import VoidPointer, TypedCPointer, StructPointer
 import ctypes
 from . import _cstd
+from .exceptions import InvalidBindingParameter
 
 if TYPE_CHECKING:
     from .struct import Struct
@@ -153,14 +160,12 @@ def _not_null(data: Optional[T]) -> T:
 StructMap = Dict[Type[ctypes.Structure], Type["Struct"]]
 
 
-def _base(
+def _decode_response(
+    res: Any,
+    struct_map: StructMap,
     fn: "ctypes._NamedFuncPointer",
-    *args,
-    map_extra: Optional[StructMap] = None,
 ) -> Any:
-    res = fn(*args)
     res_typ = type(res)
-    struct_map: StructMap = {**STRUCT_MAP, **(map_extra or {})}
 
     if res_typ.__name__.startswith("LP_"):
         struct_type = struct_map.get(getattr(_cstd, res_typ.__name__[3:]))
@@ -185,7 +190,50 @@ def _base(
     return res
 
 
+def _validate_args(
+    args: Tuple[Any, ...],
+    fn: "ctypes._NamedFuncPointer",
+) -> None:
+    if not fn.argtypes:
+        return
+
+    for index, (value, typ) in enumerate(zip(args, fn.argtypes)):
+        n_type = VoidPointer.get_py(typ)
+
+        if not isinstance(value, n_type):
+            v_type = type(value)
+
+            if ((v_type is ctypes.c_char_p) and (n_type is bytes)) or (
+                issubclass(v_type, _BaseCPointer) and (typ is ctypes.c_void_p)
+            ):
+                continue
+
+            raise InvalidBindingParameter(
+                f"argument {index + 1} got invalid type: expected {n_type.__name__}, got {v_type.__name__}"  # noqa
+            )
+
+
+def _base(
+    fn: "ctypes._NamedFuncPointer",
+    *args,
+    map_extra: Optional[StructMap] = None,
+) -> Any:
+    _validate_args(args, fn)
+    res = fn(*args)
+
+    return _decode_response(
+        res,
+        {**STRUCT_MAP, **(map_extra or {})},
+        fn,
+    )
+
+
 def _make_char_pointer(data: StringLike) -> Union[bytes, ctypes.c_char_p]:
+    if type(data) not in {VoidPointer, str, bytes}:
+        raise InvalidBindingParameter(
+            f"expected a string-like object, got {repr(data)}"  # noqa
+        )
+
     if isinstance(data, bytes):
         return data
 

src/pointers/c_pointer.py

@@ -10,7 +10,7 @@
     TYPE_CHECKING,
     Union,
     Tuple,
-    Iterator
+    Iterator,
 )
 from .exceptions import InvalidSizeError
 from _pointers import add_ref, remove_ref
@@ -147,7 +147,7 @@ def is_mappable(cls, typ: Any) -> bool:
             return False
 
     @staticmethod
-    def get_py(data: Type["ctypes._CData"]) -> Type:
+    def get_py(data: Type["ctypes._CData"]) -> type:
         """Map the specified C type to a Python type."""
         types: Dict[Type["ctypes._CData"], type] = {
             ctypes.c_bool: bool,
@@ -223,7 +223,7 @@ def __init__(
         data_type: Type[T],
         size: int,
         alternate_method: bool = True,
-        decref: bool = True
+        decref: bool = True,
     ):
         self._alt = alternate_method
         super().__init__(address, size)
@@ -241,8 +241,8 @@ def dereference(self) -> T:
         ctype = self.get_mapped(self.type)
         ptr = (
             ctype.from_address(self.address)
-            if not self._alt else
-            ctype(self.address)
+            if not self._alt
+            else ctype(self.address)  # fmt: off
         )
         return ptr.value  # type: ignore
 
@@ -267,12 +267,7 @@ def __del__(self):
 
 def cast(ptr: VoidPointer, data_type: Type[T]) -> TypedCPointer[T]:
     """Cast a void pointer to a typed pointer."""
-    return TypedCPointer(
-        ptr.address,
-        data_type,
-        ptr.size,
-        decref=False
-    )
+    return TypedCPointer(ptr.address, data_type, ptr.size, decref=False)
 
 
 def to_c_ptr(data: T) -> TypedCPointer[T]:
@@ -285,12 +280,7 @@ def to_c_ptr(data: T) -> TypedCPointer[T]:
     address = ctypes.addressof(ct)
     typ = type(data)
 
-    return TypedCPointer(
-        address,
-        typ,
-        ctypes.sizeof(ct),
-        False
-    )
+    return TypedCPointer(address, typ, ctypes.sizeof(ct), False)
 
 
 def to_struct_ptr(struct: A) -> StructPointer[A]:

src/pointers/exceptions.py

@@ -6,6 +6,7 @@
     "DereferenceError",
     "FreedMemoryError",
     "InvalidSizeError",
+    "InvalidBindingParameter",
 )  # noqa
 
 
@@ -49,3 +50,9 @@ class InvalidSizeError(Exception):
     """Raised when trying to move an object of the wrong size to an allocation."""  # noqa
 
     pass
+
+
+class InvalidBindingParameter(Exception):
+    """Raised when an invalid type is passed to the"""
+
+    pass