Remove all uses of "from ctypes import *"

Author: moreati

ci/cbindgen.py

@@ -17,7 +17,6 @@ def __init__(self):
         self.ret += '# This is a procedurally generated file, DO NOT EDIT\n'
         self.ret += '# instead edit `./ci/cbindgen.py` at the root of the repo\n'
         self.ret += '\n'
-        self.ret += 'from ctypes import *\n'
         self.ret += 'import ctypes\n'
         self.ret += 'from typing import Any\n'
         self.ret += 'from enum import Enum, auto\n'

wasmtime/_bindings.py

@@ -3,7 +3,6 @@
 # This is a procedurally generated file, DO NOT EDIT
 # instead edit `./ci/cbindgen.py` at the root of the repo
 
-from ctypes import *
 import ctypes
 from typing import Any
 from enum import Enum, auto

wasmtime/_config.py

@@ -1,5 +1,4 @@
 from . import _ffi as ffi
-from ctypes import *
 import ctypes
 from wasmtime import WasmtimeError, Managed
 import typing
@@ -223,7 +222,7 @@ def cache(self, enabled: typing.Union[bool, str]) -> None:
             error = ffi.wasmtime_config_cache_config_load(self.ptr(), None)
         elif isinstance(enabled, str):
             error = ffi.wasmtime_config_cache_config_load(self.ptr(),
-                                                          c_char_p(enabled.encode('utf-8')))
+                                                          ctypes.c_char_p(enabled.encode('utf-8')))
         else:
             raise TypeError("expected string or bool")
         if error:

wasmtime/_ffi.py

@@ -1,4 +1,3 @@
-from ctypes import *
 from pathlib import Path
 import ctypes
 import sys
@@ -34,49 +33,49 @@
 
 filename = Path(__file__).parent / (sys_platform + '-' + machine) / libname
 
-dll = cdll.LoadLibrary(str(filename))
-
-WASM_I32 = c_uint8(0)
-WASM_I64 = c_uint8(1)
-WASM_F32 = c_uint8(2)
-WASM_F64 = c_uint8(3)
-WASM_ANYREF = c_uint8(128)
-WASM_FUNCREF = c_uint8(129)
-# WASM_V128 = c_uint8(4)
-
-WASMTIME_I32 = c_uint8(0)
-WASMTIME_I64 = c_uint8(1)
-WASMTIME_F32 = c_uint8(2)
-WASMTIME_F64 = c_uint8(3)
-WASMTIME_V128 = c_uint8(4)
-WASMTIME_FUNCREF = c_uint8(5)
-WASMTIME_EXTERNREF = c_uint8(6)
-
-WASM_CONST = c_uint8(0)
-WASM_VAR = c_uint8(1)
-
-WASMTIME_EXTERN_FUNC = c_uint8(0)
-WASMTIME_EXTERN_GLOBAL = c_uint8(1)
-WASMTIME_EXTERN_TABLE = c_uint8(2)
-WASMTIME_EXTERN_MEMORY = c_uint8(3)
-WASMTIME_EXTERN_SHAREDMEMORY = c_uint8(4)
-WASMTIME_EXTERN_INSTANCE = c_uint8(4)
-WASMTIME_EXTERN_MODULE = c_uint8(5)
+dll = ctypes.cdll.LoadLibrary(str(filename))
+
+WASM_I32 = ctypes.c_uint8(0)
+WASM_I64 = ctypes.c_uint8(1)
+WASM_F32 = ctypes.c_uint8(2)
+WASM_F64 = ctypes.c_uint8(3)
+WASM_ANYREF = ctypes.c_uint8(128)
+WASM_FUNCREF = ctypes.c_uint8(129)
+# WASM_V128 = ctypes.c_uint8(4)
+
+WASMTIME_I32 = ctypes.c_uint8(0)
+WASMTIME_I64 = ctypes.c_uint8(1)
+WASMTIME_F32 = ctypes.c_uint8(2)
+WASMTIME_F64 = ctypes.c_uint8(3)
+WASMTIME_V128 = ctypes.c_uint8(4)
+WASMTIME_FUNCREF = ctypes.c_uint8(5)
+WASMTIME_EXTERNREF = ctypes.c_uint8(6)
+
+WASM_CONST = ctypes.c_uint8(0)
+WASM_VAR = ctypes.c_uint8(1)
+
+WASMTIME_EXTERN_FUNC = ctypes.c_uint8(0)
+WASMTIME_EXTERN_GLOBAL = ctypes.c_uint8(1)
+WASMTIME_EXTERN_TABLE = ctypes.c_uint8(2)
+WASMTIME_EXTERN_MEMORY = ctypes.c_uint8(3)
+WASMTIME_EXTERN_SHAREDMEMORY = ctypes.c_uint8(4)
+WASMTIME_EXTERN_INSTANCE = ctypes.c_uint8(4)
+WASMTIME_EXTERN_MODULE = ctypes.c_uint8(5)
 
 WASMTIME_FUNCREF_NULL = (1 << 64) - 1
 
 
