Eliminate remaining "from ... import *" lines in wasmtime package

There are still instances of "from wasmtime import *" in the test suite

Author: moreati

wasmtime/_config.py

@@ -1,8 +1,9 @@
-from . import _ffi as ffi
 import ctypes
 from wasmtime import WasmtimeError, Managed
 import typing
 
+from . import _bindings
+
 
 def setter_property(fset: typing.Callable) -> property:
     prop = property(fset=fset)
@@ -12,7 +13,7 @@ def setter_property(fset: typing.Callable) -> property:
     return prop
 
 
-class Config(Managed["ctypes._Pointer[ffi.wasm_config_t]"]):
+class Config(Managed["ctypes._Pointer[_bindings.wasm_config_t]"]):
     """
     Global configuration, used to create an `Engine`.
 
@@ -21,10 +22,10 @@ class Config(Managed["ctypes._Pointer[ffi.wasm_config_t]"]):
     """
 
     def __init__(self) -> None:
-        self._set_ptr(ffi.wasm_config_new())
+        self._set_ptr(_bindings.wasm_config_new())
 
-    def _delete(self, ptr: "ctypes._Pointer[ffi.wasm_config_t]") -> None:
-        ffi.wasm_config_delete(ptr)
+    def _delete(self, ptr: "ctypes._Pointer[_bindings.wasm_config_t]") -> None:
+        _bindings.wasm_config_delete(ptr)
 
     @setter_property
     def debug_info(self, enable: bool) -> None:
@@ -35,7 +36,7 @@ def debug_info(self, enable: bool) -> None:
 
         if not isinstance(enable, bool):
             raise TypeError('expected a bool')
-        ffi.wasmtime_config_debug_info_set(self.ptr(), enable)
+        _bindings.wasmtime_config_debug_info_set(self.ptr(), enable)
 
     @setter_property
     def wasm_threads(self, enable: bool) -> None:
@@ -47,7 +48,7 @@ def wasm_threads(self, enable: bool) -> None:
 
         if not isinstance(enable, bool):
             raise TypeError('expected a bool')
-        ffi.wasmtime_config_wasm_threads_set(self.ptr(), enable)
+        _bindings.wasmtime_config_wasm_threads_set(self.ptr(), enable)
 
     @setter_property
     def wasm_tail_call(self, enable: bool) -> None:
@@ -59,7 +60,7 @@ def wasm_tail_call(self, enable: bool) -> None:
 
         if not isinstance(enable, bool):
             raise TypeError('expected a bool')
-        ffi.wasmtime_config_wasm_tail_call_set(self.ptr(), enable)
+        _bindings.wasmtime_config_wasm_tail_call_set(self.ptr(), enable)
 
     @setter_property
     def wasm_reference_types(self, enable: bool) -> None:
@@ -71,7 +72,7 @@ def wasm_reference_types(self, enable: bool) -> None:
 
         if not isinstance(enable, bool):
             raise TypeError('expected a bool')
-        ffi.wasmtime_config_wasm_reference_types_set(self.ptr(), enable)
+        _bindings.wasmtime_config_wasm_reference_types_set(self.ptr(), enable)
 
     @setter_property
     def wasm_simd(self, enable: bool) -> None:
@@ -83,7 +84,7 @@ def wasm_simd(self, enable: bool) -> None:
 
         if not isinstance(enable, bool):
             raise TypeError('expected a bool')
-        ffi.wasmtime_config_wasm_simd_set(self.ptr(), enable)
+        _bindings.wasmtime_config_wasm_simd_set(self.ptr(), enable)
 
     @setter_property
     def wasm_bulk_memory(self, enable: bool) -> None:
@@ -95,7 +96,7 @@ def wasm_bulk_memory(self, enable: bool) -> None:
 
         if not isinstance(enable, bool):
             raise TypeError('expected a bool')
-        ffi.wasmtime_config_wasm_bulk_memory_set(self.ptr(), enable)
+        _bindings.wasmtime_config_wasm_bulk_memory_set(self.ptr(), enable)
 
     @setter_property
     def wasm_multi_value(self, enable: bool) -> None:
@@ -107,7 +108,7 @@ def wasm_multi_value(self, enable: bool) -> None:
 
         if not isinstance(enable, bool):
             raise TypeError('expected a bool')
