kinfer 0.3.3__cp311-cp311-macosx_11_0_arm64.whl → 0.4.0__cp311-cp311-macosx_11_0_arm64.whl

kinfer/rust_bindings/src/lib.rs

@@ -1,6 +1,15 @@
+use async_trait::async_trait;
+use kinfer::model::{ModelError, ModelProvider, ModelRunner};
+use kinfer::runtime::ModelRuntime;
+use ndarray::{Array, Ix1, IxDyn};
+use numpy::{PyArray1, PyArrayDyn, PyArrayMethods};
+use pyo3::exceptions::PyNotImplementedError;
 use pyo3::prelude::*;
+use pyo3::{pymodule, types::PyModule, Bound, PyResult, Python};
 use pyo3_stub_gen::define_stub_info_gatherer;
-use pyo3_stub_gen::derive::gen_stub_pyfunction;
+use pyo3_stub_gen::derive::{gen_stub_pyclass, gen_stub_pyfunction, gen_stub_pymethods};
+use std::sync::Arc;
+use std::sync::Mutex;
 
 #[pyfunction]
 #[gen_stub_pyfunction]
@@ -8,9 +17,309 @@ fn get_version() -> String {
     env!("CARGO_PKG_VERSION").to_string()
 }
 
+#[pyclass(subclass)]
+#[gen_stub_pyclass]
+pub struct ModelProviderABC;
+
+#[gen_stub_pymethods]
+#[pymethods]
+impl ModelProviderABC {
+    #[new]
+    fn new() -> Self {
+        ModelProviderABC
+    }
+
+    fn get_joint_angles<'py>(
+        &self,
+        joint_names: Vec<String>,
+    ) -> PyResult<Bound<'py, PyArray1<f32>>> {
+        let n = joint_names.len();
+        Err(PyNotImplementedError::new_err(format!(
+            "Must override get_joint_angles with {} joint names",
+            n
+        )))
+    }
+
+    fn get_joint_angular_velocities<'py>(
+        &self,
+        joint_names: Vec<String>,
+    ) -> PyResult<Bound<'py, PyArray1<f32>>> {
+        let n = joint_names.len();
+        Err(PyNotImplementedError::new_err(format!(
+            "Must override get_joint_angular_velocities with {} joint names",
+            n
+        )))
+    }
+
+    fn get_projected_gravity<'py>(&self) -> PyResult<Bound<'py, PyArray1<f32>>> {
+        Err(PyNotImplementedError::new_err(
+            "Must override get_projected_gravity",
+        ))
+    }
+
+    fn get_accelerometer<'py>(&self) -> PyResult<Bound<'py, PyArray1<f32>>> {
+        Err(PyNotImplementedError::new_err(
+            "Must override get_accelerometer",
+        ))
+    }
+
+    fn get_gyroscope<'py>(&self) -> PyResult<Bound<'py, PyArray1<f32>>> {
+        Err(PyNotImplementedError::new_err(
+            "Must override get_gyroscope",
+        ))
+    }
+
+    fn take_action<'py>(
+        &self,
+        joint_names: Vec<String>,
+        action: Bound<'py, PyArray1<f32>>,
+    ) -> PyResult<()> {
+        let n = action.len()?;
+        assert_eq!(joint_names.len(), n);
+        Err(PyNotImplementedError::new_err(format!(
+            "Must override take_action with {} action",
+            n
+        )))
+    }
+}
+
+#[gen_stub_pyclass]
+#[pyclass]
+#[derive(Clone)]
+struct PyModelProvider {
+    obj: Arc<Py<ModelProviderABC>>,
+}
+
+#[pymethods]
+impl PyModelProvider {
+    #[new]
+    fn new(obj: Py<ModelProviderABC>) -> Self {
+        Self { obj: Arc::new(obj) }
+    }
+}
+
+#[async_trait]
+impl ModelProvider for PyModelProvider {
+    async fn get_joint_angles(
+        &self,
+        joint_names: &[String],
+    ) -> Result<Array<f32, IxDyn>, ModelError> {
+        let args = Python::with_gil(|py| -> PyResult<Array<f32, IxDyn>> {
+            let obj = self.obj.clone();
+            let args = (joint_names,);
+            let result = obj.call_method(py, "get_joint_angles", args, None)?;
+            let array = result.extract::<Vec<f32>>(py)?;
+            Ok(Array::from_vec(array).into_dyn())
+        })
+        .map_err(|e| ModelError::Provider(e.to_string()))?;
+        Ok(args)
+    }
+
+    async fn get_joint_angular_velocities(
+        &self,
+        joint_names: &[String],
+    ) -> Result<Array<f32, IxDyn>, ModelError> {
+        let args = Python::with_gil(|py| -> PyResult<Array<f32, IxDyn>> {
+            let obj = self.obj.clone();
+            let args = (joint_names,);
+            let result = obj.call_method(py, "get_joint_angular_velocities", args, None)?;
+            let array = result.extract::<Vec<f32>>(py)?;
+            Ok(Array::from_vec(array).into_dyn())
+        })
+        .map_err(|e| ModelError::Provider(e.to_string()))?;
+        Ok(args)
+    }
+
+    async fn get_projected_gravity(&self) -> Result<Array<f32, IxDyn>, ModelError> {
+        let args = Python::with_gil(|py| -> PyResult<Array<f32, IxDyn>> {
+            let obj = self.obj.clone();
+            let args = ();
+            let result = obj.call_method(py, "get_projected_gravity", args, None)?;
+            let array = result.extract::<Vec<f32>>(py)?;
+            Ok(Array::from_vec(array).into_dyn())
+        })
+        .map_err(|e| ModelError::Provider(e.to_string()))?;
+        Ok(args)
+    }
+
+    async fn get_accelerometer(&self) -> Result<Array<f32, IxDyn>, ModelError> {
+        let args = Python::with_gil(|py| -> PyResult<Array<f32, IxDyn>> {
+            let obj = self.obj.clone();
+            let args = ();
+            let result = obj.call_method(py, "get_accelerometer", args, None)?;
+            let array = result.extract::<Vec<f32>>(py)?;
+            Ok(Array::from_vec(array).into_dyn())
+        })
+        .map_err(|e| ModelError::Provider(e.to_string()))?;
+        Ok(args)
+    }
+
+    async fn get_gyroscope(&self) -> Result<Array<f32, IxDyn>, ModelError> {
+        let args = Python::with_gil(|py| -> PyResult<Array<f32, IxDyn>> {
+            let obj = self.obj.clone();
+            let args = ();
+            let result = obj.call_method(py, "get_gyroscope", args, None)?;
+            let array = result.extract::<Vec<f32>>(py)?;
+            Ok(Array::from_vec(array).into_dyn())
+        })
+        .map_err(|e| ModelError::Provider(e.to_string()))?;
+        Ok(args)
+    }
+
+    async fn get_carry(&self, carry: Array<f32, IxDyn>) -> Result<Array<f32, IxDyn>, ModelError> {
+        Ok(carry)
+    }
+
+    async fn take_action(
+        &self,
+        joint_names: Vec<String>,
+        action: Array<f32, IxDyn>,
+    ) -> Result<(), ModelError> {
+        Python::with_gil(|py| -> PyResult<()> {
+            let obj = self.obj.clone();
+            let action_1d = action
+                .into_dimensionality::<Ix1>()
+                .map_err(|e| PyErr::new::<pyo3::exceptions::PyRuntimeError, _>(e.to_string()))?;
+            let args = (joint_names, PyArray1::from_array(py, &action_1d));
+            obj.call_method(py, "take_action", args, None)?;
+            Ok(())
+        })
+        .map_err(|e| ModelError::Provider(e.to_string()))?;
+        Ok(())
+    }
+}
+
+#[gen_stub_pyclass]
+#[pyclass]
+#[derive(Clone)]
+struct PyModelRunner {
+    runner: Arc<ModelRunner>,
+}
+
+#[gen_stub_pymethods]
+#[pymethods]
+impl PyModelRunner {
+    #[new]
+    fn new(model_path: String, provider: Py<ModelProviderABC>) -> PyResult<Self> {
+        let input_provider = Arc::new(PyModelProvider {
+            obj: Arc::new(provider),
+        });
+
+        let runner = tokio::runtime::Runtime::new().unwrap().block_on(async {
+            ModelRunner::new(model_path, input_provider)
+                .await
+                .map_err(|e| PyErr::new::<pyo3::exceptions::PyRuntimeError, _>(e.to_string()))
+        })?;
+
+        Ok(Self {
+            runner: Arc::new(runner),
+        })
+    }
+
+    fn init(&self) -> PyResult<Py<PyArrayDyn<f32>>> {
+        let runner = self.runner.clone();
+        let result = tokio::runtime::Runtime::new().unwrap().block_on(async {
+            runner
+                .init()
+                .await
+                .map_err(|e| PyErr::new::<pyo3::exceptions::PyRuntimeError, _>(e.to_string()))
+        })?;
+
+        Python::with_gil(|py| {
+            let array = numpy::PyArray::from_array(py, &result);
+            Ok(array.into())
+        })
+    }
+
+    fn step(
+        &self,
+        carry: Py<PyArrayDyn<f32>>,
+    ) -> PyResult<(Py<PyArrayDyn<f32>>, Py<PyArrayDyn<f32>>)> {
+        let runner = self.runner.clone();
+        let carry_array = Python::with_gil(|py| -> PyResult<Array<f32, IxDyn>> {
+            let carry_array = carry.bind(py);
+            Ok(carry_array.to_owned_array())
+        })?;
+
+        let result = tokio::runtime::Runtime::new().unwrap().block_on(async {
+            runner
+                .step(carry_array)
+                .await
+                .map_err(|e| PyErr::new::<pyo3::exceptions::PyRuntimeError, _>(e.to_string()))
+        })?;
+
+        Python::with_gil(|py| {
+            let (output, carry) = result;
+            let output_array = numpy::PyArray::from_array(py, &output);
+            let carry_array = numpy::PyArray::from_array(py, &carry);
+            Ok((output_array.into(), carry_array.into()))
+        })
+    }
+
+    fn take_action(&self, action: Py<PyArrayDyn<f32>>) -> PyResult<()> {
+        let runner = self.runner.clone();
+        let action_array = Python::with_gil(|py| -> PyResult<Array<f32, IxDyn>> {
+            let action_array = action.bind(py);
+            Ok(action_array.to_owned_array())
+        })?;
+
+        tokio::runtime::Runtime::new().unwrap().block_on(async {
+            runner
+                .take_action(action_array)
+                .await
+                .map_err(|e| PyErr::new::<pyo3::exceptions::PyRuntimeError, _>(e.to_string()))
+        })?;
+
+        Ok(())
+    }
+}
+
+#[gen_stub_pyclass]
+#[pyclass]
+#[derive(Clone)]
+struct PyModelRuntime {
+    runtime: Arc<Mutex<ModelRuntime>>,
+}
+
+#[gen_stub_pymethods]
+#[pymethods]
+impl PyModelRuntime {
+    #[new]
+    fn new(model_runner: PyModelRunner, dt: u64) -> PyResult<Self> {
+        Ok(Self {
+            runtime: Arc::new(Mutex::new(ModelRuntime::new(model_runner.runner, dt))),
+        })
+    }
+
+    fn set_slowdown_factor(&self, slowdown_factor: i32) {
+        let mut runtime = self.runtime.lock().unwrap();
+        runtime.set_slowdown_factor(slowdown_factor);
+    }
+
+    fn set_magnitude_factor(&self, magnitude_factor: f32) {
+        let mut runtime = self.runtime.lock().unwrap();
+        runtime.set_magnitude_factor(magnitude_factor);
+    }
+
+    fn start(&self) -> PyResult<()> {
+        let mut runtime = self.runtime.lock().unwrap();
+        runtime
+            .start()
+            .map_err(|e| PyErr::new::<pyo3::exceptions::PyRuntimeError, _>(e.to_string()))
+    }
+
+    fn stop(&self) {
+        let mut runtime = self.runtime.lock().unwrap();
+        runtime.stop();
+    }
+}
+
 #[pymodule]
 fn rust_bindings(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(get_version, m)?)?;