-class wasm_ref_t(Structure):
+class wasm_ref_t(ctypes.Structure):
     pass
 
 
-class wasm_val_union(Union):
+class wasm_val_union(ctypes.Union):
     _fields_ = [
-        ("i32", c_int32),
-        ("i64", c_int64),
-        ("f32", c_float),
-        ("f64", c_double),
-        ("ref", POINTER(wasm_ref_t)),
+        ("i32", ctypes.c_int32),
+        ("i64", ctypes.c_int64),
+        ("f32", ctypes.c_float),
+        ("f64", ctypes.c_double),
+        ("ref", ctypes.POINTER(wasm_ref_t)),
     ]
 
     i32: int
@@ -86,8 +85,8 @@ class wasm_val_union(Union):
     ref: "typing.Union[ctypes._Pointer[wasm_ref_t], None]"
 
 
-class wasm_val_t(Structure):
-    _fields_ = [("kind", c_uint8), ("of", wasm_val_union)]
+class wasm_val_t(ctypes.Structure):
+    _fields_ = [("kind", ctypes.c_uint8), ("of", wasm_val_union)]
 
     kind: int
     of: wasm_val_union
@@ -97,23 +96,23 @@ class wasm_val_t(Structure):
 
 
 def to_bytes(vec: wasm_byte_vec_t) -> bytearray:
-    ty = c_uint8 * vec.size
-    return bytearray(ty.from_address(addressof(vec.data.contents)))
+    ty = ctypes.c_uint8 * vec.size
+    return bytearray(ty.from_address(ctypes.addressof(vec.data.contents)))
 
 
 def to_str(vec: wasm_byte_vec_t) -> str:
     return to_bytes(vec).decode("utf-8")
 
 
 def to_str_raw(ptr: "ctypes._Pointer", size: int) -> str:
-    return string_at(ptr, size).decode("utf-8")
+    return ctypes.string_at(ptr, size).decode("utf-8")
 
 
 def str_to_name(s: str, trailing_nul: bool = False) -> wasm_byte_vec_t:
     if not isinstance(s, str):
         raise TypeError("expected a string")
     s_bytes = s.encode('utf8')
-    buf = cast(create_string_buffer(s_bytes), POINTER(c_uint8))
+    buf = ctypes.cast(ctypes.create_string_buffer(s_bytes), ctypes.POINTER(ctypes.c_uint8))
     if trailing_nul:
         extra = 1
     else:

wasmtime/_func.py

@@ -154,7 +154,7 @@ def get(self, name: str) -> Optional[AsExtern]:
 
         # First convert to a raw name so we can typecheck our argument
         name_bytes = name.encode('utf-8')
-        name_buf = ffi.create_string_buffer(name_bytes)
+        name_buf = ctypes.create_string_buffer(name_bytes)
 
         # Next see if we've been invalidated
         if self.__ptr is None:

wasmtime/_globals.py

@@ -1,5 +1,6 @@
+import ctypes
+
 from . import _ffi as ffi
-from ctypes import *
 from wasmtime import GlobalType, Val, WasmtimeError
 from typing import Any
 from ._store import Storelike
@@ -16,9 +17,9 @@ def __init__(self, store: Storelike, ty: GlobalType, val: Any):
         error = ffi.wasmtime_global_new(
             store._context(),
             ty.ptr(),
-            byref(val),
-            byref(global_))
-        ffi.wasmtime_val_unroot(byref(val))
+            ctypes.byref(val),
+            ctypes.byref(global_))
+        ffi.wasmtime_val_unroot(ctypes.byref(val))
         if error:
             raise WasmtimeError._from_ptr(error)
         self._global = global_
@@ -34,7 +35,7 @@ def type(self, store: Storelike) -> GlobalType:
         Gets the type of this global as a `GlobalType`
         """
 
-        ptr = ffi.wasmtime_global_type(store._context(), byref(self._global))
+        ptr = ffi.wasmtime_global_type(store._context(), ctypes.byref(self._global))
         return GlobalType._from_ptr(ptr, None)
 
     def value(self, store: Storelike) -> Any:
@@ -44,7 +45,7 @@ def value(self, store: Storelike) -> Any:
         Returns a native python type
         """
         raw = ffi.wasmtime_val_t()
-        ffi.wasmtime_global_get(store._context(), byref(self._global), byref(raw))
+        ffi.wasmtime_global_get(store._context(), ctypes.byref(self._global), ctypes.byref(raw))
         val = Val._from_raw(store, raw)
         if val.value is not None:
             return val.value
@@ -56,8 +57,8 @@ def set_value(self, store: Storelike, val: Any) -> None:
         Sets the value of this global to a new value
         """
         val = Val._convert_to_raw(store, self.type(store).content, val)
-        error = ffi.wasmtime_global_set(store._context(), byref(self._global), byref(val))
-        ffi.wasmtime_val_unroot(byref(val))
+        error = ffi.wasmtime_global_set(store._context(), ctypes.byref(self._global), ctypes.byref(val))
+        ffi.wasmtime_val_unroot(ctypes.byref(val))
         if error:
             raise WasmtimeError._from_ptr(error)
 

wasmtime/_instance.py

@@ -1,3 +1,5 @@
+import ctypes
+
 from . import _ffi as ffi
 from ctypes import POINTER, byref
 from wasmtime import Module, WasmtimeError
@@ -76,8 +78,8 @@ def __init__(self, store: Storelike, instance: Instance):
         extern_list = []
         i = 0
         item = ffi.wasmtime_extern_t()
-        name_ptr = POINTER(ffi.c_char)()
-        name_len = ffi.c_size_t(0)
+        name_ptr = POINTER(ctypes.c_char)()
+        name_len = ctypes.c_size_t(0)
         while ffi.wasmtime_instance_export_nth(
                 store._context(),
                 byref(instance._instance),

wasmtime/_linker.py

@@ -1,5 +1,4 @@
 import ctypes
-from ctypes import *
 from typing import Any
 from wasmtime import Instance, Engine, FuncType
 from wasmtime import Module, WasmtimeError, Func, Managed
@@ -49,17 +48,17 @@ def define(self, store: Storelike, module: str, name: str, item: AsExtern) -> No
         """
         raw_item = get_extern_ptr(item)
         module_bytes = module.encode('utf-8')
-        module_buf = create_string_buffer(module_bytes)
+        module_buf = ctypes.create_string_buffer(module_bytes)
         name_bytes = name.encode('utf-8')
-        name_buf = create_string_buffer(name_bytes)
+        name_buf = ctypes.create_string_buffer(name_bytes)
         error = ffi.wasmtime_linker_define(
             self.ptr(),
             store._context(),
             module_buf,
             len(module_bytes),
             name_buf,
             len(name_bytes),
-            byref(raw_item))
+            ctypes.byref(raw_item))
         if error:
             raise WasmtimeError._from_ptr(error)
 