-        ffi.wasmtime_config_wasm_multi_value_set(self.ptr(), enable)
+        _bindings.wasmtime_config_wasm_multi_value_set(self.ptr(), enable)
 
     @setter_property
     def wasm_multi_memory(self, enable: bool) -> None:
@@ -119,7 +120,7 @@ def wasm_multi_memory(self, enable: bool) -> None:
 
         if not isinstance(enable, bool):
             raise TypeError('expected a bool')
-        ffi.wasmtime_config_wasm_multi_memory_set(self.ptr(), enable)
+        _bindings.wasmtime_config_wasm_multi_memory_set(self.ptr(), enable)
 
     @setter_property
     def wasm_memory64(self, enable: bool) -> None:
@@ -131,7 +132,7 @@ def wasm_memory64(self, enable: bool) -> None:
 
         if not isinstance(enable, bool):
             raise TypeError('expected a bool')
-        ffi.wasmtime_config_wasm_memory64_set(self.ptr(), enable)
+        _bindings.wasmtime_config_wasm_memory64_set(self.ptr(), enable)
 
     @setter_property
     def wasm_relaxed_simd(self, enable: bool) -> None:
@@ -143,7 +144,7 @@ def wasm_relaxed_simd(self, enable: bool) -> None:
 
         if not isinstance(enable, bool):
             raise TypeError('expected a bool')
-        ffi.wasmtime_config_wasm_relaxed_simd_set(self.ptr(), enable)
+        _bindings.wasmtime_config_wasm_relaxed_simd_set(self.ptr(), enable)
 
     @setter_property
     def wasm_relaxed_simd_deterministic(self, enable: bool) -> None:
@@ -157,7 +158,7 @@ def wasm_relaxed_simd_deterministic(self, enable: bool) -> None:
 
         if not isinstance(enable, bool):
             raise TypeError('expected a bool')
-        ffi.wasmtime_config_wasm_relaxed_simd_deterministic_set(self.ptr(), enable)
+        _bindings.wasmtime_config_wasm_relaxed_simd_deterministic_set(self.ptr(), enable)
 
     @setter_property
     def strategy(self, strategy: str) -> None:
@@ -171,35 +172,35 @@ def strategy(self, strategy: str) -> None:
         """
 
         if strategy == "auto":
-            ffi.wasmtime_config_strategy_set(self.ptr(), 0)
+            _bindings.wasmtime_config_strategy_set(self.ptr(), 0)
         elif strategy == "cranelift":
-            ffi.wasmtime_config_strategy_set(self.ptr(), 1)
+            _bindings.wasmtime_config_strategy_set(self.ptr(), 1)
         else:
             raise WasmtimeError("unknown strategy: " + str(strategy))
 
     @setter_property
     def cranelift_debug_verifier(self, enable: bool) -> None:
         if not isinstance(enable, bool):
             raise TypeError('expected a bool')
-        ffi.wasmtime_config_cranelift_debug_verifier_set(self.ptr(), enable)
+        _bindings.wasmtime_config_cranelift_debug_verifier_set(self.ptr(), enable)
 
     @setter_property
     def cranelift_opt_level(self, opt_level: str) -> None:
         if opt_level == "none":
-            ffi.wasmtime_config_cranelift_opt_level_set(self.ptr(), 0)
+            _bindings.wasmtime_config_cranelift_opt_level_set(self.ptr(), 0)
         elif opt_level == "speed":
-            ffi.wasmtime_config_cranelift_opt_level_set(self.ptr(), 1)
+            _bindings.wasmtime_config_cranelift_opt_level_set(self.ptr(), 1)
         elif opt_level == "speed_and_size":
-            ffi.wasmtime_config_cranelift_opt_level_set(self.ptr(), 2)
+            _bindings.wasmtime_config_cranelift_opt_level_set(self.ptr(), 2)
         else:
             raise WasmtimeError("unknown opt level: " + str(opt_level))
 
     @setter_property
     def profiler(self, profiler: str) -> None:
         if profiler == "none":
-            ffi.wasmtime_config_profiler_set(self.ptr(), 0)
+            _bindings.wasmtime_config_profiler_set(self.ptr(), 0)
         elif profiler == "jitdump":
-            ffi.wasmtime_config_profiler_set(self.ptr(), 1)
+            _bindings.wasmtime_config_profiler_set(self.ptr(), 1)
         else:
             raise WasmtimeError("unknown profiler: " + str(profiler))
 
@@ -219,9 +220,9 @@ def cache(self, enabled: typing.Union[bool, str]) -> None:
         if isinstance(enabled, bool):
             if not enabled:
                 raise WasmtimeError("caching cannot be explicitly disabled")
-            error = ffi.wasmtime_config_cache_config_load(self.ptr(), None)
+            error = _bindings.wasmtime_config_cache_config_load(self.ptr(), None)
         elif isinstance(enabled, str):
-            error = ffi.wasmtime_config_cache_config_load(self.ptr(),
+            error = _bindings.wasmtime_config_cache_config_load(self.ptr(),
                                                           ctypes.c_char_p(enabled.encode('utf-8')))
         else:
             raise TypeError("expected string or bool")
@@ -239,7 +240,7 @@ def epoch_interruption(self, enabled: bool) -> None:
             val = 1
         else:
             val = 0
-        ffi.wasmtime_config_epoch_interruption_set(self.ptr(), val)
+        _bindings.wasmtime_config_epoch_interruption_set(self.ptr(), val)
 
     @setter_property
     def consume_fuel(self, instances: bool) -> None:
@@ -252,7 +253,7 @@ def consume_fuel(self, instances: bool) -> None:
         """
         if not isinstance(instances, bool):
             raise TypeError('expected an bool')
