954 lines
33 KiB
Python
954 lines
33 KiB
Python
|
|
|
|
# This file was autogenerated by some hot garbage in the `uniffi` crate.
|
|
# Trust me, you don't want to mess with it!
|
|
|
|
# Common helper code.
|
|
#
|
|
# Ideally this would live in a separate .py file where it can be unittested etc
|
|
# in isolation, and perhaps even published as a re-useable package.
|
|
#
|
|
# However, it's important that the details of how this helper code works (e.g. the
|
|
# way that different builtin types are passed across the FFI) exactly match what's
|
|
# expected by the rust code on the other side of the interface. In practice right
|
|
# now that means coming from the exact some version of `uniffi` that was used to
|
|
# compile the rust component. The easiest way to ensure this is to bundle the Python
|
|
# helpers directly inline like we're doing here.
|
|
|
|
from __future__ import annotations
|
|
import os
|
|
import sys
|
|
import ctypes
|
|
import enum
|
|
import struct
|
|
import contextlib
|
|
import datetime
|
|
import threading
|
|
import itertools
|
|
import traceback
|
|
import typing
|
|
import platform
|
|
|
|
# Used for default argument values
|
|
_DEFAULT = object() # type: typing.Any
|
|
|
|
|
|
class _UniffiRustBuffer(ctypes.Structure):
|
|
_fields_ = [
|
|
("capacity", ctypes.c_uint64),
|
|
("len", ctypes.c_uint64),
|
|
("data", ctypes.POINTER(ctypes.c_char)),
|
|
]
|
|
|
|
@staticmethod
|
|
def default():
|
|
return _UniffiRustBuffer(0, 0, None)
|
|
|
|
@staticmethod
|
|
def alloc(size):
|
|
return _uniffi_rust_call(_UniffiLib.ffi_hublib_rustbuffer_alloc, size)
|
|
|
|
@staticmethod
|
|
def reserve(rbuf, additional):
|
|
return _uniffi_rust_call(_UniffiLib.ffi_hublib_rustbuffer_reserve, rbuf, additional)
|
|
|
|
def free(self):
|
|
return _uniffi_rust_call(_UniffiLib.ffi_hublib_rustbuffer_free, self)
|
|
|
|
def __str__(self):
|
|
return "_UniffiRustBuffer(capacity={}, len={}, data={})".format(
|
|
self.capacity,
|
|
self.len,
|
|
self.data[0:self.len]
|
|
)
|
|
|
|
@contextlib.contextmanager
|
|
def alloc_with_builder(*args):
|
|
"""Context-manger to allocate a buffer using a _UniffiRustBufferBuilder.
|
|
|
|
The allocated buffer will be automatically freed if an error occurs, ensuring that
|
|
we don't accidentally leak it.
|
|
"""
|
|
builder = _UniffiRustBufferBuilder()
|
|
try:
|
|
yield builder
|
|
except:
|
|
builder.discard()
|
|
raise
|
|
|
|
@contextlib.contextmanager
|
|
def consume_with_stream(self):
|
|
"""Context-manager to consume a buffer using a _UniffiRustBufferStream.
|
|
|
|
The _UniffiRustBuffer will be freed once the context-manager exits, ensuring that we don't
|
|
leak it even if an error occurs.
|
|
"""
|
|
try:
|
|
s = _UniffiRustBufferStream.from_rust_buffer(self)
|
|
yield s
|
|
if s.remaining() != 0:
|
|
raise RuntimeError("junk data left in buffer at end of consume_with_stream")
|
|
finally:
|
|
self.free()
|
|
|
|
@contextlib.contextmanager
|
|
def read_with_stream(self):
|
|
"""Context-manager to read a buffer using a _UniffiRustBufferStream.
|
|
|
|
This is like consume_with_stream, but doesn't free the buffer afterwards.
|
|
It should only be used with borrowed `_UniffiRustBuffer` data.
|
|
"""
|
|
s = _UniffiRustBufferStream.from_rust_buffer(self)
|
|
yield s
|
|
if s.remaining() != 0:
|
|
raise RuntimeError("junk data left in buffer at end of read_with_stream")
|
|
|
|
class _UniffiForeignBytes(ctypes.Structure):
|
|
_fields_ = [
|
|
("len", ctypes.c_int32),
|
|
("data", ctypes.POINTER(ctypes.c_char)),
|
|
]
|
|
|
|
def __str__(self):
|
|
return "_UniffiForeignBytes(len={}, data={})".format(self.len, self.data[0:self.len])
|
|
|
|
|
|
class _UniffiRustBufferStream:
|
|
"""
|
|
Helper for structured reading of bytes from a _UniffiRustBuffer
|
|
"""
|
|
|
|
def __init__(self, data, len):
|
|
self.data = data
|
|
self.len = len
|
|
self.offset = 0
|
|
|
|
@classmethod
|
|
def from_rust_buffer(cls, buf):
|
|
return cls(buf.data, buf.len)
|
|
|
|
def remaining(self):
|
|
return self.len - self.offset
|
|
|
|
def _unpack_from(self, size, format):
|
|
if self.offset + size > self.len:
|
|
raise InternalError("read past end of rust buffer")
|
|
value = struct.unpack(format, self.data[self.offset:self.offset+size])[0]
|
|
self.offset += size
|
|
return value
|
|
|
|
def read(self, size):
|
|
if self.offset + size > self.len:
|
|
raise InternalError("read past end of rust buffer")
|
|
data = self.data[self.offset:self.offset+size]
|
|
self.offset += size
|
|
return data
|
|
|
|
def read_i8(self):
|
|
return self._unpack_from(1, ">b")
|
|
|
|
def read_u8(self):
|
|
return self._unpack_from(1, ">B")
|
|
|
|
def read_i16(self):
|
|
return self._unpack_from(2, ">h")
|
|
|
|
def read_u16(self):
|
|
return self._unpack_from(2, ">H")
|
|
|
|
def read_i32(self):
|
|
return self._unpack_from(4, ">i")
|
|
|
|
def read_u32(self):
|
|
return self._unpack_from(4, ">I")
|
|
|
|
def read_i64(self):
|
|
return self._unpack_from(8, ">q")
|
|
|
|
def read_u64(self):
|
|
return self._unpack_from(8, ">Q")
|
|
|
|
def read_float(self):
|
|
v = self._unpack_from(4, ">f")
|
|
return v
|
|
|
|
def read_double(self):
|
|
return self._unpack_from(8, ">d")
|
|
|
|
class _UniffiRustBufferBuilder:
|
|
"""
|
|
Helper for structured writing of bytes into a _UniffiRustBuffer.
|
|
"""
|
|
|
|
def __init__(self):
|
|
self.rbuf = _UniffiRustBuffer.alloc(16)
|
|
self.rbuf.len = 0
|
|
|
|
def finalize(self):
|
|
rbuf = self.rbuf
|
|
self.rbuf = None
|
|
return rbuf
|
|
|
|
def discard(self):
|
|
if self.rbuf is not None:
|
|
rbuf = self.finalize()
|
|
rbuf.free()
|
|
|
|
@contextlib.contextmanager
|
|
def _reserve(self, num_bytes):
|
|
if self.rbuf.len + num_bytes > self.rbuf.capacity:
|
|
self.rbuf = _UniffiRustBuffer.reserve(self.rbuf, num_bytes)
|
|
yield None
|
|
self.rbuf.len += num_bytes
|
|
|
|
def _pack_into(self, size, format, value):
|
|
with self._reserve(size):
|
|
# XXX TODO: I feel like I should be able to use `struct.pack_into` here but can't figure it out.
|
|
for i, byte in enumerate(struct.pack(format, value)):
|
|
self.rbuf.data[self.rbuf.len + i] = byte
|
|
|
|
def write(self, value):
|
|
with self._reserve(len(value)):
|
|
for i, byte in enumerate(value):
|
|
self.rbuf.data[self.rbuf.len + i] = byte
|
|
|
|
def write_i8(self, v):
|
|
self._pack_into(1, ">b", v)
|
|
|
|
def write_u8(self, v):
|
|
self._pack_into(1, ">B", v)
|
|
|
|
def write_i16(self, v):
|
|
self._pack_into(2, ">h", v)
|
|
|
|
def write_u16(self, v):
|
|
self._pack_into(2, ">H", v)
|
|
|
|
def write_i32(self, v):
|
|
self._pack_into(4, ">i", v)
|
|
|
|
def write_u32(self, v):
|
|
self._pack_into(4, ">I", v)
|
|
|
|
def write_i64(self, v):
|
|
self._pack_into(8, ">q", v)
|
|
|
|
def write_u64(self, v):
|
|
self._pack_into(8, ">Q", v)
|
|
|
|
def write_float(self, v):
|
|
self._pack_into(4, ">f", v)
|
|
|
|
def write_double(self, v):
|
|
self._pack_into(8, ">d", v)
|
|
|
|
def write_c_size_t(self, v):
|
|
self._pack_into(ctypes.sizeof(ctypes.c_size_t) , "@N", v)
|
|
# A handful of classes and functions to support the generated data structures.
|
|
# This would be a good candidate for isolating in its own ffi-support lib.
|
|
|
|
class InternalError(Exception):
|
|
pass
|
|
|
|
class _UniffiRustCallStatus(ctypes.Structure):
|
|
"""
|
|
Error runtime.
|
|
"""
|
|
_fields_ = [
|
|
("code", ctypes.c_int8),
|
|
("error_buf", _UniffiRustBuffer),
|
|
]
|
|
|
|
# These match the values from the uniffi::rustcalls module
|
|
CALL_SUCCESS = 0
|
|
CALL_ERROR = 1
|
|
CALL_UNEXPECTED_ERROR = 2
|
|
|
|
@staticmethod
|
|
def default():
|
|
return _UniffiRustCallStatus(code=_UniffiRustCallStatus.CALL_SUCCESS, error_buf=_UniffiRustBuffer.default())
|
|
|
|
def __str__(self):
|
|
if self.code == _UniffiRustCallStatus.CALL_SUCCESS:
|
|
return "_UniffiRustCallStatus(CALL_SUCCESS)"
|
|
elif self.code == _UniffiRustCallStatus.CALL_ERROR:
|
|
return "_UniffiRustCallStatus(CALL_ERROR)"
|
|
elif self.code == _UniffiRustCallStatus.CALL_UNEXPECTED_ERROR:
|
|
return "_UniffiRustCallStatus(CALL_UNEXPECTED_ERROR)"
|
|
else:
|
|
return "_UniffiRustCallStatus(<invalid code>)"
|
|
|
|
def _uniffi_rust_call(fn, *args):
|
|
# Call a rust function
|
|
return _uniffi_rust_call_with_error(None, fn, *args)
|
|
|
|
def _uniffi_rust_call_with_error(error_ffi_converter, fn, *args):
|
|
# Call a rust function and handle any errors
|
|
#
|
|
# This function is used for rust calls that return Result<> and therefore can set the CALL_ERROR status code.
|
|
# error_ffi_converter must be set to the _UniffiConverter for the error class that corresponds to the result.
|
|
call_status = _UniffiRustCallStatus.default()
|
|
|
|
args_with_error = args + (ctypes.byref(call_status),)
|
|
result = fn(*args_with_error)
|
|
_uniffi_check_call_status(error_ffi_converter, call_status)
|
|
return result
|
|
|
|
def _uniffi_check_call_status(error_ffi_converter, call_status):
|
|
if call_status.code == _UniffiRustCallStatus.CALL_SUCCESS:
|
|
pass
|
|
elif call_status.code == _UniffiRustCallStatus.CALL_ERROR:
|
|
if error_ffi_converter is None:
|
|
call_status.error_buf.free()
|
|
raise InternalError("_uniffi_rust_call_with_error: CALL_ERROR, but error_ffi_converter is None")
|
|
else:
|
|
raise error_ffi_converter.lift(call_status.error_buf)
|
|
elif call_status.code == _UniffiRustCallStatus.CALL_UNEXPECTED_ERROR:
|
|
# When the rust code sees a panic, it tries to construct a _UniffiRustBuffer
|
|
# with the message. But if that code panics, then it just sends back
|
|
# an empty buffer.
|
|
if call_status.error_buf.len > 0:
|
|
msg = _UniffiConverterString.lift(call_status.error_buf)
|
|
else:
|
|
msg = "Unknown rust panic"
|
|
raise InternalError(msg)
|
|
else:
|
|
raise InternalError("Invalid _UniffiRustCallStatus code: {}".format(
|
|
call_status.code))
|
|
|
|
def _uniffi_trait_interface_call(call_status, make_call, write_return_value):
|
|
try:
|
|
return write_return_value(make_call())
|
|
except Exception as e:
|
|
call_status.code = _UniffiRustCallStatus.CALL_UNEXPECTED_ERROR
|
|
call_status.error_buf = _UniffiConverterString.lower(repr(e))
|
|
|
|
def _uniffi_trait_interface_call_with_error(call_status, make_call, write_return_value, error_type, lower_error):
|
|
try:
|
|
try:
|
|
return write_return_value(make_call())
|
|
except error_type as e:
|
|
call_status.code = _UniffiRustCallStatus.CALL_ERROR
|
|
call_status.error_buf = lower_error(e)
|
|
except Exception as e:
|
|
call_status.code = _UniffiRustCallStatus.CALL_UNEXPECTED_ERROR
|
|
call_status.error_buf = _UniffiConverterString.lower(repr(e))
|
|
class _UniffiHandleMap:
|
|
"""
|
|
A map where inserting, getting and removing data is synchronized with a lock.
|
|
"""
|
|
|
|
def __init__(self):
|
|
# type Handle = int
|
|
self._map = {} # type: Dict[Handle, Any]
|
|
self._lock = threading.Lock()
|
|
self._counter = itertools.count()
|
|
|
|
def insert(self, obj):
|
|
with self._lock:
|
|
handle = next(self._counter)
|
|
self._map[handle] = obj
|
|
return handle
|
|
|
|
def get(self, handle):
|
|
try:
|
|
with self._lock:
|
|
return self._map[handle]
|
|
except KeyError:
|
|
raise InternalError("_UniffiHandleMap.get: Invalid handle")
|
|
|
|
def remove(self, handle):
|
|
try:
|
|
with self._lock:
|
|
return self._map.pop(handle)
|
|
except KeyError:
|
|
raise InternalError("_UniffiHandleMap.remove: Invalid handle")
|
|
|
|
def __len__(self):
|
|
return len(self._map)
|
|
# Types conforming to `_UniffiConverterPrimitive` pass themselves directly over the FFI.
|
|
class _UniffiConverterPrimitive:
|
|
@classmethod
|
|
def lift(cls, value):
|
|
return value
|
|
|
|
@classmethod
|
|
def lower(cls, value):
|
|
return value
|
|
|
|
class _UniffiConverterPrimitiveInt(_UniffiConverterPrimitive):
|
|
@classmethod
|
|
def check_lower(cls, value):
|
|
try:
|
|
value = value.__index__()
|
|
except Exception:
|
|
raise TypeError("'{}' object cannot be interpreted as an integer".format(type(value).__name__))
|
|
if not isinstance(value, int):
|
|
raise TypeError("__index__ returned non-int (type {})".format(type(value).__name__))
|
|
if not cls.VALUE_MIN <= value < cls.VALUE_MAX:
|
|
raise ValueError("{} requires {} <= value < {}".format(cls.CLASS_NAME, cls.VALUE_MIN, cls.VALUE_MAX))
|
|
|
|
class _UniffiConverterPrimitiveFloat(_UniffiConverterPrimitive):
|
|
@classmethod
|
|
def check_lower(cls, value):
|
|
try:
|
|
value = value.__float__()
|
|
except Exception:
|
|
raise TypeError("must be real number, not {}".format(type(value).__name__))
|
|
if not isinstance(value, float):
|
|
raise TypeError("__float__ returned non-float (type {})".format(type(value).__name__))
|
|
|
|
# Helper class for wrapper types that will always go through a _UniffiRustBuffer.
|
|
# Classes should inherit from this and implement the `read` and `write` static methods.
|
|
class _UniffiConverterRustBuffer:
|
|
@classmethod
|
|
def lift(cls, rbuf):
|
|
with rbuf.consume_with_stream() as stream:
|
|
return cls.read(stream)
|
|
|
|
@classmethod
|
|
def lower(cls, value):
|
|
with _UniffiRustBuffer.alloc_with_builder() as builder:
|
|
cls.write(value, builder)
|
|
return builder.finalize()
|
|
|
|
# Contains loading, initialization code, and the FFI Function declarations.
|
|
# Define some ctypes FFI types that we use in the library
|
|
|
|
"""
|
|
Function pointer for a Rust task, which a callback function that takes a opaque pointer
|
|
"""
|
|
_UNIFFI_RUST_TASK = ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_int8)
|
|
|
|
def _uniffi_future_callback_t(return_type):
|
|
"""
|
|
Factory function to create callback function types for async functions
|
|
"""
|
|
return ctypes.CFUNCTYPE(None, ctypes.c_uint64, return_type, _UniffiRustCallStatus)
|
|
|
|
def _uniffi_load_indirect():
|
|
"""
|
|
This is how we find and load the dynamic library provided by the component.
|
|
For now we just look it up by name.
|
|
"""
|
|
if sys.platform == "darwin":
|
|
libname = "lib{}.dylib"
|
|
elif sys.platform.startswith("win"):
|
|
# As of python3.8, ctypes does not seem to search $PATH when loading DLLs.
|
|
# We could use `os.add_dll_directory` to configure the search path, but
|
|
# it doesn't feel right to mess with application-wide settings. Let's
|
|
# assume that the `.dll` is next to the `.py` file and load by full path.
|
|
libname = os.path.join(
|
|
os.path.dirname(__file__),
|
|
"{}.dll",
|
|
)
|
|
else:
|
|
# Anything else must be an ELF platform - Linux, *BSD, Solaris/illumos
|
|
libname = "lib{}.so"
|
|
|
|
libname = libname.format("uniffi_hublib")
|
|
path = os.path.join(os.path.dirname(__file__), libname)
|
|
lib = ctypes.cdll.LoadLibrary(path)
|
|
return lib
|
|
|
|
def _uniffi_check_contract_api_version(lib):
|
|
# Get the bindings contract version from our ComponentInterface
|
|
bindings_contract_version = 26
|
|
# Get the scaffolding contract version by calling the into the dylib
|
|
scaffolding_contract_version = lib.ffi_hublib_uniffi_contract_version()
|
|
if bindings_contract_version != scaffolding_contract_version:
|
|
raise InternalError("UniFFI contract version mismatch: try cleaning and rebuilding your project")
|
|
|
|
def _uniffi_check_api_checksums(lib):
|
|
if lib.uniffi_hublib_checksum_func_get_secret_value() != 7762:
|
|
raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
|
|
if lib.uniffi_hublib_checksum_func_recreate_secret_value() != 51310:
|
|
raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
|
|
|
|
# A ctypes library to expose the extern-C FFI definitions.
|
|
# This is an implementation detail which will be called internally by the public API.
|
|
|
|
_UniffiLib = _uniffi_load_indirect()
|
|
_UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK = ctypes.CFUNCTYPE(None,ctypes.c_uint64,ctypes.c_int8,
|
|
)
|
|
_UNIFFI_FOREIGN_FUTURE_FREE = ctypes.CFUNCTYPE(None,ctypes.c_uint64,
|
|
)
|
|
_UNIFFI_CALLBACK_INTERFACE_FREE = ctypes.CFUNCTYPE(None,ctypes.c_uint64,
|
|
)
|
|
class _UniffiForeignFuture(ctypes.Structure):
|
|
_fields_ = [
|
|
("handle", ctypes.c_uint64),
|
|
("free", _UNIFFI_FOREIGN_FUTURE_FREE),
|
|
]
|
|
class _UniffiForeignFutureStructU8(ctypes.Structure):
|
|
_fields_ = [
|
|
("return_value", ctypes.c_uint8),
|
|
("call_status", _UniffiRustCallStatus),
|
|
]
|
|
_UNIFFI_FOREIGN_FUTURE_COMPLETE_U8 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiForeignFutureStructU8,
|
|
)
|
|
class _UniffiForeignFutureStructI8(ctypes.Structure):
|
|
_fields_ = [
|
|
("return_value", ctypes.c_int8),
|
|
("call_status", _UniffiRustCallStatus),
|
|
]
|
|
_UNIFFI_FOREIGN_FUTURE_COMPLETE_I8 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiForeignFutureStructI8,
|
|
)
|
|
class _UniffiForeignFutureStructU16(ctypes.Structure):
|
|
_fields_ = [
|
|
("return_value", ctypes.c_uint16),
|
|
("call_status", _UniffiRustCallStatus),
|
|
]
|
|
_UNIFFI_FOREIGN_FUTURE_COMPLETE_U16 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiForeignFutureStructU16,
|
|
)
|
|
class _UniffiForeignFutureStructI16(ctypes.Structure):
|
|
_fields_ = [
|
|
("return_value", ctypes.c_int16),
|
|
("call_status", _UniffiRustCallStatus),
|
|
]
|
|
_UNIFFI_FOREIGN_FUTURE_COMPLETE_I16 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiForeignFutureStructI16,
|
|
)
|
|
class _UniffiForeignFutureStructU32(ctypes.Structure):
|
|
_fields_ = [
|
|
("return_value", ctypes.c_uint32),
|
|
("call_status", _UniffiRustCallStatus),
|
|
]
|
|
_UNIFFI_FOREIGN_FUTURE_COMPLETE_U32 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiForeignFutureStructU32,
|
|
)
|
|
class _UniffiForeignFutureStructI32(ctypes.Structure):
|
|
_fields_ = [
|
|
("return_value", ctypes.c_int32),
|
|
("call_status", _UniffiRustCallStatus),
|
|
]
|
|
_UNIFFI_FOREIGN_FUTURE_COMPLETE_I32 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiForeignFutureStructI32,
|
|
)
|
|
class _UniffiForeignFutureStructU64(ctypes.Structure):
|
|
_fields_ = [
|
|
("return_value", ctypes.c_uint64),
|
|
("call_status", _UniffiRustCallStatus),
|
|
]
|
|
_UNIFFI_FOREIGN_FUTURE_COMPLETE_U64 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiForeignFutureStructU64,
|
|
)
|
|
class _UniffiForeignFutureStructI64(ctypes.Structure):
|
|
_fields_ = [
|
|
("return_value", ctypes.c_int64),
|
|
("call_status", _UniffiRustCallStatus),
|
|
]
|
|
_UNIFFI_FOREIGN_FUTURE_COMPLETE_I64 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiForeignFutureStructI64,
|
|
)
|
|
class _UniffiForeignFutureStructF32(ctypes.Structure):
|
|
_fields_ = [
|
|
("return_value", ctypes.c_float),
|
|
("call_status", _UniffiRustCallStatus),
|
|
]
|
|
_UNIFFI_FOREIGN_FUTURE_COMPLETE_F32 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiForeignFutureStructF32,
|
|
)
|
|
class _UniffiForeignFutureStructF64(ctypes.Structure):
|
|
_fields_ = [
|
|
("return_value", ctypes.c_double),
|
|
("call_status", _UniffiRustCallStatus),
|
|
]
|
|
_UNIFFI_FOREIGN_FUTURE_COMPLETE_F64 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiForeignFutureStructF64,
|
|
)
|
|
class _UniffiForeignFutureStructPointer(ctypes.Structure):
|
|
_fields_ = [
|
|
("return_value", ctypes.c_void_p),
|
|
("call_status", _UniffiRustCallStatus),
|
|
]
|
|
_UNIFFI_FOREIGN_FUTURE_COMPLETE_POINTER = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiForeignFutureStructPointer,
|
|
)
|
|
class _UniffiForeignFutureStructRustBuffer(ctypes.Structure):
|
|
_fields_ = [
|
|
("return_value", _UniffiRustBuffer),
|
|
("call_status", _UniffiRustCallStatus),
|
|
]
|
|
_UNIFFI_FOREIGN_FUTURE_COMPLETE_RUST_BUFFER = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiForeignFutureStructRustBuffer,
|
|
)
|
|
class _UniffiForeignFutureStructVoid(ctypes.Structure):
|
|
_fields_ = [
|
|
("call_status", _UniffiRustCallStatus),
|
|
]
|
|
_UNIFFI_FOREIGN_FUTURE_COMPLETE_VOID = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiForeignFutureStructVoid,
|
|
)
|
|
_UniffiLib.uniffi_hublib_fn_func_get_secret_value.argtypes = (
|
|
ctypes.c_uint64,
|
|
_UniffiRustBuffer,
|
|
_UniffiRustBuffer,
|
|
ctypes.POINTER(_UniffiRustCallStatus),
|
|
)
|
|
_UniffiLib.uniffi_hublib_fn_func_get_secret_value.restype = _UniffiRustBuffer
|
|
_UniffiLib.uniffi_hublib_fn_func_recreate_secret_value.argtypes = (
|
|
ctypes.c_uint64,
|
|
_UniffiRustBuffer,
|
|
_UniffiRustBuffer,
|
|
_UniffiRustBuffer,
|
|
ctypes.POINTER(_UniffiRustCallStatus),
|
|
)
|
|
_UniffiLib.uniffi_hublib_fn_func_recreate_secret_value.restype = _UniffiRustBuffer
|
|
_UniffiLib.ffi_hublib_rustbuffer_alloc.argtypes = (
|
|
ctypes.c_uint64,
|
|
ctypes.POINTER(_UniffiRustCallStatus),
|
|
)
|
|
_UniffiLib.ffi_hublib_rustbuffer_alloc.restype = _UniffiRustBuffer
|
|
_UniffiLib.ffi_hublib_rustbuffer_from_bytes.argtypes = (
|
|
_UniffiForeignBytes,
|
|
ctypes.POINTER(_UniffiRustCallStatus),
|
|
)
|
|
_UniffiLib.ffi_hublib_rustbuffer_from_bytes.restype = _UniffiRustBuffer
|
|
_UniffiLib.ffi_hublib_rustbuffer_free.argtypes = (
|
|
_UniffiRustBuffer,
|
|
ctypes.POINTER(_UniffiRustCallStatus),
|
|
)
|
|
_UniffiLib.ffi_hublib_rustbuffer_free.restype = None
|
|
_UniffiLib.ffi_hublib_rustbuffer_reserve.argtypes = (
|
|
_UniffiRustBuffer,
|
|
ctypes.c_uint64,
|
|
ctypes.POINTER(_UniffiRustCallStatus),
|
|
)
|
|
_UniffiLib.ffi_hublib_rustbuffer_reserve.restype = _UniffiRustBuffer
|
|
_UniffiLib.ffi_hublib_rust_future_poll_u8.argtypes = (
|
|
ctypes.c_uint64,
|
|
_UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_poll_u8.restype = None
|
|
_UniffiLib.ffi_hublib_rust_future_cancel_u8.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_cancel_u8.restype = None
|
|
_UniffiLib.ffi_hublib_rust_future_free_u8.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_free_u8.restype = None
|
|
_UniffiLib.ffi_hublib_rust_future_complete_u8.argtypes = (
|
|
ctypes.c_uint64,
|
|
ctypes.POINTER(_UniffiRustCallStatus),
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_complete_u8.restype = ctypes.c_uint8
|
|
_UniffiLib.ffi_hublib_rust_future_poll_i8.argtypes = (
|
|
ctypes.c_uint64,
|
|
_UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_poll_i8.restype = None
|
|
_UniffiLib.ffi_hublib_rust_future_cancel_i8.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_cancel_i8.restype = None
|
|
_UniffiLib.ffi_hublib_rust_future_free_i8.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_free_i8.restype = None
|
|
_UniffiLib.ffi_hublib_rust_future_complete_i8.argtypes = (
|
|
ctypes.c_uint64,
|
|
ctypes.POINTER(_UniffiRustCallStatus),
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_complete_i8.restype = ctypes.c_int8
|
|
_UniffiLib.ffi_hublib_rust_future_poll_u16.argtypes = (
|
|
ctypes.c_uint64,
|
|
_UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_poll_u16.restype = None
|
|
_UniffiLib.ffi_hublib_rust_future_cancel_u16.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_cancel_u16.restype = None
|
|
_UniffiLib.ffi_hublib_rust_future_free_u16.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_free_u16.restype = None
|
|
_UniffiLib.ffi_hublib_rust_future_complete_u16.argtypes = (
|
|
ctypes.c_uint64,
|
|
ctypes.POINTER(_UniffiRustCallStatus),
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_complete_u16.restype = ctypes.c_uint16
|
|
_UniffiLib.ffi_hublib_rust_future_poll_i16.argtypes = (
|
|
ctypes.c_uint64,
|
|
_UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_poll_i16.restype = None
|
|
_UniffiLib.ffi_hublib_rust_future_cancel_i16.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_cancel_i16.restype = None
|
|
_UniffiLib.ffi_hublib_rust_future_free_i16.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_free_i16.restype = None
|
|
_UniffiLib.ffi_hublib_rust_future_complete_i16.argtypes = (
|
|
ctypes.c_uint64,
|
|
ctypes.POINTER(_UniffiRustCallStatus),
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_complete_i16.restype = ctypes.c_int16
|
|
_UniffiLib.ffi_hublib_rust_future_poll_u32.argtypes = (
|
|
ctypes.c_uint64,
|
|
_UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_poll_u32.restype = None
|
|
_UniffiLib.ffi_hublib_rust_future_cancel_u32.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_cancel_u32.restype = None
|
|
_UniffiLib.ffi_hublib_rust_future_free_u32.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_free_u32.restype = None
|
|
_UniffiLib.ffi_hublib_rust_future_complete_u32.argtypes = (
|
|
ctypes.c_uint64,
|
|
ctypes.POINTER(_UniffiRustCallStatus),
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_complete_u32.restype = ctypes.c_uint32
|
|
_UniffiLib.ffi_hublib_rust_future_poll_i32.argtypes = (
|
|
ctypes.c_uint64,
|
|
_UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_poll_i32.restype = None
|
|
_UniffiLib.ffi_hublib_rust_future_cancel_i32.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_cancel_i32.restype = None
|
|
_UniffiLib.ffi_hublib_rust_future_free_i32.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_free_i32.restype = None
|
|
_UniffiLib.ffi_hublib_rust_future_complete_i32.argtypes = (
|
|
ctypes.c_uint64,
|
|
ctypes.POINTER(_UniffiRustCallStatus),
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_complete_i32.restype = ctypes.c_int32
|
|
_UniffiLib.ffi_hublib_rust_future_poll_u64.argtypes = (
|
|
ctypes.c_uint64,
|
|
_UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_poll_u64.restype = None
|
|
_UniffiLib.ffi_hublib_rust_future_cancel_u64.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_cancel_u64.restype = None
|
|
_UniffiLib.ffi_hublib_rust_future_free_u64.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_free_u64.restype = None
|
|
_UniffiLib.ffi_hublib_rust_future_complete_u64.argtypes = (
|
|
ctypes.c_uint64,
|
|
ctypes.POINTER(_UniffiRustCallStatus),
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_complete_u64.restype = ctypes.c_uint64
|
|
_UniffiLib.ffi_hublib_rust_future_poll_i64.argtypes = (
|
|
ctypes.c_uint64,
|
|
_UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_poll_i64.restype = None
|
|
_UniffiLib.ffi_hublib_rust_future_cancel_i64.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_cancel_i64.restype = None
|
|
_UniffiLib.ffi_hublib_rust_future_free_i64.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_free_i64.restype = None
|
|
_UniffiLib.ffi_hublib_rust_future_complete_i64.argtypes = (
|
|
ctypes.c_uint64,
|
|
ctypes.POINTER(_UniffiRustCallStatus),
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_complete_i64.restype = ctypes.c_int64
|
|
_UniffiLib.ffi_hublib_rust_future_poll_f32.argtypes = (
|
|
ctypes.c_uint64,
|
|
_UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_poll_f32.restype = None
|
|
_UniffiLib.ffi_hublib_rust_future_cancel_f32.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_cancel_f32.restype = None
|
|
_UniffiLib.ffi_hublib_rust_future_free_f32.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_free_f32.restype = None
|
|
_UniffiLib.ffi_hublib_rust_future_complete_f32.argtypes = (
|
|
ctypes.c_uint64,
|
|
ctypes.POINTER(_UniffiRustCallStatus),
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_complete_f32.restype = ctypes.c_float
|
|
_UniffiLib.ffi_hublib_rust_future_poll_f64.argtypes = (
|
|
ctypes.c_uint64,
|
|
_UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_poll_f64.restype = None
|
|
_UniffiLib.ffi_hublib_rust_future_cancel_f64.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_cancel_f64.restype = None
|
|
_UniffiLib.ffi_hublib_rust_future_free_f64.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_free_f64.restype = None
|
|
_UniffiLib.ffi_hublib_rust_future_complete_f64.argtypes = (
|
|
ctypes.c_uint64,
|
|
ctypes.POINTER(_UniffiRustCallStatus),
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_complete_f64.restype = ctypes.c_double
|
|
_UniffiLib.ffi_hublib_rust_future_poll_pointer.argtypes = (
|
|
ctypes.c_uint64,
|
|
_UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_poll_pointer.restype = None
|
|
_UniffiLib.ffi_hublib_rust_future_cancel_pointer.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_cancel_pointer.restype = None
|
|
_UniffiLib.ffi_hublib_rust_future_free_pointer.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_free_pointer.restype = None
|
|
_UniffiLib.ffi_hublib_rust_future_complete_pointer.argtypes = (
|
|
ctypes.c_uint64,
|
|
ctypes.POINTER(_UniffiRustCallStatus),
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_complete_pointer.restype = ctypes.c_void_p
|
|
_UniffiLib.ffi_hublib_rust_future_poll_rust_buffer.argtypes = (
|
|
ctypes.c_uint64,
|
|
_UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_poll_rust_buffer.restype = None
|
|
_UniffiLib.ffi_hublib_rust_future_cancel_rust_buffer.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_cancel_rust_buffer.restype = None
|
|
_UniffiLib.ffi_hublib_rust_future_free_rust_buffer.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_free_rust_buffer.restype = None
|
|
_UniffiLib.ffi_hublib_rust_future_complete_rust_buffer.argtypes = (
|
|
ctypes.c_uint64,
|
|
ctypes.POINTER(_UniffiRustCallStatus),
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_complete_rust_buffer.restype = _UniffiRustBuffer
|
|
_UniffiLib.ffi_hublib_rust_future_poll_void.argtypes = (
|
|
ctypes.c_uint64,
|
|
_UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_poll_void.restype = None
|
|
_UniffiLib.ffi_hublib_rust_future_cancel_void.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_cancel_void.restype = None
|
|
_UniffiLib.ffi_hublib_rust_future_free_void.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_free_void.restype = None
|
|
_UniffiLib.ffi_hublib_rust_future_complete_void.argtypes = (
|
|
ctypes.c_uint64,
|
|
ctypes.POINTER(_UniffiRustCallStatus),
|
|
)
|
|
_UniffiLib.ffi_hublib_rust_future_complete_void.restype = None
|
|
_UniffiLib.uniffi_hublib_checksum_func_get_secret_value.argtypes = (
|
|
)
|
|
_UniffiLib.uniffi_hublib_checksum_func_get_secret_value.restype = ctypes.c_uint16
|
|
_UniffiLib.uniffi_hublib_checksum_func_recreate_secret_value.argtypes = (
|
|
)
|
|
_UniffiLib.uniffi_hublib_checksum_func_recreate_secret_value.restype = ctypes.c_uint16
|
|
_UniffiLib.ffi_hublib_uniffi_contract_version.argtypes = (
|
|
)
|
|
_UniffiLib.ffi_hublib_uniffi_contract_version.restype = ctypes.c_uint32
|
|
|
|
_uniffi_check_contract_api_version(_UniffiLib)
|
|
# _uniffi_check_api_checksums(_UniffiLib)
|
|
|
|
# Public interface members begin here.
|
|
|
|
|
|
class _UniffiConverterUInt64(_UniffiConverterPrimitiveInt):
|
|
CLASS_NAME = "u64"
|
|
VALUE_MIN = 0
|
|
VALUE_MAX = 2**64
|
|
|
|
@staticmethod
|
|
def read(buf):
|
|
return buf.read_u64()
|
|
|
|
@staticmethod
|
|
def write(value, buf):
|
|
buf.write_u64(value)
|
|
|
|
class _UniffiConverterString:
|
|
@staticmethod
|
|
def check_lower(value):
|
|
if not isinstance(value, str):
|
|
raise TypeError("argument must be str, not {}".format(type(value).__name__))
|
|
return value
|
|
|
|
@staticmethod
|
|
def read(buf):
|
|
size = buf.read_i32()
|
|
if size < 0:
|
|
raise InternalError("Unexpected negative string length")
|
|
utf8_bytes = buf.read(size)
|
|
return utf8_bytes.decode("utf-8")
|
|
|
|
@staticmethod
|
|
def write(value, buf):
|
|
utf8_bytes = value.encode("utf-8")
|
|
buf.write_i32(len(utf8_bytes))
|
|
buf.write(utf8_bytes)
|
|
|
|
@staticmethod
|
|
def lift(buf):
|
|
with buf.consume_with_stream() as stream:
|
|
return stream.read(stream.remaining()).decode("utf-8")
|
|
|
|
@staticmethod
|
|
def lower(value):
|
|
with _UniffiRustBuffer.alloc_with_builder() as builder:
|
|
builder.write(value.encode("utf-8"))
|
|
return builder.finalize()
|
|
|
|
# Async support
|
|
|
|
def get_secret_value(cur_time: "int",user_agent: "str",url: "str") -> "str":
|
|
_UniffiConverterUInt64.check_lower(cur_time)
|
|
|
|
_UniffiConverterString.check_lower(user_agent)
|
|
|
|
_UniffiConverterString.check_lower(url)
|
|
|
|
return _UniffiConverterString.lift(_uniffi_rust_call(_UniffiLib.uniffi_hublib_fn_func_get_secret_value,
|
|
_UniffiConverterUInt64.lower(cur_time),
|
|
_UniffiConverterString.lower(user_agent),
|
|
_UniffiConverterString.lower(url)))
|
|
|
|
|
|
def recreate_secret_value(cur_time: "int",user_agent: "str",url: "str",gotten_value: "str") -> "str":
|
|
_UniffiConverterUInt64.check_lower(cur_time)
|
|
|
|
_UniffiConverterString.check_lower(user_agent)
|
|
|
|
_UniffiConverterString.check_lower(url)
|
|
|
|
_UniffiConverterString.check_lower(gotten_value)
|
|
|
|
return _UniffiConverterString.lift(_uniffi_rust_call(_UniffiLib.uniffi_hublib_fn_func_recreate_secret_value,
|
|
_UniffiConverterUInt64.lower(cur_time),
|
|
_UniffiConverterString.lower(user_agent),
|
|
_UniffiConverterString.lower(url),
|
|
_UniffiConverterString.lower(gotten_value)))
|
|
|
|
|
|
__all__ = [
|
|
"InternalError",
|
|
"get_secret_value",
|
|
"recreate_secret_value",
|
|
]
|
|
|