@@ -73,9 +72,9 @@ def define_func(self, module: str, name: str, ty: FuncType, func: Callable[...,
         the linker can be used to instantiate modules in multiple stores.
         """
         module_bytes = module.encode('utf-8')
-        module_buf = create_string_buffer(module_bytes)
+        module_buf = ctypes.create_string_buffer(module_bytes)
         name_bytes = name.encode('utf-8')
-        name_buf = create_string_buffer(name_bytes)
+        name_buf = ctypes.create_string_buffer(name_bytes)
         if not isinstance(ty, FuncType):
             raise TypeError("expected a FuncType")
         idx = FUNCTIONS.allocate((func, ty.results, access_caller))
@@ -106,12 +105,12 @@ def define_instance(self, store: Storelike, name: str, instance: Instance) -> No
         if not isinstance(instance, Instance):
             raise TypeError("expected an `Instance`")
         name_bytes = name.encode('utf8')
-        name_buf = create_string_buffer(name_bytes)
+        name_buf = ctypes.create_string_buffer(name_bytes)
         error = ffi.wasmtime_linker_define_instance(self.ptr(),
                                                     store._context(),
                                                     name_buf,
                                                     len(name_bytes),
-                                                    byref(instance._instance))
+                                                    ctypes.byref(instance._instance))
         if error:
             raise WasmtimeError._from_ptr(error)
 
@@ -146,7 +145,7 @@ def define_module(self, store: Storelike, name: str, module: Module) -> None:
         if not isinstance(module, Module):
             raise TypeError("expected a `Module`")
         name_bytes = name.encode('utf-8')
-        name_buf = create_string_buffer(name_bytes)
+        name_buf = ctypes.create_string_buffer(name_bytes)
         error = ffi.wasmtime_linker_module(self.ptr(), store._context(), name_buf, len(name_bytes), module.ptr())
         if error:
             raise WasmtimeError._from_ptr(error)
@@ -162,11 +161,11 @@ def instantiate(self, store: Storelike, module: Module) -> Instance:
         Raises an error if an import of `module` hasn't been defined in this
         linker or if a trap happens while instantiating the instance.
         """
-        trap = POINTER(ffi.wasm_trap_t)()
+        trap = ctypes.POINTER(ffi.wasm_trap_t)()
         instance = ffi.wasmtime_instance_t()
         with enter_wasm(store) as trap:
             error = ffi.wasmtime_linker_instantiate(
-                self.ptr(), store._context(), module.ptr(), byref(instance), trap)
+                self.ptr(), store._context(), module.ptr(), ctypes.byref(instance), trap)
             if error:
                 raise WasmtimeError._from_ptr(error)
         return Instance._from_raw(instance)
@@ -181,10 +180,10 @@ def get_default(self, store: Storelike, name: str) -> Func:
         Raises an error if the default export wasn't present.
         """
         name_bytes = name.encode('utf-8')
-        name_buf = create_string_buffer(name_bytes)
+        name_buf = ctypes.create_string_buffer(name_bytes)
         func = ffi.wasmtime_func_t()
         error = ffi.wasmtime_linker_get_default(self.ptr(), store._context(),
-                                                name_buf, len(name_bytes), byref(func))
+                                                name_buf, len(name_bytes), ctypes.byref(func))
         if error:
             raise WasmtimeError._from_ptr(error)
         return Func._from_raw(func)
@@ -197,14 +196,14 @@ def get(self, store: Storelike, module: str, name: str) -> AsExtern:
         defined twice with different types.
         """
         module_bytes = module.encode('utf-8')
-        module_buf = create_string_buffer(module_bytes)
+        module_buf = ctypes.create_string_buffer(module_bytes)
         name_bytes = name.encode('utf-8')
-        name_buf = create_string_buffer(name_bytes)
+        name_buf = ctypes.create_string_buffer(name_bytes)
         item = ffi.wasmtime_extern_t()
         ok = ffi.wasmtime_linker_get(self.ptr(), store._context(),
                                      module_buf, len(module_bytes),
                                      name_buf, len(name_bytes),
-                                     byref(item))
+                                     ctypes.byref(item))
         if ok:
             return wrap_extern(item)
         raise WasmtimeError("item not defined in linker")