-        ffi.wasmtime_config_consume_fuel_set(self.ptr(), instances)
+        _bindings.wasmtime_config_consume_fuel_set(self.ptr(), instances)
 
     @setter_property
     def parallel_compilation(self, enable: bool) -> None:
@@ -264,4 +265,4 @@ def parallel_compilation(self, enable: bool) -> None:
         """
         if not isinstance(enable, bool):
             raise TypeError('expected a bool')
-        ffi.wasmtime_config_parallel_compilation_set(self.ptr(), enable)
+        _bindings.wasmtime_config_parallel_compilation_set(self.ptr(), enable)

wasmtime/_engine.py

@@ -1,25 +1,26 @@
-from . import _ffi as ffi
 from wasmtime import Config, WasmtimeError, Managed
 from typing import Optional
 import ctypes
 
+from . import _bindings
 
-class Engine(Managed["ctypes._Pointer[ffi.wasm_engine_t]"]):
+
+class Engine(Managed["ctypes._Pointer[_bindings.wasm_engine_t]"]):
 
     def __init__(self, config: Optional[Config] = None):
         if config is None:
-            self._set_ptr(ffi.wasm_engine_new())
+            self._set_ptr(_bindings.wasm_engine_new())
         elif not isinstance(config, Config):
             raise TypeError("expected Config")
         else:
             ptr = config._consume()
-            self._set_ptr(ffi.wasm_engine_new_with_config(ptr))
+            self._set_ptr(_bindings.wasm_engine_new_with_config(ptr))
 
-    def _delete(self, ptr: "ctypes._Pointer[ffi.wasm_engine_t]") -> None:
-        ffi.wasm_engine_delete(ptr)
+    def _delete(self, ptr: "ctypes._Pointer[_bindings.wasm_engine_t]") -> None:
+        _bindings.wasm_engine_delete(ptr)
 
     def increment_epoch(self) -> None:
-        ffi.wasmtime_engine_increment_epoch(self.ptr())
+        _bindings.wasmtime_engine_increment_epoch(self.ptr())
 
     def is_pulley(self) -> bool:
-        return ffi.wasmtime_engine_is_pulley(self.ptr())
+        return _bindings.wasmtime_engine_is_pulley(self.ptr())

wasmtime/_error.py

@@ -2,26 +2,27 @@
 from . import _ffi as ffi
 import ctypes
 from typing import Optional
+
+from . import _bindings
 from wasmtime import Managed
 
 
-class WasmtimeError(Exception, Managed["ctypes._Pointer[ffi.wasmtime_error_t]"]):
+class WasmtimeError(Exception, Managed["ctypes._Pointer[_bindings.wasmtime_error_t]"]):
     __message: Optional[str]
 
     def __init__(self, message: str):
         self.__message = message
 
-    def _delete(self, ptr: "ctypes._Pointer[ffi.wasmtime_error_t]") -> None:
-        ffi.wasmtime_error_delete(ptr)
+    def _delete(self, ptr: "ctypes._Pointer[_bindings.wasmtime_error_t]") -> None:
+        _bindings.wasmtime_error_delete(ptr)
 
     @classmethod
     def _from_ptr(cls, ptr: "ctypes._Pointer") -> 'WasmtimeError':
-        from . import _ffi as ffi
-        if not isinstance(ptr, POINTER(ffi.wasmtime_error_t)):
+        if not isinstance(ptr, POINTER(_bindings.wasmtime_error_t)):
             raise TypeError("wrong pointer type")
 
         exit_code = c_int(0)
-        if ffi.wasmtime_error_exit_status(ptr, byref(exit_code)):
+        if _bindings.wasmtime_error_exit_status(ptr, byref(exit_code)):
             exit_trap: ExitTrap = ExitTrap.__new__(ExitTrap)
             exit_trap._set_ptr(ptr)
             exit_trap.__message = None
@@ -36,10 +37,10 @@ def _from_ptr(cls, ptr: "ctypes._Pointer") -> 'WasmtimeError':
     def __str__(self) -> str:
         if self.__message:
             return self.__message
-        message_vec = ffi.wasm_byte_vec_t()
-        ffi.wasmtime_error_message(self.ptr(), byref(message_vec))
+        message_vec = _bindings.wasm_byte_vec_t()
+        _bindings.wasmtime_error_message(self.ptr(), byref(message_vec))
         message = ffi.to_str(message_vec)
-        ffi.wasm_byte_vec_delete(byref(message_vec))
+        _bindings.wasm_byte_vec_delete(byref(message_vec))
         return message
 
 

wasmtime/_extern.py

@@ -1,10 +1,11 @@
+from . import _bindings
 from . import _ffi as ffi
 import ctypes
 from ._exportable import AsExtern
 from wasmtime import WasmtimeError, Managed
 
 
-def wrap_extern(ptr: ffi.wasmtime_extern_t) -> AsExtern:
+def wrap_extern(ptr: _bindings.wasmtime_extern_t) -> AsExtern:
     from wasmtime import Func, Table, Global, Memory, SharedMemory, Module, Instance
 
     if ptr.kind == ffi.WASMTIME_EXTERN_FUNC.value:
@@ -24,7 +25,7 @@ def wrap_extern(ptr: ffi.wasmtime_extern_t) -> AsExtern:
     raise WasmtimeError("unknown extern")
 
 
-def get_extern_ptr(item: AsExtern) -> ffi.wasmtime_extern_t:
+def get_extern_ptr(item: AsExtern) -> _bindings.wasmtime_extern_t:
     from wasmtime import Func, Table, Global, Memory, SharedMemory, Module, Instance
 
     if isinstance(item, Func):
@@ -45,9 +46,9 @@ def get_extern_ptr(item: AsExtern) -> ffi.wasmtime_extern_t:
         raise TypeError("expected a Func, Global, Memory, Table, Module, or Instance")
 
 
-class Extern(Managed["ctypes._Pointer[ffi.wasm_extern_t]"]):
-    def __init__(self, ptr: "ctypes._Pointer[ffi.wasm_extern_t]"):
+class Extern(Managed["ctypes._Pointer[_bindings.wasm_extern_t]"]):
+    def __init__(self, ptr: "ctypes._Pointer[_bindings.wasm_extern_t]"):
         self._set_ptr(ptr)
 
-    def _delete(self, ptr: "ctypes._Pointer[ffi.wasm_extern_t]") -> None:
-        ffi.wasm_extern_delete(ptr)
+    def _delete(self, ptr: "ctypes._Pointer[_bindings.wasm_extern_t]") -> None:
+        _bindings.wasm_extern_delete(ptr)

wasmtime/_ffi.py

@@ -92,7 +92,7 @@ class wasm_val_t(ctypes.Structure):
     of: wasm_val_union
 
 
-from ._bindings import *  # noqa
+from ._bindings import wasm_byte_vec_t  # noqa
 
 
 def to_bytes(vec: wasm_byte_vec_t) -> bytearray: