vollo-rt 27.0.0__py3-none-any.whl

_vollo_rt.py

@@ -0,0 +1,11 @@
+# auto-generated file
+import _cffi_backend
+
+ffi = _cffi_backend.FFI('_vollo_rt',
+    _version = 0x2601,
+    _types = b'\x00\x00\x05\x0D\x00\x00\x04\x03\x00\x00\x00\x0F\x00\x00\x05\x0D\x00\x00\x78\x03\x00\x00\x6D\x03\x00\x00\x00\x0F\x00\x00\x05\x0D\x00\x00\x04\x11\x00\x00\x0E\x03\x00\x00\x77\x03\x00\x00\x00\x0F\x00\x00\x05\x0D\x00\x00\x04\x11\x00\x00\x1C\x01\x00\x00\x00\x0F\x00\x00\x05\x0D\x00\x00\x04\x11\x00\x00\x1C\x01\x00\x00\x01\x01\x00\x00\x00\x0F\x00\x00\x05\x0D\x00\x00\x04\x11\x00\x00\x1C\x01\x00\x00\x18\x01\x00\x00\x70\x03\x00\x00\x6F\x03\x00\x00\x00\x0F\x00\x00\x05\x0D\x00\x00\x04\x11\x00\x00\x1C\x01\x00\x00\x18\x01\x00\x00\x3A\x03\x00\x00\x75\x03\x00\x00\x00\x0F\x00\x00\x05\x0D\x00\x00\x04\x11\x00\x00\x1C\x01\x00\x00\x18\x01\x00\x00\x30\x03\x00\x00\x3F\x03\x00\x00\x27\x11\x00\x00\x04\x03\x00\x00\x00\x0F\x00\x00\x05\x0D\x00\x00\x04\x11\x00\x00\x1C\x01\x00\x00\x18\x01\x00\x00\x16\x01\x00\x00\x73\x03\x00\x00\x2A\x11\x00\x00\x00\x0F\x00\x00\x05\x0D\x00\x00\x04\x11\x00\x00\x1C\x01\x00\x00\x18\x01\x00\x00\x16\x01\x00\x00\x27\x11\x00\x00\x76\x03\x00\x00\x21\x11\x00\x00\x00\x0F\x00\x00\x05\x0D\x00\x00\x04\x11\x00\x00\x78\x03\x00\x00\x1C\x01\x00\x00\x00\x0F\x00\x00\x05\x0D\x00\x00\x00\x0F\x00\x00\x72\x0D\x00\x00\x04\x11\x00\x00\x1C\x01\x00\x00\x1C\x01\x00\x00\x00\x0F\x00\x00\x74\x0D\x00\x00\x04\x11\x00\x00\x1C\x01\x00\x00\x1C\x01\x00\x00\x00\x0F\x00\x00\x0E\x0D\x00\x00\x04\x11\x00\x00\x00\x0F\x00\x00\x0E\x0D\x00\x00\x04\x11\x00\x00\x1C\x01\x00\x00\x00\x0F\x00\x00\x0E\x0D\x00\x00\x04\x11\x00\x00\x1C\x01\x00\x00\x1C\x01\x00\x00\x00\x0F\x00\x00\x75\x0D\x00\x00\x04\x11\x00\x00\x1C\x01\x00\x00\x00\x0F\x00\x00\x30\x0D\x00\x00\x04\x11\x00\x00\x1C\x01\x00\x00\x1C\x01\x00\x00\x00\x0F\x00\x00\x04\x0D\x00\x00\x04\x11\x00\x00\x1C\x01\x00\x00\x00\x0F\x00\x00\x78\x0D\x00\x00\x05\x11\x00\x00\x00\x0F\x00\x00\x78\x0D\x00\x00\x04\x11\x00\x00\x00\x0F\x00\x00\x02\x01\x00\x00\x00\x0B\x00\x00\x71\x03\x00\x00\x71\x03\x00\x00\x0D\x01\x00\x00\x07\x01\x00\x00\x00\x09\x00\x00\x0E\x03\x00\x00\x76\x03\x00\x00\x14\x01\x00\x00\x18\x03\x00\x00\x00\x01',
+    _globals = (b'\xFF\xFF\xFF\x0Bnumber_format_bf16',0,b'\xFF\xFF\xFF\x0Bnumber_format_fp32',1,b'\x00\x00\x51\x23vollo_rt_accelerator_block_size',0,b'\x00\x00\x51\x23vollo_rt_accelerator_num_cores',0,b'\x00\x00\x0C\x23vollo_rt_add_accelerator',0,b'\x00\x00\x23\x23vollo_rt_add_job',0,b'\x00\x00\x1C\x23vollo_rt_add_job_bf16',0,b'\x00\x00\x34\x23vollo_rt_add_job_bf16_partial_update',0,b'\x00\x00\x15\x23vollo_rt_add_job_fp32',0,b'\x00\x00\x2C\x23vollo_rt_add_job_partial_update',0,b'\x00\x00\x10\x23vollo_rt_add_vm',0,b'\x00\x00\x6A\x23vollo_rt_destroy',0,b'\x00\x00\x67\x23vollo_rt_destroy_err',0,b'\x00\x00\x5A\x23vollo_rt_get_raw_buffer',0,b'\x00\x00\x63\x23vollo_rt_get_raw_buffer_bytes',0,b'\x00\x00\x00\x23vollo_rt_init',0,b'\x00\x00\x03\x23vollo_rt_load_program',0,b'\x00\x00\x3D\x23vollo_rt_load_program_from_buffer',0,b'\x00\x00\x5E\x23vollo_rt_model_input_format',0,b'\x00\x00\x55\x23vollo_rt_model_input_num_elements',0,b'\x00\x00\x49\x23vollo_rt_model_input_shape',0,b'\x00\x00\x55\x23vollo_rt_model_input_shape_len',0,b'\x00\x00\x44\x23vollo_rt_model_input_streaming_dim',0,b'\x00\x00\x0C\x23vollo_rt_model_name',0,b'\x00\x00\x51\x23vollo_rt_model_num_inputs',0,b'\x00\x00\x51\x23vollo_rt_model_num_outputs',0,b'\x00\x00\x5E\x23vollo_rt_model_output_format',0,b'\x00\x00\x55\x23vollo_rt_model_output_num_elements',0,b'\x00\x00\x49\x23vollo_rt_model_output_shape',0,b'\x00\x00\x55\x23vollo_rt_model_output_shape_len',0,b'\x00\x00\x44\x23vollo_rt_model_output_streaming_dim',0,b'\x00\x00\x4E\x23vollo_rt_num_models',0,b'\x00\x00\x07\x23vollo_rt_poll',0,b'\x00\x00\x42\x23vollo_rt_version',0),
+    _struct_unions = ((b'\x00\x00\x00\x73\x00\x00\x00\x02partial_update_input',b'\x00\x00\x30\x11input_arg_num',b'\x00\x00\x30\x11num_updates',b'\x00\x00\x27\x11update_indices',b'\x00\x00\x3F\x11update_values'),),
+    _enums = (b'\x00\x00\x00\x6E\x00\x00\x00\x16number_format\x00number_format_bf16,number_format_fp32',),
+    _typenames = (b'\x00\x00\x00\x76bf16',b'\x00\x00\x00\x30number_format',b'\x00\x00\x00\x73partial_update_input',b'\x00\x00\x00\x04vollo_rt_context_t',b'\x00\x00\x00\x05vollo_rt_error_t'),
+)

