refactor(c_types): Enable setting the numeric C type from CAny

Enable setting the C type for numeric type wrappers from the `CAny`
adapter class. This allows functions that use `CAny`, instead of the
type-specific `C*` classes, to specify the C types that will be used to
represent numeric Python types.

PR: #29
Signed-off-by: Kostis Papazafeiropoulos <papazof@gmail.com>
Reviewed-by: Anastassios Nanos <ananos@nubificus.co.uk>
Approved-by: Anastassios Nanos <ananos@nubificus.co.uk>

Author: papazof

vaccel/_c_types/types.py

@@ -75,13 +75,18 @@ class CAny(CType):
         _wrapped (CType): The wrapped C object.
     """
 
-    def __init__(self, obj: Any):
+    def __init__(self, obj: Any, *, precision: str | None = None):
         """Initializes a new `CAny` object.
 
         Args:
             obj: The python object to be wrapped as a C type.
+            precision: The C type that will be used to represent the python
+                object type, if the type is numeric.
         """
-        self._wrapped = to_ctype(obj)
+        if precision is not None:
+            self._wrapped = to_ctype(obj, precision=precision)
+        else:
+            self._wrapped = to_ctype(obj)
 
     def _init_c_obj(self):
         msg = "CAny is a generic adapter, not meant for initialization."
@@ -111,11 +116,13 @@ def __repr__(self):
 
 
 @singledispatch
-def to_ctype(value: Any):
+def to_ctype(value: Any, *, precision: str | None = None):
+    _ = precision
     msg = f"No CType wrapper registered for {type(value)}"
     raise TypeError(msg)
 
 
 @to_ctype.register
-def _(value: CType):
+def _(value: CType, *, precision: str | None = None):
+    _ = precision
     return value

vaccel/_c_types/wrappers/cbytes.py

@@ -85,6 +85,8 @@ def __eq__(self, other: "CBytes | bytes | bytearray | memoryview"):
             return self._data == other
         return NotImplemented
 
+    __hash__ = None
+
     def __bytes__(self):
         return bytes(self._data)
 
@@ -102,10 +104,12 @@ def __repr__(self):
 
 
 @to_ctype.register
-def _(value: bytes):
+def _(value: bytes, *, precision: str | None = None):
+    _ = precision
     return CBytes(value)
 
 
 @to_ctype.register
-def _(value: bytearray):
+def _(value: bytearray, *, precision: str | None = None):
+    _ = precision
     return CBytes(value)

vaccel/_c_types/wrappers/cfloat.py

@@ -2,6 +2,8 @@
 
 """C type interface for `float` objects."""
 
+from typing import Final
+
 from vaccel._c_types.types import CType, to_ctype
 from vaccel._libvaccel import ffi
 from vaccel.error import NullPointerError
@@ -22,15 +24,18 @@ class CFloat(CType):
         _ctype_str (str): The actual string that is used for the C type.
     """
 
+    _SUPPORTED_PRECISIONS: Final[set[str]] = {"float", "double"}
+
     def __init__(self, value: float, precision: str = "float"):
         """Initializes a new `CFloat` object.
 
         Args:
             value: The float to be wrapped.
             precision: The C type that will be used to represent the float.
         """
-        if precision not in ("float", "double"):
-            msg = "precision must be 'float' or 'double'"
+        if precision not in self._SUPPORTED_PRECISIONS:
+            supported = ", ".join(str(d) for d in self._SUPPORTED_PRECISIONS)
+            msg = f"Unsupported precision: {precision}. Supported: {supported}"
             raise ValueError(msg)
         self._value = float(value)
         self._precision = precision
@@ -158,5 +163,5 @@ def __repr__(self):
 
 
 @to_ctype.register
-def _(value: float):
-    return CFloat(value)
+def _(value: float, *, precision: str | None = "float"):
+    return CFloat(value, precision)

vaccel/_c_types/wrappers/cint.py

@@ -2,6 +2,8 @@
 
 """C type interface for `int` objects."""
 
+from typing import Final
+
 from vaccel._c_types.types import CType, to_ctype
 from vaccel._libvaccel import ffi
 from vaccel.error import NullPointerError
@@ -22,16 +24,33 @@ class CInt(CType):
         _ctype_str (str): The actual string that is used for the C type.
     """
 
+    _SUPPORTED_PRECISIONS: Final[set[str]] = {
+        "int",
+        "int8_t",
+        "int16_t",
+        "int32_t",
+        "int64_t",
+        "unsigned",
+        "unsigned int",
+        "uint8_t",
+        "uint16_t",
+        "uint32_t",
+        "uint64_t",
+    }
+
     def __init__(self, value: int, precision: str = "int"):
         """Initializes a new `CInt` object.
 
         Args:
             value: The int to be wrapped.
             precision: The C type that will be used to represent the int.
         """
+        if precision not in self._SUPPORTED_PRECISIONS:
+            supported = ", ".join(str(d) for d in self._SUPPORTED_PRECISIONS)
+            msg = f"Unsupported precision: {precision}. Supported: {supported}"
+            raise ValueError(msg)
         self._value = int(value)
         self._precision = precision
-        # TODO: validate user input  # noqa: FIX002
         self._ctype_str = self._precision
         super().__init__()
 
@@ -156,5 +175,5 @@ def __repr__(self):
 
 
 @to_ctype.register
-def _(value: int):
-    return CInt(value)
+def _(value: int, *, precision: str | None = "int"):
+    return CInt(value, precision)

vaccel/_c_types/wrappers/clist.py

@@ -218,5 +218,6 @@ def __repr__(self):
 
 @to_ctype.register(tuple)
 @to_ctype.register(list)
-def _(value: list):
+def _(value: list, *, precision: str | None = None):
+    _ = precision
     return CList(value)

vaccel/_c_types/wrappers/cnumpyarray.py

@@ -152,5 +152,6 @@ def is_contiguous(self) -> bool:
 if HAS_NUMPY:
 
     @to_ctype.register
-    def _(value: np.ndarray):
+    def _(value: np.ndarray, *, precision: str | None = None):
+        _ = precision
         return CNumpyArray(value)

vaccel/_c_types/wrappers/cstr.py

@@ -90,6 +90,8 @@ def __eq__(self, other: "CStr | str"):
             return self._value == other
         return NotImplemented
 
+    __hash__ = None
+
     def __repr__(self):
         try:
             c_ptr = (
@@ -104,10 +106,12 @@ def __repr__(self):
 
 
 @to_ctype.register
-def _(value: str):
+def _(value: str, *, precision: str | None = None):
+    _ = precision
     return CStr(value)
 
 
 @to_ctype.register
-def _(value: Path):
+def _(value: Path, *, precision: str | None = None):
+    _ = precision
     return CStr(value)