+    m.add_class::<ModelProviderABC>()?;
+    m.add_class::<PyModelRunner>()?;
+    m.add_class::<PyModelRuntime>()?;
     Ok(())
 }
 

kinfer/rust_bindings.pyi

@@ -1,7 +1,35 @@
 # This file is automatically generated by pyo3_stub_gen
 # ruff: noqa: E501, F401
 
+import builtins
+import numpy
+import numpy.typing
+import typing
 
-def get_version() -> str:
+class ModelProviderABC:
+    def __new__(cls) -> ModelProviderABC: ...
+    def get_joint_angles(self, joint_names:typing.Sequence[builtins.str]) -> numpy.typing.NDArray[numpy.float32]: ...
+    def get_joint_angular_velocities(self, joint_names:typing.Sequence[builtins.str]) -> numpy.typing.NDArray[numpy.float32]: ...
+    def get_projected_gravity(self) -> numpy.typing.NDArray[numpy.float32]: ...
+    def get_accelerometer(self) -> numpy.typing.NDArray[numpy.float32]: ...
+    def get_gyroscope(self) -> numpy.typing.NDArray[numpy.float32]: ...
+    def take_action(self, joint_names:typing.Sequence[builtins.str], action:numpy.typing.NDArray[numpy.float32]) -> None: ...
+
+class PyModelProvider:
     ...
 
+class PyModelRunner:
+    def __new__(cls, model_path:builtins.str, provider:ModelProviderABC) -> PyModelRunner: ...
+    def init(self) -> numpy.typing.NDArray[numpy.float32]: ...
+    def step(self, carry:numpy.typing.NDArray[numpy.float32]) -> tuple[numpy.typing.NDArray[numpy.float32], numpy.typing.NDArray[numpy.float32]]: ...
+    def take_action(self, action:numpy.typing.NDArray[numpy.float32]) -> None: ...
+
+class PyModelRuntime:
+    def __new__(cls, model_runner:PyModelRunner, dt:builtins.int) -> PyModelRuntime: ...
+    def set_slowdown_factor(self, slowdown_factor:builtins.int) -> None: ...
+    def set_magnitude_factor(self, magnitude_factor:builtins.float) -> None: ...
+    def start(self) -> None: ...
+    def stop(self) -> None: ...
+
+def get_version() -> builtins.str: ...
+

kinfer-0.4.0.dist-info/METADATA

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: kinfer
+Version: 0.4.0
+Summary: Tool to make it easier to run a model on a real robot
+Home-page: https://github.com/kscalelabs/kinfer.git
+Author: K-Scale Labs
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: onnx
+Requires-Dist: onnxruntime==1.20.0
+Requires-Dist: pydantic
+Provides-Extra: dev
+Requires-Dist: black; extra == "dev"
+Requires-Dist: darglint; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: types-tensorflow; extra == "dev"
+Provides-Extra: pytorch
+Requires-Dist: torch; extra == "pytorch"
+Provides-Extra: jax
+Requires-Dist: tensorflow; extra == "jax"
+Requires-Dist: tf2onnx; extra == "jax"
+Requires-Dist: jax; extra == "jax"
+Requires-Dist: equinox; extra == "jax"
+Requires-Dist: numpy<2; extra == "jax"
+Provides-Extra: all
+Requires-Dist: black; extra == "all"
+Requires-Dist: darglint; extra == "all"
+Requires-Dist: mypy; extra == "all"
+Requires-Dist: pytest; extra == "all"
+Requires-Dist: ruff; extra == "all"
+Requires-Dist: types-tensorflow; extra == "all"
+Requires-Dist: torch; extra == "all"
+Requires-Dist: tensorflow; extra == "all"
+Requires-Dist: tf2onnx; extra == "all"
+Requires-Dist: jax; extra == "all"
+Requires-Dist: equinox; extra == "all"
+Requires-Dist: numpy<2; extra == "all"
+Dynamic: author
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# kinfer
+
+This package is designed to support running real-time robotics models.
+
+For more information, see the documentation [here](https://docs.kscale.dev/docs/k-infer).

kinfer-0.4.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+kinfer/rust_bindings.cpython-311-darwin.so,sha256=lwkKH5R0rx9hsMdjtsNcSWwdFM93Bz2Eg_91Hpcx7vg,1931696
+kinfer/requirements.txt,sha256=j08HO4ptA5afuj99j8FlAP2qla5Zf4_OiEBtgAmF7Jg,90
+kinfer/__init__.py,sha256=YbtJIepEE4pbjYbdgFCV-rBP90AnQpBfDaprkflBmEE,99
+kinfer/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kinfer/rust_bindings.pyi,sha256=oQKlW_bRw_c7fgVMbqiscPJ57pli25DkTCA_odsMOSU,1639
+kinfer/rust/Cargo.toml,sha256=0SLLbjtoODLrSMcyPdg22Ora-JNdaCqbMKb1c5OQblU,404
+kinfer/rust/src/runtime.rs,sha256=eDflFSIa4IxOmG3SInwrHrYc02UzEANZMkK-liA7pVA,3407
+kinfer/rust/src/lib.rs,sha256=Z3dWdhKhqhWqPJee6vWde4ptqquOYW6W9wB0wyaKCyk,71
+kinfer/rust/src/model.rs,sha256=pODQzD-roXpCJ7-kzaE6uULgqHgsHKb3oQjv-uKtCYk,10668
+kinfer/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kinfer/common/types.py,sha256=Yf3c8Tui7vWguXMmxxa_QynwydCPu9RxrJS8JJMDuKg,147
+kinfer/export/serialize.py,sha256=pOxXdcWMoaNfnAUhgzHUTb7GtZvn0MYtKskIarHzAiY,3007
+kinfer/export/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kinfer/export/jax.py,sha256=nbZB7Bxed4MQmfBZrH_Ml6PnkHQoyq5jdOT01DxiZDA,1337
+kinfer/export/pytorch.py,sha256=twGpcX6OaJgiiwQ0teo_4rrCFTrCqu-ULH2UEHl8auc,1477
+kinfer/export/common.py,sha256=ZiOAtehb2_ATg7t3tWzxbHUkGhtJ8vqjlaaw94-Iux4,1021
+kinfer/rust_bindings/Cargo.toml,sha256=i1RGB9VNd9Q4FJ6gGwjZJQYo8DBBvpVWf3GJ95EfVgM,637
+kinfer/rust_bindings/pyproject.toml,sha256=jLcJuHCnQRh9HWR_R7a9qLHwj6LMBgnHyeKK_DruO1Y,135
+kinfer/rust_bindings/rust_bindings.pyi,sha256=oQKlW_bRw_c7fgVMbqiscPJ57pli25DkTCA_odsMOSU,1639
+kinfer/rust_bindings/src/lib.rs,sha256=lKYr6Imu0Z-XxDKCguJLfrhIuai6S2bEhRAe__9sFnc,10196
+kinfer/rust_bindings/src/bin/stub_gen.rs,sha256=hhoVGnaSfazbSfj5a4x6mPicGPOgWQAfsDmiPej0B6Y,133
+kinfer-0.4.0.dist-info/RECORD,,
+kinfer-0.4.0.dist-info/WHEEL,sha256=rtKwvZSAzWV03G3Ircwq_TRBlj2DQz4ocNXl0bd9DbU,136
+kinfer-0.4.0.dist-info/top_level.txt,sha256=6mY_t3PYr3Dm0dpqMk80uSnArbvGfCFkxOh1QWtgDEo,7
+kinfer-0.4.0.dist-info/METADATA,sha256=2gGRmUwgmAoYK8kRG5qTtteIMrdaUYW7Edvpk_32yas,1745
+kinfer-0.4.0.dist-info/licenses/LICENSE,sha256=Qw-Z0XTwS-diSW91e_jLeBPX9zZbAatOJTBLdPHPaC0,1069

{kinfer-0.3.3.dist-info → kinfer-0.4.0.dist-info}/WHEEL

@@ -1,5 +1,6 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.6.0)
+Generator: setuptools (80.4.0)
 Root-Is-Purelib: false
 Tag: cp311-cp311-macosx_11_0_arm64