vollo_rt/__init__.py

@@ -0,0 +1,590 @@
+# Python bindings for the Vollo Runtime
+
+from dataclasses import dataclass
+from typing import Any, List, Tuple, Optional, Union
+from _vollo_rt import ffi
+
+import os
+
+import torch
+import numpy as np
+
+import time
+
+from collections.abc import Sequence
+
+
+def handle_error(output):
+    if output:
+        raise Exception(ffi.string(output).decode("utf-8"))
+
+
+class VolloRTContext:
+    """
+    A context for performing computation on Vollo
+
+    This wraps the C bindings for the Vollo Runtime. In order for contexts to be
+    properly garbage collected, :class:`VolloRTContext` is a context manager, and should be
+    used in a ``with`` block. This ensures that the context id correctly destroyed
+    after use. :class:`VolloRTContext` should not be nested, only a single context should
+    be open at any given time.
+
+    The general order of operations is as follows:
+        - Initialise context in a ``with`` statement
+        - :meth:`add_accelerator`
+        - :meth:`load_program` / :meth:`load_program_bytes`
+        - Gather metadata about the models available in the loaded program
+        - Run inference with either:
+            - :meth:`run`
+            - Low level API:
+                - Add jobs with :meth:`add_job`, :meth:`add_job_f32` or :meth:`add_job_bf16`
+                - :meth:`poll` until a job is completed
+                - :meth:`get_result` to retrieve the result of the computation
+
+    High level API example:
+
+    .. code-block:: python
+
+        ctx.add_accelerator(0)
+        ctx.load_program("program.vollo")
+
+        input_arr = np.random.rand(100,50).astype(np.float32)
+        output = ctx.run(input_arr)
+
+    Low level API example:
+
+    .. code-block:: python
+
+        ctx.add_accelerator(0)
+        ctx.load_program("program.vollo")
+
+        # add jobs
+        input_arr = np.random.rand(100,50).astype(np.float32)
+        user_ctx_f32 = ctx.add_job_f32(input_arr)
+
+        # loop until the job is complete
+        completed_jobs = []
+        while(user_ctx_f32 not in completed_jobs):
+            completed_jobs = completed_jobs + ctx.poll()
+
+        # retrieve the results from each computation
+        output_f32 = ctx.get_result(user_ctx_f32)
+    """
+
+    def __init__(self):
+        try:
+            self.lib = ffi.dlopen("libvollo_rt.so")
+        except Exception:
+            raise Exception(
+                """
+                Could not load the Vollo RT library!
+
+                Make sure to "source $VOLLO_SDK/setup.sh", or to set "$LD_LIBRARY_PATH" appropriately.
+                See https://vollo.myrtle.ai/latest/vollo-runtime.html for more information.
+                """
+            )
+
+        _ptr = ffi.new("void **")
+        handle_error(self.lib.vollo_rt_init(_ptr))
+
+        # Keep inputs alive until their jobs have been completed
+        self._context_input_map = {}
+
+        self._context_output_map = {}
+        self._context_counter = -1
+        self._ctx = _ptr[0]
+
+        self.number_format_bf16 = self.lib.number_format_bf16
+        self.number_format_fp32 = self.lib.number_format_fp32
+
+    def __enter__(self):
+        return self
+
+    def _make_unique_context(self) -> int:
+        self._context_counter += 1
+        return self._context_counter
+
+    def add_accelerator(self, accelerator_index: int):
+        """
+        Add an accelerator.
+        The accelerator is specified by its index. The index refers to an accelerator in the sorted list
+        of PCI addresses.
+        """
+        handle_error(
+            self.lib.vollo_rt_add_accelerator(
+                self._ctx, ffi.cast("size_t", accelerator_index)
+            )
+        )
+
+    def add_vm(
+        self,
+        accelerator_index: int,
+        bit_accurate: bool,
+    ):
+        """
+        Add a VM, to run a program in software simulation rather than on hardware.
+        Allows testing the API without needing an accelerator or license, giving correct results but much slower.
+
+        You can choose any `accelerator_index` to assign to the VM then use the rest of the API as though the VM
+        is an accelerator. However, the VM hardware config is determined by the requirements of the loaded program,
+        so until you call `vollo_rt_load_program` the values returned by `accelerator_num_cores` and
+        `accelerator_block_size` will be 0.
+
+        Cannot currently be used with Vollo Trees programs.
+
+        This should be called before `load_program`.
+
+        Arg:
+
+            bit_accurate: Use a compute model that replicates the VOLLO accelerator with bit-accuracy. Disable
+            to use single precision compute.
+        """
+        handle_error(
+            self.lib.vollo_rt_add_vm(
+                self._ctx,
+                ffi.cast("size_t", accelerator_index),
+                ffi.cast("bool", bit_accurate),
+            )
+        )
+
+    def accelerator_num_cores(self, accelerator_index: int) -> int:
+        """
+        Get the number of cores of a Vollo accelerator.
+        For Vollo Trees bitstreams, this is the number of tree units.
+
+        If used on a VM before loading a program, it will return 0, because the VM hardware config is determined by
+        the requirements of the loaded program.
+        """
+        return self.lib.vollo_rt_accelerator_num_cores(self._ctx, accelerator_index)
+
+    def accelerator_block_size(self, accelerator_index: int) -> int:
+        """
+        Get the block size of a Vollo accelerator.
+
+        If used on a VM before loading a program, it will return 0, because the VM hardware config is determined by
+        the requirements of the loaded program.
+        """
+        return self.lib.vollo_rt_accelerator_block_size(self._ctx, accelerator_index)
+
+    def load_program(
+        self,
+        program: Union[
+            str,
+            os.PathLike,
+            Any,
+        ],
+    ):
+        """
+        Load a pre-compiled program onto the accelerator.
+
+        Arg:
+
+            program: One of:
+
+                A path to a Vollo program (typically .vollo)
+
+                A program straight from the Vollo Compiler or the Vollo Trees Compiler
+        """
+        if isinstance(program, str) or isinstance(program, os.PathLike):
+            handle_error(
+                self.lib.vollo_rt_load_program(self._ctx, str(program).encode("utf-8"))
+            )
+        else:
+            try:
+                bytes = program.save_bytes()
+            except AttributeError:
+                raise Exception(
+                    "load_program: Unsupported type, expected a path or a Vollo program"
+                )
+
+            self.load_program_bytes(bytes)
+
+    def load_program_bytes(self, program_bytes: bytes):
+        """
+        Load a pre-compiled Vollo program from a bytes object
+        """
+        if not isinstance(program_bytes, bytes):
+            raise TypeError("program_bytes must be of type bytes")
+
+        handle_error(
+            self.lib.vollo_rt_load_program_from_buffer(
+                self._ctx, program_bytes, len(program_bytes)
+            )
+        )
+
+    def num_models(self) -> int:
+        """
+        The number of models in the loaded program.
+        """
+        return self.lib.vollo_rt_num_models(self._ctx)
+
+    def model_name(self, model_index: int = 0) -> Optional[str]:
+        """
+        Get the name of a model if set
+        """
+        name = self.lib.vollo_rt_model_name(self._ctx, model_index)
+
+        if name:
+            return ffi.string(name).decode("utf-8")
+        else:
+            return None
+
+    def model_num_inputs(self, model_index: int = 0) -> int:
+        """
+        Get the number of inputs the model uses.
+        """
+        return self.lib.vollo_rt_model_num_inputs(self._ctx, model_index)
+
+    def model_num_outputs(self, model_index: int = 0) -> int:
+        """
+        Get the number of outputs the model uses.
+        """
+        return self.lib.vollo_rt_model_num_outputs(self._ctx, model_index)
+
+    def model_input_shape(
+        self, model_index: int = 0, input_index: int = 0
+    ) -> Tuple[int]:
+        """
+        Get the shape of a model input
+        """
+        raw_array = self.lib.vollo_rt_model_input_shape(
+            self._ctx, model_index, input_index
+        )
+
+        shape_len = self.lib.vollo_rt_model_input_shape_len(
+            self._ctx, model_index, input_index
+        )
+
+        shape = []
+        for i in range(shape_len):
+            shape.append(raw_array[i])
+
+        return tuple(shape)
+
+    def model_output_shape(
+        self, model_index: int = 0, output_index: int = 0
+    ) -> Tuple[int]:
+        """
+        Get the shape of a model output
+        """
+        raw_array = self.lib.vollo_rt_model_output_shape(
+            self._ctx, model_index, output_index
+        )
+
+        shape_len = self.lib.vollo_rt_model_output_shape_len(
+            self._ctx, model_index, output_index
+        )
+
+        shape = []
+        for i in range(shape_len):
+            shape.append(raw_array[i])
+
+        return tuple(shape)
+
+    def model_input_streaming_dim(
+        self, model_index: int = 0, input_index: int = 0
+    ) -> Optional[int]:
+        """
+        Get the input streaming dimension or None
+        """
+        dim = self.lib.vollo_rt_model_input_streaming_dim(
+            self._ctx, model_index, input_index
+        )
+
+        if dim == -1:
+            return None
+
+        return dim
+
+    def model_output_streaming_dim(
+        self, model_index: int = 0, output_index: int = 0
+    ) -> Optional[int]:
+        """
+        Get the output streaming dimension or None
+        """
+        dim = self.lib.vollo_rt_model_output_streaming_dim(
+            self._ctx, model_index, output_index
+        )
+
+        if dim == -1:
+            return None
+
+        return dim
+
+    def model_output_format(self, model_index: int = 0, output_index: int = 0):
+        """
+        Get the native number format (bf16 or fp32) of a specific output of the model.
+        Returns the enum value (self.number_format_bf16 or self.number_format_fp32).
+        """
+        return self.lib.vollo_rt_model_output_format(
+            self._ctx, model_index, output_index
+        )
+
+    def _get_dtype_from_format(self, fmt, use_torch: bool):
+        """Helper to convert vollo number format to torch/numpy dtype"""
+        if fmt == self.lib.number_format_bf16:
+            if use_torch:
+                return torch.bfloat16
+            else:
+                # Numpy has no native bfloat16, usually we fall back to float32 or raise error.
+                # Since Vollo driver handles conversion, we can't really hold bf16 in numpy.
+                raise ValueError("Numpy does not support bfloat16 output")
+        elif fmt == self.lib.number_format_fp32:
+            return torch.float32 if use_torch else np.float32
+        else:
+            raise ValueError(f"Unknown format: {fmt}")
+
+    def add_job(self, inputs, model_index: int = 0, output_formats=None):
+        """
+        Sets up a computation on the vollo.
+
+        Args:
+            inputs: A Tensor/Array or Sequence of Tensors/Arrays.
+            model_index: The index of the model to use.
+            output_formats: (Optional) A list of vollo number_formats (self.number_format_bf16/number_format_fp32)
+                specifying the desired output types. If None, the model's
+                native output formats are used.
+
+        Returns:
+            User context handle. The results (retrieved via poll) will match the
+            types specified in output_formats (or the model's native types).
+        """
+        if not isinstance(inputs, Sequence):
+            inputs = [inputs]
+        else:
+            inputs = list(inputs)
+
+        num_inputs = self.model_num_inputs(model_index)
+        assert (
+            len(inputs) == num_inputs
+        ), f"add_job: Was given {len(inputs)} inputs but the program expects {num_inputs} inputs"
+
+        user_ctx = self._make_unique_context()
+        self._context_input_map[user_ctx] = []
+
+        # 1. Prepare Input Buffers & Formats
+        c_input_ptrs = ffi.new(f"void *[{num_inputs}]")
+        c_in_fmt_arr = ffi.new(f"number_format[{num_inputs}]")
+
+        # We track if we see any torch tensors to decide if outputs should be torch or numpy
+        any_torch = False
+
+        for i, inp in enumerate(inputs):
+            expected_shape = self.model_input_shape(model_index, i)
+            assert tuple(inp.shape) == expected_shape
+
+            fmt = None
+            ptr = None
+
+            if isinstance(inp, torch.Tensor):
+                any_torch = True
+                inp = inp.contiguous()
+                if inp.dtype == torch.bfloat16:
+                    fmt = self.number_format_bf16
+                elif inp.dtype == torch.float32:
+                    fmt = self.number_format_fp32
+                else:
+                    raise TypeError(
+                        f"add_job: Unsupported torch dtype at input {i}: {inp.dtype}"
+                    )
+                ptr = inp.data_ptr()
+
+            elif isinstance(inp, np.ndarray):
+                if inp.dtype == np.float32:
+                    inp = np.ascontiguousarray(inp)
+                    fmt = self.number_format_fp32
+                else:
+                    raise TypeError(
+                        f"add_job: Unsupported numpy dtype at input {i}: {inp.dtype}"
+                    )
+                ptr = inp.ctypes.data
+            else:
+                raise TypeError(
+                    f"add_job: Unsupported input type at index {i}: {type(inp)}"
+                )
+
+            c_in_fmt_arr[i] = fmt
+            c_input_ptrs[i] = ffi.cast("void *", ptr)
+            self._context_input_map[user_ctx].append(inp)
+
+        # 2. Determine Output Formats
+        num_outputs = self.model_num_outputs(model_index)
+
+        # If no specific output formats requested, either use model native formats (if any torch
+        # input), or force fp32 (if all numpy inputs)
+        if output_formats is None:
+            if not any_torch:
+                # numpy doesn't support bf16, so we have to force fp32 outputs
+                output_formats = [self.number_format_fp32] * num_outputs
+            else:
+                output_formats = [
+                    self.model_output_format(model_index, i) for i in range(num_outputs)
+                ]
+
+        assert len(output_formats) == num_outputs
+
+        # 3. Prepare Output Buffers
+        outputs = []
+        c_output_ptrs = ffi.new(f"void *[{num_outputs}]")
+        c_out_fmt_arr = ffi.new(f"number_format[{num_outputs}]")
+
+        for i, fmt in enumerate(output_formats):
+            out_shape = self.model_output_shape(model_index, i)
+
+            # Determine python dtype based on the requested format and whether inputs were torch/numpy
+            # If inputs were numpy but format is bf16, we have a problem (numpy can't hold bf16).
+            # We assume if the user passed numpy, they expect fp32 or the model allows fp32.
+
+            if not any_torch and fmt == self.number_format_bf16:
+                # Fallback: If inputs are numpy but output requires bf16, we can't return numpy bf16.
+                # We raise an error or force the user to use torch.
+                # Alternatively, we could cast to fp32 here, but that ignores the 'fmt' argument.
+                raise ValueError(
+                    f"Output {i} is bf16, but inputs are numpy arrays. "
+                    "Numpy does not support bfloat16. Please use torch tensors or request fp32 output."
+                )
+
+            # Map format to dtype
+            dtype = self._get_dtype_from_format(fmt, use_torch=any_torch)
+
+            if any_torch:
+                out_tensor = torch.zeros(out_shape, dtype=dtype)
+                ptr = out_tensor.data_ptr()
+                outputs.append(out_tensor)
+            else:
+                out_array = np.zeros(out_shape, dtype=dtype)
+                ptr = out_array.ctypes.data
+                outputs.append(out_array)
+
+            c_output_ptrs[i] = ffi.cast("void *", ptr)
+            c_out_fmt_arr[i] = fmt
+
+        self._context_output_map[user_ctx] = outputs
+
+        # 4. Call C Function
+        handle_error(
+            self.lib.vollo_rt_add_job(
+                self._ctx,
+                ffi.cast("size_t", model_index),
+                ffi.cast("uint64_t", user_ctx),
+                c_in_fmt_arr,
+                c_input_ptrs,
+                c_out_fmt_arr,
+                c_output_ptrs,
+            )
+        )
+
+        return user_ctx
+
+    def add_job_f32(self, inputs, model_index: int = 0) -> int:
+        """
+        Sets up a computation where inputs and outputs are float32.
+        """
+        # 1. Check inputs
+        check_inputs = inputs if isinstance(inputs, Sequence) else [inputs]
+        for i, inp in enumerate(check_inputs):
+            if isinstance(inp, torch.Tensor):
+                if inp.dtype != torch.float32:
+                    raise TypeError(
+                        f"add_job_f32: Input {i} is torch.{inp.dtype}, expected float32"
+                    )
+            elif isinstance(inp, np.ndarray):
+                if inp.dtype != np.float32:
+                    raise TypeError(
+                        f"add_job_f32: Input {i} is numpy.{inp.dtype}, expected float32"
+                    )
+            else:
+                raise TypeError(f"add_job_f32: Unsupported type {type(inp)}")
+
+        # 2. Force outputs to FP32
+        num_outputs = self.model_num_outputs(model_index)
+        forced_formats = [self.number_format_fp32] * num_outputs
+
+        return self.add_job(inputs, model_index, output_formats=forced_formats)
+
+    def add_job_bf16(self, inputs, model_index: int = 0):
+        """
+        Sets up a computation where inputs and outputs are bfloat16.
+        """
+        # 1. Check inputs
+        check_inputs = inputs if isinstance(inputs, Sequence) else [inputs]
+        for i, inp in enumerate(check_inputs):
+            if isinstance(inp, torch.Tensor):
+                if inp.dtype != torch.bfloat16:
+                    raise TypeError(
+                        f"add_job_bf16: Input {i} is torch.{inp.dtype}, expected bfloat16"
+                    )
+            else:
+                raise TypeError(
+                    f"add_job_bf16: Input {i} must be a torch tensor (Numpy does not support bfloat16)"
+                )
+
+        # 2. Force outputs to BF16
+        num_outputs = self.model_num_outputs(model_index)
+        forced_formats = [self.number_format_bf16] * num_outputs
+
+        return self.add_job(inputs, model_index, output_formats=forced_formats)
+
+    def poll(self) -> List[int]:
+        """
+        Poll the vollo for completion.
+        Returns a list of user contexts corresponding to completed jobs.
+
+        Note: Polling also initiates transfers for new jobs, so you must poll before any progress
+        on these new jobs can be made.
+        """
+        num_completed_ptr = ffi.new("size_t *")
+        user_ctxs_ptr = ffi.new("uint64_t **")
+        handle_error(
+            self.lib.vollo_rt_poll(self._ctx, num_completed_ptr, user_ctxs_ptr)
+        )
+        results = [int(user_ctxs_ptr[0][i]) for i in range(int(num_completed_ptr[0]))]
+        # Safe to clean up inputs once their job has completed
+        for user_ctx in results:
+            self._context_input_map.pop(user_ctx)
+        return results
+
+    def get_result(self, user_ctx: int):
+        """
+        Retrieve the result of the computation corresponding to ``user_ctx``
+        """
+        outputs = self._context_output_map[user_ctx]
+        return outputs[0] if len(outputs) == 1 else tuple(outputs)
+
+    def run(
+        self,
+        inputs,
+        model_index: int = 0,
+        max_poll_iterations: int = 20_000_000_000,
+        sleep_duration_ms: Optional[float] = None,
+    ):
+        """
+        Run a single inference of a model on Vollo
+
+        This is a simpler API to run single inferences without needing to
+        use :meth:`add_job`, :meth:`poll` and :meth:`get_result` manually
+
+        Arg:
+
+            sleep_duration_ms: The number of milliseconds to wait between each poll. There will be no wait if set to None.
+        """
+        user_ctx = self.add_job(inputs, model_index)
+
+        poll_count = 0
+
+        # time.sleep() takes in argument as seconds, but we've taken sleep_duration_ms in as milliseconds
+        if sleep_duration_ms is not None:
+            sleep_duration_ms /= 1_000
+
+        while user_ctx not in self.poll():
+            poll_count += 1
+            if poll_count == max_poll_iterations:
+                raise TimeoutError
+
+            if sleep_duration_ms is not None:
+                time.sleep(sleep_duration_ms)
+
+        return self.get_result(user_ctx)
+
+    def __exit__(self, *args):
+        handle_error(self.lib.vollo_rt_destroy(self._ctx))

vollo_rt-27.0.0.dist-info/EULA.md

@@ -0,0 +1,101 @@
+MYRTLE SOFTWARE END USER LICENSE AGREEMENT (“EULA”)
+PLEASE READ THIS AGREEMENT CAREFULLY. 
+THIS EULA, (TOGETHER WITH THE EVALUATION FORM, THE "AGREEMENT"), IS ENTERED INTO  BETWEEN YOU (“USER”) AND MYRTLE SOFTWARE LTD, A COMPANY INCORPORATED UNDER THE LAWS OF ENGLAND AND WALES AT THIRD FLOOR, ST ANDREWS HOUSE, 59 ST ANDREWS STREET, CAMBRIDGE CB2 3BZ, COMPANY NUMBER 4978210 (THE  "COMPANY"), WHICH APPLIES TO USER'S USE OF THE COMPANY'S SOFTWARE, DOCUMENTATION AND CONTENT.  
+USER AND THE COMPANY MAY EACH BE REFERRED TO AS A “PARTY” AND TOGETHER AS THE “PARTIES”. IF THE USER DOWNLOADS, INSTALLS, ACCESSES, OR OTHERWISE USES ANY OF THE SERVICES, USER HEREBY AGREES TO AND SHALL BE BOUND BY THE TERMS OF THIS EULA.  
+IF USER DOES NOT AGREE TO THE TERMS OF THIS EULA, THE USER IS NOT PERMITTED TO PROCEED FURTHER OR USE ANY OF THE COMPANY SERVICE.  COMPANY RESERVES THE RIGHT TO CHANGE THE TERMS OF THIS EULA AT ANY TIME UPON THIRTY (30) DAYS WRITTEN NOTICE THROUGH OUR WEBSITE. 
+
+
+1. DEFINITIONS AND INTERPRETATIONS
+   1. "Authorised Reseller" means a reseller that is enrolled with the Company under a partner programme or similar arrangement.
+"Authorised User" means an employee, contractor or consultant of the User who has log in credentials for, or access to, the Services.
+"Confidential Information" means all confidential or proprietary information (however recorded or preserved) disclosed by one party or its employees, officers, subcontractors, representatives or advisers to the other party and the other party’s representatives, including the terms of this Agreement, the business, affairs, customers, clients, suppliers, plans, intentions, market opportunities, operations, processes, products, services, data, know-how, or trade secrets of the disclosing party.
+"Derived Data" means any data which is derived from User's use of the Services, which shall include: (i) any meta-data created in the User's use of the Services such as the number of connections and volume of data; (ii) any data which is processed and stored as mathematical constructs; and (iii) statistical or aggregated data, but shall exclude any personal data.
+"E-Portal" means shall mean the e-ticketing portal provided by the Authorised Reseller to raise any issues that need to be resolved by the Company and that require Support. 
+"Intellectual Property Rights" means patents, rights to inventions, copyright and neighbouring and related rights, trade marks, goodwill and all other intellectual property rights, in each case whether registered or unregistered and including all applications and rights to apply for and be granted, renewals or extensions of, and rights to claim priority from, such rights and all similar or equivalent rights or forms of protection which subsist or will subsist now or in the future in any part of the world.
+"Rights" means individually or collectively, Services, all software, hardware, algorithms, methodologies, Derived Data, other technology used by the Company to provide the Services, and all Intellectual Property Rights and proprietary rights in all of the foregoing.
+"Services" means the provision of the Company's software, documentation and content when as purchased by the User from the Company or Authorised reseller.
+"Support" means the support services that the Company will provide to the User during the period of use of the Services.
+"Website" means www.myrtle.ai.
+2. EVALUATIONS AND BETA TESTING
+   1. This clause 2 applies if the Company has agreed to provide the User with a non-transferable, non-exclusive, revocable, non-sublicensable license to access the Services to either: (a) conduct a proof of value of the Services (a "Proof of Value"); or (b) conduct a technical preview (a "Product Review") of a product of the Company which may or may not include unreleased features (a "Beta Product"), free of charge for the Evaluation Period specified in the Evaluation Form. Either Party may terminate a Proof of Value or Product Review for any reason on no less than 7 days' notice to the other. During an Evaluation Period, in addition to the restrictions set out at clauses 3.2 and 3.3 below, the User may be provided with access to test data in a non-live environment only, on the terms of this Agreement. 
+   2. Services and/or Beta Products provided to Customer during an Evaluation Period are provided "as is" and the Company provides no representations, warranties or guarantees whether express or implied regarding the Services. To the fullest extent permitted by applicable law, the Company shall have no liability to the Customer whether in contract, tort or otherwise and clause 8.4 shall not apply. 
+   3. On expiry or termination of the Evaluation Period any rights granted to the User herein shall cease and the provisions of clause 7 shall apply. 
+3. ACCESS TO THE SERVICE 
+   1. Subject to the terms and conditions of this EULA and any agreement agreed between the User and  Company, the Company hereby grants the User a non-exclusive, non-transferable license, during the term of the Agreement and subject to the terms of the Agreement, to use and access the Services, solely in accordance with the published documentation for the Services, for the Users own internal-use purposes.  
+   2. The User agrees not to: 
+      1. permit any third party to access and/or use the Services; 
+      2. rent, lease, loan, or sell access to the Services to any third party; 
+      3. interfere with, disrupt, alter, translate, or modify the Services or any part thereof, or create an undue burden on the Services or the networks or services connected to the Services; 
+      4. reverse-engineer the Services (except to the extent that such restriction on reverse engineering is prohibited by law in which case User shall provide the Company with prompt written notice prior to any such action), or access the Services to build a competitive product or service; or
+      5. introduce software or automated agents or scripts to the Services so as to produce multiple accounts, generate automated searches, requests and queries, or to strip or mine data from the Services.  
+   3. The Services, including any accounts,  passwords or other such log in or access information, may not be used by more than one individual user, and User agrees not to assist with or permit this.  
+   4. The Company reserves the right, at its discretion, to suspend or terminate any use and access to the Services that the Company reasonably determines have been used by an unauthorised third party.   
+4. OWNERSHIP AND INTELLECTUAL PROPERTY RIGHTS
+   1. The User acknowledges and agrees that the Rights, shall be the exclusive property of the Company. 
+   2. The User  hereby assigns to  the Company any suggestions, ideas, enhancement requests, improvements, feedback, recommendations or other information provided by the User related to the Services. 
+   3. All rights not expressly granted to the User are reserved to the Company. 
+   4. The Company makes no representation or warranty as to the validity or enforceability of the intellectual property rights in the Services.
+   5. Subject to clause 4.6 and 4.7, the Company shall defend the User against any third party claim that the use of the Services in accordance with this Agreement infringes any third party intellectual property right and shall indemnify the User for and against any amounts awarded against the User in judgment or settlement of such claims, provided that:
+      1. the Company is given prompt notice of such claim; 
+      2. User provides reasonable co-operation to the Company in the defence and settlement of such claim, at the Company’s expense; 
+      3. the Company is given sole authority to defend or settle the claim; and 
+      4. the User makes no admission of liability or fault itself or on behalf of the Company.
+   6. In the defence or settlement of any claim pursuant to clause 4.5 above, the Company may at its sole option and expense either: 
+      1. procure for the User the right to continue using the Services in the manner contemplated by this Agreement; 
+      2. replace or modify the Services so that it becomes non-infringing; or 
+      3. terminate this Agreement immediately by providing written notice to the User, without liability to the User.
+   7. The Company shall not be required to indemnify the User and disclaims all liability to the User, to the fullest extent permissible by applicable law,  if the alleged infringement is based on: 
+      1. modification of the Services by anyone other than the Company; or 
+      2. the User or any Authorised User’s use of the Services otherwise than in accordance with this Agreement or in a manner contrary to the instructions given to the User by the Company; or 
+      3. the User or any Authorised User’s use of the Services after notice of the alleged or actual infringement from the Company or any appropriate authority; or 
+      4. use or combination of the Services with any other software or hardware, in circumstances where, but for such combination, no infringement would have occurred.
+   8. User shall defend the Company against all, or any costs, claims, damages or expenses incurred by the Company in respect of any third party claim relating to the Customer’s or any Authorised User’s use of the Services otherwise than in accordance with this Agreement, provided that:
+      1. the User is given prompt notice of such claim; 
+      2. the Company provides reasonable co-operation to the User in the defence and settlement of such claim, at the User’s expense; 
+      3. the User is given sole authority to defend or settle the claim; 
+      4. the Company makes no admission of liability or fault itself or on behalf of the User;
+      5. any settlement will not entail an admission of fault or guilt by Company; and 
+   9. the settlement includes, as an unconditional term, the claimant’s or the plaintiff’s release of Company from all liability in respect of the claim).
+5. CONFIDENTIAL INFORMATION 
+   1. User will not use any Confidential Information for any purpose not expressly permitted by this EULA, and will disclose the Confidential Information only to the employees, consultants (to the extent acting on the User's  behalf and for its benefit), and agents of the User who have a need to know such Confidential Information for purposes of the Agreement and who are under a duty of confidentiality no less restrictive than the User’s duty hereunder.  
+   2. The User will protect the Confidential Information from unauthorised use, access, or disclosure in the same manner as the User protects its own confidential or proprietary information of a similar nature and with no less than reasonable care.  
+   3. The User will be allowed to disclose the Confidential Information to the extent that such disclosure is: 
+      1. specifically approved in writing by the Company, 
+      2. necessary in the course of legal proceedings for the User to defend itself or to enforce its rights under this EULA; or
+      3. required by law or by the order of a court or similar judicial or administrative body, provided that the User notifies the Company of such required disclosure promptly and in writing and cooperates with  the Company, at  the Company’s reasonable request and expense, in any lawful action to contest or limit the scope of such required disclosure.  
+   4. User will return to  the Company or destroy all tangible copies of Confidential Information in the User’s possession or control and permanently erase all electronic copies of Confidential Information promptly upon the expiration or termination of this EULA, whichever occurs first.
+6. SUPPORT SERVICES
+During the term of the EULA, the Company may provide support services directly to the User, or through the Authorised Reseller, such support terms being set out in the agreement between the User and the Authorised Reseller.
+7. TERMINATION 
+   1. Company may terminate this Agreement immediately whereby the User is in breach of the provisions of clause 3.2.
+   2. Notwithstanding the foregoing, any term or condition of the Agreement which by its sense or nature should be deemed to survive such termination shall so survive.  
+   3. Without affecting any other right or remedy available to it, either party may terminate this agreement with immediate effect by giving written notice to the other party if:
+      1. the fees are payable directly to the Company, the other party fails to pay an amount due under this agreement on the due date for payment and remains in default not less than ten (10) days after being notified to make such payment;
+      2. the other party commits a material breach of any term of this agreement and (if such breach is remediable) fails to remedy that breach within a period of thirty (30) days after being notified in writing to do so;
+      3. the other party takes or has taken against it (other than in relation to a solvent restructuring) any step or action towards its entering bankruptcy, administration, provisional liquidation or any composition or arrangement with its creditors, applying to court for or obtaining a moratorium under Part A1 of the Insolvency Act 1986, being wound up (whether voluntarily or by order of the court), being struck off the register of companies, having a receiver appointed to any of its assets, or its entering a procedure in any jurisdiction with a similar effect to a procedure listed in this clause 7.3.3;
+      4. the other party suspends or ceases, or threatens to suspend or cease, carrying on business; or
+      5. the User enters into an agreement with an Authorised Reseller which subsequently terminates or is terminated.
+   4. Without affecting any other right or remedy available to it, either party may terminate this agreement on giving not less than one months' written notice
+8. LIMITATION OF LIABILITY   
+   1. The Software is provided by the Company on an 'as is' basis and accordingly all implied warranties terms or otherwise are hereby expressly excluded from the terms of this Agreement, including any terms relating to fitness for purpose, satisfactory quality or otherwise.
+   2. In no event shall the Company be liable to the User for any special, indirect, incidental or consequential damages, or any damages or costs due to any direct or indirect loss of profits, data, use or goodwill, personal or property damage resulting from or in connection with this EULA, the service, or the use or inability to use the service, regardless of the cause of action or the theory of liability, whether in tort (including negligence), contract, or otherwise, even if the Company has been notified of the likelihood of such damages.  
+   3. Subject to clause 8.4, the maximum aggregate liability of the Company arising out of or in any way connected to this EULA whether in contract, tort (including negligence but excluding willful misconduct) or otherwise, shall be £10,000.
+   4. Neither party limits its liability (if any) to the other for: personal injury or death resulting from negligence; fraud; or any matter for which it would be illegal to exclude or to attempt to exclude its liability. 
+   5. The Company cannot guarantee the accuracy and functionality of the output of the Services and their results and so the Company shall have no liability in relation to the output and any subsequent usage of any data from the output by the User.
+9. FEES 
+   1. User shall pay the fees in accordance with this clause 9 and any payment terms specified by the Company from time to time without set-off in respect of any liability of the Company. 
+   2. Unless otherwise agreed with the Company, fees (and any expenses or other sums) payable under this Agreement are due at the point of sale. Payment confirmation will be provided after payment has been taken. 
+   3. All fees, expenses or other sums payable under this Agreement are exclusive of any applicable value added tax or other applicable taxes or duties for which the User shall be additionally liable. 
+   4. If any sum payable to the Company is not paid within 14 days after the due date the Company may suspend performance of its obligations and/or charge interest on a daily basis at the rate of 4% above the Bank of England's base rate from time to time in force, compounded quarterly, from the date for payment of that sum to the date of actual payment.
+   5. The Company shall be entitled to increase the  fees at any time upon thirty (30) days' prior written notice to the User before the start of a new or renewed . 
+   6. Where the User: (a) is participating in a Proof of Value; or (b)  has purchased the Services through an Authorised Reseller of the Supplier this clause 9 shall not apply.  
+10. MISCELLANEOUS 
+   1. Jurisdiction. This EULA and any dispute or claim arising out of it or in connection with it or its subject matter or formation (including non-contractual disputes or claims) shall be governed by and construed in accordance with the laws of England and Wales.  Each Party irrevocably agrees that the courts of England have exclusive jurisdiction to any dispute or claim arising out of or in connection with this EULA or its subject matter or formation (including non-contractual disputes or claims).   
+   2. No Partnership and Agency. The relationship between the parties is that of independent contractors and nothing in this Agreement shall be construed to create a partnership, joint venture, or agency relationship between the parties, nor authorise any Party to make or enter into any commitments for or on behalf of the other Party. Each Party confirms it is acting on its own behalf and not for the benefit of any other person. The parties acknowledge that the arrangements between them are non-exclusive. Nothing contained in this Agreement shall prohibit either of the parties from conducting business activities with other third parties. 
+   3. Compliance with laws. You shall always comply with all international and domestic laws, ordinances, regulations, and statutes that are applicable to its purchase and use of the Services.
+   4. Severance. If any provision of this EULA is, for any reason, held to be invalid or unenforceable, the other provisions of this EULA will remain enforceable, and the invalid or unenforceable provision will be deemed modified so that it is valid and enforceable to the maximum extent permitted by law.  
+   5. Waiver. No failure or delay by a Party to exercise any right or remedy provided under this Agreement or by law shall constitute a waiver of that or any other right or remedy, nor shall it prevent or restrict the further exercise of that or any other right or remedy. No single or partial exercise of such right or remedy shall prevent or restrict the further exercise of that or any other right or remedy. 
+   6. Assignment. Neither Party shall assign, subcontract, delegate, or otherwise transfer this EULA, or its rights and obligations herein, without obtaining the prior written consent of the other Party, and any attempted assignment, subcontract, delegation, or transfer in violation of the foregoing will be null and void; provided, however, that the Company may assign this EULA in connection with a merger, acquisition, reorganization or sale of all or substantially all of its assets, or other operation of law, without the User’s consent.  
+   7. Force Majeure. Any delay in the performance of any duties or obligations of either Party will not be considered a breach of this EULA if such delay is caused by a labor dispute, shortage of materials, fire, earthquake, flood, or any other event beyond the control of such Party, provided that such Party uses reasonable efforts, under the circumstances, to notify the other Party of the cause of such delay and to resume performance as soon as possible.   
+   8. Variation. No modification of or amendment to this EULA, or any waiver of any rights under this EULA, will be effective unless in writing and signed by an officer of the Company. 
+   9. Counterparts. This Agreement may be executed in any number of counterparts, each of which when executed shall constitute a duplicate original, but all the counterparts shall together constitute the one agreement.

vollo_rt-27.0.0.dist-info/METADATA

@@ -0,0 +1,9 @@
+Metadata-Version: 2.1
+Name: vollo-rt
+Version: 27.0.0
+License: Proprietary
+License-File: EULA.md
+Requires-Dist: cffi>=1.0.0
+Requires-Dist: torch>=1.11.0
+Requires-Dist: numpy
+

vollo_rt-27.0.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+_vollo_rt.py,sha256=8XqNhO6lkigehyldyx1uqgnRSMs36jb8mqn2wo7W_CY,4177
+vollo_rt/__init__.py,sha256=Yl8w3yHOgyRNE38nHj7d48FZlm7DdGXuBXj3k6UrCeY,20759
+vollo_rt-27.0.0.dist-info/EULA.md,sha256=0EKZV204TUv5L2XPMBz5WYtXoszclG-7U09UEGrvX6U,20275
+vollo_rt-27.0.0.dist-info/METADATA,sha256=w1CXbiOPqUiJORrI2yKVjDM9mzWUQmuLCZPhy9hyCh4,174
+vollo_rt-27.0.0.dist-info/WHEEL,sha256=VyG4dJCdJcxE1baiVBm9NET3Nj7Wne1lZZq7UFNxRpg,97
+vollo_rt-27.0.0.dist-info/top_level.txt,sha256=Dz8aD7eOptQIPlSZBC_UUoP42gZzlkvO1WiyYng7ytg,19
+vollo_rt-27.0.0.dist-info/RECORD,,

vollo_rt-27.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.1.1.post0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

vollo_rt-27.0.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+_vollo_rt
+vollo_rt