kinfer 0.3.2__cp312-cp312-macosx_11_0_arm64.whl → 0.3.3__cp312-cp312-macosx_11_0_arm64.whl

kinfer/serialize/schema.py

@@ -2,19 +2,19 @@
 
 import numpy as np
 
-from kinfer import proto as P
+from kinfer import proto as K
 from kinfer.serialize.utils import dtype_num_bytes
 
 
-def get_dummy_value(value_schema: P.ValueSchema) -> P.Value:
+def get_dummy_value(value_schema: K.ValueSchema) -> K.Value:
     value_type = value_schema.WhichOneof("value_type")
 
     match value_type:
         case "joint_positions":
-            return P.Value(
-                joint_positions=P.JointPositionsValue(
+            return K.Value(
+                joint_positions=K.JointPositionsValue(
                     values=[
-                        P.JointPositionValue(
+                        K.JointPositionValue(
                             joint_name=joint_name,
                             value=0.0,
                             unit=value_schema.joint_positions.unit,
@@ -24,10 +24,10 @@ def get_dummy_value(value_schema: P.ValueSchema) -> P.Value:
                 ),
             )
         case "joint_velocities":
-            return P.Value(
-                joint_velocities=P.JointVelocitiesValue(
+            return K.Value(
+                joint_velocities=K.JointVelocitiesValue(
                     values=[
-                        P.JointVelocityValue(
+                        K.JointVelocityValue(
                             joint_name=joint_name,
                             value=0.0,
                             unit=value_schema.joint_velocities.unit,
@@ -37,10 +37,10 @@ def get_dummy_value(value_schema: P.ValueSchema) -> P.Value:
                 ),
             )
         case "joint_torques":
-            return P.Value(
-                joint_torques=P.JointTorquesValue(
+            return K.Value(
+                joint_torques=K.JointTorquesValue(
                     values=[
-                        P.JointTorqueValue(
+                        K.JointTorqueValue(
                             joint_name=joint_name,
                             value=0.0,
                             unit=value_schema.joint_torques.unit,
@@ -50,10 +50,10 @@ def get_dummy_value(value_schema: P.ValueSchema) -> P.Value:
                 ),
             )
         case "joint_commands":
-            return P.Value(
-                joint_commands=P.JointCommandsValue(
+            return K.Value(
+                joint_commands=K.JointCommandsValue(
                     values=[
-                        P.JointCommandValue(
+                        K.JointCommandValue(
                             joint_name=joint_name,
                             torque=0.0,
                             velocity=0.0,
@@ -69,8 +69,8 @@ def get_dummy_value(value_schema: P.ValueSchema) -> P.Value:
                 ),
             )
         case "camera_frame":
-            return P.Value(
-                camera_frame=P.CameraFrameValue(
+            return K.Value(
+                camera_frame=K.CameraFrameValue(
                     data=b"\x00"
                     * (
                         value_schema.camera_frame.width
@@ -80,8 +80,8 @@ def get_dummy_value(value_schema: P.ValueSchema) -> P.Value:
                 ),
             )
         case "audio_frame":
-            return P.Value(
-                audio_frame=P.AudioFrameValue(
+            return K.Value(
+                audio_frame=K.AudioFrameValue(
                     data=b"\x00"
                     * (
                         value_schema.audio_frame.channels
@@ -91,24 +91,24 @@ def get_dummy_value(value_schema: P.ValueSchema) -> P.Value:
                 ),
             )
         case "imu":
-            return P.Value(
-                imu=P.ImuValue(
-                    linear_acceleration=P.ImuAccelerometerValue(x=0.0, y=0.0, z=0.0),
-                    angular_velocity=P.ImuGyroscopeValue(x=0.0, y=0.0, z=0.0),
-                    magnetic_field=P.ImuMagnetometerValue(x=0.0, y=0.0, z=0.0),
+            return K.Value(
+                imu=K.ImuValue(
+                    linear_acceleration=K.ImuAccelerometerValue(x=0.0, y=0.0, z=0.0),
+                    angular_velocity=K.ImuGyroscopeValue(x=0.0, y=0.0, z=0.0),
+                    magnetic_field=K.ImuMagnetometerValue(x=0.0, y=0.0, z=0.0),
                 ),
             )
         case "timestamp":
-            return P.Value(
-                timestamp=P.TimestampValue(seconds=1728000000, nanos=0),
+            return K.Value(
+                timestamp=K.TimestampValue(seconds=1728000000, nanos=0),
             )
         case "vector_command":
-            return P.Value(
-                vector_command=P.VectorCommandValue(values=[0.0] * value_schema.vector_command.dimensions),
+            return K.Value(
+                vector_command=K.VectorCommandValue(values=[0.0] * value_schema.vector_command.dimensions),
             )
         case "state_tensor":
-            return P.Value(
-                state_tensor=P.StateTensorValue(
+            return K.Value(
+                state_tensor=K.StateTensorValue(
                     data=b"\x00"
                     * np.prod(value_schema.state_tensor.shape)
                     * dtype_num_bytes(value_schema.state_tensor.dtype)
@@ -118,8 +118,8 @@ def get_dummy_value(value_schema: P.ValueSchema) -> P.Value:
             raise ValueError(f"Invalid value type: {value_type}")
 
 
-def get_dummy_io(schema: P.IOSchema) -> P.IO:
-    io_value = P.IO()
+def get_dummy_io(schema: K.IOSchema) -> K.IO:
+    io_value = K.IO()
     for value_schema in schema.values:
         io_value.values.append(get_dummy_value(value_schema))
     return io_value

kinfer/serialize/types.py

@@ -2,16 +2,16 @@
 
 from typing import Type, TypeVar, cast
 
-from kinfer import proto as P
+from kinfer import proto as K
 
 T = TypeVar("T")
 
 
-def to_value_type(enum_value: T) -> P.Value:
+def to_value_type(enum_value: T) -> K.Value:
     """Convert an enum value to ValueType."""
-    return cast(P.Value, enum_value)
+    return cast(K.Value, enum_value)
 
 
-def from_value_type(value_type: P.Value, enum_class: Type[T]) -> T:
+def from_value_type(value_type: K.Value, enum_class: Type[T]) -> T:
     """Convert a ValueType to the specified enum type."""
     return cast(T, value_type)

kinfer/serialize/utils.py

@@ -6,112 +6,112 @@ from typing import Any, Collection
 import numpy as np
 import torch
 
-from kinfer import proto as P
+from kinfer import proto as K
 
 
-def numpy_dtype(dtype: P.DType.ValueType) -> type[np.floating] | type[np.integer]:
+def numpy_dtype(dtype: K.DType.ValueType) -> type[np.floating] | type[np.integer]:
     match dtype:
-        case P.DType.FP8:
+        case K.DType.FP8:
             raise NotImplementedError("FP8 is not supported")
-        case P.DType.FP16:
+        case K.DType.FP16:
             return np.float16
-        case P.DType.FP32:
+        case K.DType.FP32:
             return np.float32
-        case P.DType.FP64:
+        case K.DType.FP64:
             return np.float64
-        case P.DType.INT8:
+        case K.DType.INT8:
             return np.int8
-        case P.DType.INT16:
+        case K.DType.INT16:
             return np.int16
-        case P.DType.INT32:
+        case K.DType.INT32:
             return np.int32
-        case P.DType.INT64:
+        case K.DType.INT64:
             return np.int64
-        case P.DType.UINT8:
+        case K.DType.UINT8:
             return np.uint8
-        case P.DType.UINT16:
+        case K.DType.UINT16:
             return np.uint16
-        case P.DType.UINT32:
+        case K.DType.UINT32:
             return np.uint32
-        case P.DType.UINT64:
+        case K.DType.UINT64:
             return np.uint64
         case _:
             raise ValueError(f"Unsupported dtype: {dtype}")
 
 
-def pytorch_dtype(dtype: P.DType.ValueType) -> torch.dtype:
+def pytorch_dtype(dtype: K.DType.ValueType) -> torch.dtype:
     match dtype:
-        case P.DType.FP8:
+        case K.DType.FP8:
             raise NotImplementedError("FP8 is not supported")
-        case P.DType.FP16:
+        case K.DType.FP16:
             return torch.float16
-        case P.DType.FP32:
+        case K.DType.FP32:
             return torch.float32
-        case P.DType.FP64:
+        case K.DType.FP64:
             return torch.float64
-        case P.DType.INT8:
+        case K.DType.INT8:
             return torch.int8
-        case P.DType.INT16:
+        case K.DType.INT16:
             return torch.int16
-        case P.DType.INT32:
+        case K.DType.INT32:
             return torch.int32
-        case P.DType.INT64:
+        case K.DType.INT64:
             return torch.int64
-        case P.DType.UINT8:
+        case K.DType.UINT8:
             return torch.uint8
-        case P.DType.UINT16:
+        case K.DType.UINT16:
             return torch.uint16
-        case P.DType.UINT32:
+        case K.DType.UINT32:
             return torch.uint32
-        case P.DType.UINT64:
+        case K.DType.UINT64:
             return torch.uint64
         case _:
             raise ValueError(f"Unsupported dtype: {dtype}")
 
 
-def parse_bytes(data: bytes, dtype: P.DType.ValueType) -> np.ndarray:
+def parse_bytes(data: bytes, dtype: K.DType.ValueType) -> np.ndarray:
     return np.frombuffer(data, dtype=numpy_dtype(dtype))
 
 
-def dtype_num_bytes(dtype: P.DType.ValueType) -> int:
+def dtype_num_bytes(dtype: K.DType.ValueType) -> int:
     match dtype:
-        case P.DType.FP8 | P.DType.INT8 | P.DType.UINT8:
+        case K.DType.FP8 | K.DType.INT8 | K.DType.UINT8:
             return 1
-        case P.DType.FP16 | P.DType.INT16 | P.DType.UINT16:
+        case K.DType.FP16 | K.DType.INT16 | K.DType.UINT16:
             return 2
-        case P.DType.FP32 | P.DType.INT32 | P.DType.UINT32:
+        case K.DType.FP32 | K.DType.INT32 | K.DType.UINT32:
             return 4
-        case P.DType.FP64 | P.DType.INT64 | P.DType.UINT64:
+        case K.DType.FP64 | K.DType.INT64 | K.DType.UINT64:
             return 8
         case _:
             raise ValueError(f"Unsupported dtype: {dtype}")
 
 
-def dtype_range(dtype: P.DType.ValueType) -> tuple[int, int]:
+def dtype_range(dtype: K.DType.ValueType) -> tuple[int, int]:
     match dtype:
-        case P.DType.FP8:
+        case K.DType.FP8:
             return -1, 1
-        case P.DType.FP16:
+        case K.DType.FP16:
             return -1, 1
-        case P.DType.FP32:
+        case K.DType.FP32:
             return -1, 1
-        case P.DType.FP64:
+        case K.DType.FP64:
             return -1, 1
-        case P.DType.INT8:
+        case K.DType.INT8:
             return -(2**7), 2**7 - 1
-        case P.DType.INT16:
+        case K.DType.INT16:
             return -(2**15), 2**15 - 1
-        case P.DType.INT32:
+        case K.DType.INT32:
             return -(2**31), 2**31 - 1
-        case P.DType.INT64:
+        case K.DType.INT64:
             return -(2**63), 2**63 - 1
-        case P.DType.UINT8:
+        case K.DType.UINT8:
             return 0, 2**8 - 1
-        case P.DType.UINT16:
+        case K.DType.UINT16:
             return 0, 2**16 - 1
-        case P.DType.UINT32:
+        case K.DType.UINT32:
             return 0, 2**32 - 1
-        case P.DType.UINT64:
+        case K.DType.UINT64:
             return 0, 2**64 - 1
         case _:
             raise ValueError(f"Unsupported dtype: {dtype}")
@@ -119,8 +119,8 @@ def dtype_range(dtype: P.DType.ValueType) -> tuple[int, int]:
 
 def convert_torque(
     value: float,
-    from_unit: P.JointTorqueUnit.ValueType,
-    to_unit: P.JointTorqueUnit.ValueType,
+    from_unit: K.JointTorqueUnit.ValueType,
+    to_unit: K.JointTorqueUnit.ValueType,
 ) -> float:
     if from_unit == to_unit:
         return value
@@ -129,30 +129,30 @@ def convert_torque(
 
 def convert_angular_velocity(
     value: float,
-    from_unit: P.JointVelocityUnit.ValueType,
-    to_unit: P.JointVelocityUnit.ValueType,
+    from_unit: K.JointVelocityUnit.ValueType,
+    to_unit: K.JointVelocityUnit.ValueType,
 ) -> float:
     if from_unit == to_unit:
         return value
-    if from_unit == P.JointVelocityUnit.DEGREES_PER_SECOND:
-        assert to_unit == P.JointVelocityUnit.RADIANS_PER_SECOND
+    if from_unit == K.JointVelocityUnit.DEGREES_PER_SECOND:
+        assert to_unit == K.JointVelocityUnit.RADIANS_PER_SECOND
         return value * math.pi / 180
-    if from_unit == P.JointVelocityUnit.RADIANS_PER_SECOND:
-        assert to_unit == P.JointVelocityUnit.DEGREES_PER_SECOND
+    if from_unit == K.JointVelocityUnit.RADIANS_PER_SECOND:
+        assert to_unit == K.JointVelocityUnit.DEGREES_PER_SECOND
         return value * 180 / math.pi
     raise ValueError(f"Unsupported unit: {from_unit}")
 
 
 def convert_angular_position(
     value: float,
-    from_unit: P.JointPositionUnit.ValueType,
-    to_unit: P.JointPositionUnit.ValueType,
+    from_unit: K.JointPositionUnit.ValueType,
+    to_unit: K.JointPositionUnit.ValueType,
 ) -> float:
     if from_unit == to_unit:
         return value
-    if from_unit == P.JointPositionUnit.DEGREES:
+    if from_unit == K.JointPositionUnit.DEGREES:
         return value * math.pi / 180
-    if from_unit == P.JointPositionUnit.RADIANS:
+    if from_unit == K.JointPositionUnit.RADIANS:
         return value * 180 / math.pi
     raise ValueError(f"Unsupported unit: {from_unit}")
 

{kinfer-0.3.2.dist-info → kinfer-0.3.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kinfer
-Version: 0.3.2
+Version: 0.3.3
 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

{kinfer-0.3.2.dist-info → kinfer-0.3.3.dist-info}/RECORD

@@ -1,9 +1,9 @@
 kinfer/requirements.txt,sha256=-xI0a63Os_v2mkO0Cy5bA5envglD-2c4mdSeLG4movA,91
-kinfer/__init__.py,sha256=LSRl3lC7SWBk9or4fT1TYYPP92yhEeRca-3gxG8urM0,131
+kinfer/__init__.py,sha256=Mt6PA3d3U9voePY0_GQ7rkc9Dgov93jY_OiFHcNDdBg,311
 kinfer/requirements-dev.txt,sha256=jZzaEENgXPHkAjbnwdglVCaV_GDkwCWIX2BWX0e3uLc,70
 kinfer/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kinfer/rust_bindings.pyi,sha256=KFNalMmwkfoS8BwJfVAz5APaqlW1ryp0xpmnbfud5kc,118
-kinfer/rust_bindings.cpython-312-darwin.so,sha256=UrAjAA3g9AScLwaUBNueJET4KWt7fO8oT44wbJd_ldI,436120
+kinfer/rust_bindings.cpython-312-darwin.so,sha256=BZR-t6bOln21TcAfBbG52_Fr-PpKF8XannDy1AeULjw,436120
 kinfer/proto/kinfer_pb2.pyi,sha256=ogFIJ7p2G-ovFig6I0RfIpH4oZ4dd2MkxPznBXENkb8,34151
 kinfer/proto/__init__.py,sha256=Zz2ApZaHIF375552y54X63XEq3XhZjyujmX_MsNjLmQ,848
 kinfer/proto/kinfer_pb2.py,sha256=sng4W-ZOdBgCowYK3JcoxoFOmUhPac07YDaoi6noeq0,11968
@@ -16,24 +16,25 @@ kinfer/rust/src/onnx_serializer.rs,sha256=Ti0iLoJi5VPkX_Yq7QPHzmtiJZPXvySUqRw8sy
 kinfer/rust/src/serializer.rs,sha256=jaSnb6K8DDynCLdgBU4Nl4Ig8ZrZRdQUXjdZF1Ew7qs,6151
 kinfer/rust/src/model.rs,sha256=5IWOkl_yj8Ea7yZkFug18ALwKrOtUAg17d7RphrMP1Y,5243
 kinfer/rust/src/tests/onnx_serializer_tests.rs,sha256=KdrysHqhYC27lIdkNTSUJ9CTBs0PN0-8aw2Xe3pqk4E,7481
-kinfer/serialize/__init__.py,sha256=zUAaf-EpWtDF3ZTneoP0-wS2TjzhFrp5-5xs_yie1ZA,1281
-kinfer/serialize/numpy.py,sha256=g9u51h62-aTosNElSnAc5_8OHxCmDQaGWmeIAwSUm40,16146
-kinfer/serialize/types.py,sha256=vWc2QqiMBodu0zUx0u69su6h42J3PTpS8ttPYHaEKlA,427
-kinfer/serialize/pytorch.py,sha256=1trcjjdywLh93hLnA-6WB1q558RM7gOopdnluOV6ivk,16169
-kinfer/serialize/utils.py,sha256=VzchOS4Wv6zhm1STmth3kGV83ExNtlE0Vio1K3kM_tE,5382
-kinfer/serialize/json.py,sha256=fpacSJoyILWrPJPqJyqGJ9HpgweLSpNYokCWb7rXqks,15081
-kinfer/serialize/base.py,sha256=rCtfvexmhYGHBXAMxXgltMLE4zkshhqDNhaWu009y2c,16390
-kinfer/serialize/schema.py,sha256=xNkY6WQ55sfmZ4QgZy4eg4hxayCEFnAiFxYvyl_ojMQ,4730
-kinfer/inference/__init__.py,sha256=fT52B78HnErtXSv2pvipsDVsufZlmnMzvR9Ny0UudoE,22
-kinfer/inference/python.py,sha256=RN7bk-41EJjeWaokqMRFXLqw8rpPfLJsrtHmhiIy2OM,3012
-kinfer/export/__init__.py,sha256=hxLu7FmRYn01ysoOQalrMa5K_qg4rLNf8OAuoemzd6I,23
-kinfer/export/pytorch.py,sha256=xz8DKT1ZBTYITLGh-ef01eEGvWOzQ-SMInRI8ol1RzM,4529
+kinfer/serialize/__init__.py,sha256=-_aNXvBDKh1LrLyF16Kkp3_Rmdd0EeQ3EUy_ZJJs4gk,1997
+kinfer/serialize/numpy.py,sha256=AovEjcWBVTpRk1bERQtTIP6Ac5W0ivx02lkmkbH8lTU,16146
+kinfer/serialize/types.py,sha256=op45q0NVrugS00fh0Zp7RNfETybxhF7daEp3dXhK-nE,427
+kinfer/serialize/pytorch.py,sha256=KO-YRrl1H7pVwx1xWdOvkUSr7Zy6YZVweq16dzcpguI,16169
+kinfer/serialize/utils.py,sha256=ptvNzyQTRe_ZI1Zc--WALVxHTbJRNaRuUE5P2dWREbI,5382
+kinfer/serialize/json.py,sha256=QywCQhYAlsA5AY-tfwzmI_unN0znqQyPo-hBgfVT-m0,15081
+kinfer/serialize/base.py,sha256=2nc0kmWyVqEIbSxpGqRuCgROUp0eciuRLz_-Dgny_YQ,16390
+kinfer/serialize/schema.py,sha256=wx5Y9vykRvMC5BtMkGtKxvAKvjW4-56ZU449NKfETTE,4730
+kinfer/inference/__init__.py,sha256=pn8nc2oy3UXdmD_Fm7BcrgE1Tw-LMrQHbHp7jIzw4d8,55
+kinfer/inference/python.py,sha256=CQanHMPLwQ_LOikaL78wX5daW-lhE0XVSfPJSYIVNBM,2177
+kinfer/inference/base.py,sha256=HHxYSfehICGDgVTfm9babZ1OKbjKyRuNUUDjx7cGmSU,1778
+kinfer/export/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kinfer/export/pytorch.py,sha256=6fBnyS6Q1xL8R5UtD3Zw4fU1sB-Ta6nmpJ8qg9UfryA,4529
 kinfer/rust_bindings/Cargo.toml,sha256=VZ6MY1QpqUQnDC1ygeSScaf8X-m1zXye6yaODV4RE5o,387
 kinfer/rust_bindings/pyproject.toml,sha256=jLcJuHCnQRh9HWR_R7a9qLHwj6LMBgnHyeKK_DruO1Y,135
 kinfer/rust_bindings/src/lib.rs,sha256=rIq7S32Xjv83GXUW1ZNAd5Ex1HwDAYvG0quYJr6VaAQ,405
 kinfer/rust_bindings/src/bin/stub_gen.rs,sha256=hhoVGnaSfazbSfj5a4x6mPicGPOgWQAfsDmiPej0B6Y,133
-kinfer-0.3.2.dist-info/RECORD,,
-kinfer-0.3.2.dist-info/LICENSE,sha256=Qw-Z0XTwS-diSW91e_jLeBPX9zZbAatOJTBLdPHPaC0,1069
-kinfer-0.3.2.dist-info/WHEEL,sha256=7Wd-yga4fjSiXpUH443rsPZpiZ4h8-uNrXJrYRW_e14,109
-kinfer-0.3.2.dist-info/top_level.txt,sha256=6mY_t3PYr3Dm0dpqMk80uSnArbvGfCFkxOh1QWtgDEo,7
-kinfer-0.3.2.dist-info/METADATA,sha256=RW4H6claL0CC4hanA2ep3Jp3v_ogINeg6YtXwtospdk,1884
+kinfer-0.3.3.dist-info/RECORD,,
+kinfer-0.3.3.dist-info/LICENSE,sha256=Qw-Z0XTwS-diSW91e_jLeBPX9zZbAatOJTBLdPHPaC0,1069
+kinfer-0.3.3.dist-info/WHEEL,sha256=7Wd-yga4fjSiXpUH443rsPZpiZ4h8-uNrXJrYRW_e14,109
+kinfer-0.3.3.dist-info/top_level.txt,sha256=6mY_t3PYr3Dm0dpqMk80uSnArbvGfCFkxOh1QWtgDEo,7
+kinfer-0.3.3.dist-info/METADATA,sha256=xmI3l8I2s-kqg-Zn_d37XGreHeb3twrEz0bArq1PMKQ,1884