+Generator: delocate 0.13.0
 

kinfer/inference/__init__.py

@@ -1,2 +0,0 @@
-from .base import KModel
-from .python import ONNXModel

kinfer/inference/base.py

@@ -1,64 +0,0 @@
-"""Defines the base interface for running model inference.
-
-All kinfer models must implement this interface - the model inputs and outputs
-should match the provided schema, and the `__call__` method should take the
-inputs and return the outputs according to this schema.
-"""
-
-import functools
-from abc import ABC, abstractmethod
-
-from kinfer import proto as K
-
-
-class KModel(ABC):
-    """Base interface for running model inference."""
-
-    @abstractmethod
-    def get_schema(self) -> K.ModelSchema:
-        """Get the model schema."""
-
-    @abstractmethod
-    def __call__(self, inputs: K.IO) -> K.IO:
-        """Run inference on input data.
-
-        Args:
-            inputs: Input data, matching the input schema.
-
-        Returns:
-            Model outputs, matching the output schema.
-        """
-
-    @functools.cached_property
-    def schema(self) -> K.ModelSchema:
-        return self.get_schema()
-
-    @property
-    def input_schema(self) -> K.IOSchema:
-        """Get the input schema."""
-        return self.schema.input_schema
-
-    @property
-    def output_schema(self) -> K.IOSchema:
-        """Get the output schema."""
-        return self.schema.output_schema
-
-    @property
-    def schema_input_keys(self) -> list[str]:
-        """Get all value names from input schemas.
-
-        Returns:
-            List of value names from input schema.
-        """
-        input_names = [value.value_name for value in self.input_schema.values]
-        return input_names
-
-    @property
-    def schema_output_keys(self) -> list[str]:
-        """Get all value names from output schemas.
-
-        Returns:
-            List of value names from output schema.
-        """
-        output_names = [value.value_name for value in self.output_schema.values]
-        return output_names

kinfer/inference/python.py

@@ -1,66 +0,0 @@
-"""ONNX model inference utilities for Python."""
-
-import base64
-from pathlib import Path
-
-import onnx
-import onnxruntime as ort
-
-from kinfer import proto as K
-from kinfer.export.pytorch import KINFER_METADATA_KEY
-from kinfer.inference.base import KModel
-from kinfer.serialize.numpy import NumpyMultiSerializer
-
-
-def _read_schema(model: onnx.ModelProto) -> K.ModelSchema:
-    for prop in model.metadata_props:
-        if prop.key == KINFER_METADATA_KEY:
-            try:
-                schema_bytes = base64.b64decode(prop.value)
-                schema = K.ModelSchema()
-                schema.ParseFromString(schema_bytes)
-                return schema
-            except Exception as e:
-                raise ValueError("Failed to parse kinfer_metadata value") from e
-        else:
-            raise ValueError(f"Found arbitrary metadata key {prop.key}")
-
-    raise ValueError(f"{KINFER_METADATA_KEY} not found in model metadata")
-
-
-class ONNXModel(KModel):
-    """Wrapper for ONNX model inference."""
-
-    def __init__(self: "ONNXModel", model_path: str | Path) -> None:
-        """Initialize ONNX model.
-
-        Args:
-            model_path: Path to ONNX model file
-        """
-        self.model_path = model_path
-
-        # Load model and create inference session
-        self.model = onnx.load(model_path)
-        self.session = ort.InferenceSession(model_path)
-        self._schema = _read_schema(self.model)
-
-        # Create serializers for input and output.
-        self._input_serializer = NumpyMultiSerializer(self._schema.input_schema)
-        self._output_serializer = NumpyMultiSerializer(self._schema.output_schema)
-
-    def get_schema(self) -> K.ModelSchema:
-        return self._schema
-
-    def __call__(self, inputs: K.IO) -> K.IO:
-        """Run inference on input data.
-
-        Args:
-            inputs: Input data, matching the input schema.
-
-        Returns:
-            Model outputs, matching the output schema.
-        """
-        inputs_np = self._input_serializer.serialize_io(inputs, as_dict=True)
-        outputs_np = self.session.run(None, inputs_np)
-        outputs = self._output_serializer.deserialize_io(outputs_np)
-        return outputs

kinfer/proto/__init__.py

@@ -1,40 +0,0 @@
-"""Defines helper types for the protocol buffers."""
-
-from .kinfer_pb2 import (
-    IO,
-    AudioFrameSchema,
-    AudioFrameValue,
-    CameraFrameSchema,
-    CameraFrameValue,
-    DType,
-    ImuAccelerometerValue,
-    ImuGyroscopeValue,
-    ImuMagnetometerValue,
-    ImuSchema,
-    ImuValue,
-    IOSchema,
-    JointCommandsSchema,
-    JointCommandsValue,
-    JointCommandValue,
-    JointPositionsSchema,
-    JointPositionsValue,
-    JointPositionUnit,
-    JointPositionValue,
-    JointTorquesSchema,
-    JointTorquesValue,
-    JointTorqueUnit,
-    JointTorqueValue,
-    JointVelocitiesSchema,
-    JointVelocitiesValue,
-    JointVelocityUnit,
-    JointVelocityValue,
-    ModelSchema,
-    StateTensorSchema,
-    StateTensorValue,
-    TimestampSchema,
-    TimestampValue,
-    Value,
-    ValueSchema,
-    VectorCommandSchema,
-    VectorCommandValue,
-)