wujihandpy 1.5.0rc1__cp38-cp38-win_amd64.whl

wujihandpy/__init__.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+
+# start delvewheel patch
+def _delvewheel_patch_1_10_0():
+    import ctypes
+    import os
+    import platform
+    import sys
+    libs_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, 'wujihandpy.libs'))
+    is_conda_cpython = platform.python_implementation() == 'CPython' and (hasattr(ctypes.pythonapi, 'Anaconda_GetVersion') or 'packaged by conda-forge' in sys.version)
+    if sys.version_info[:2] >= (3, 8) and not is_conda_cpython or sys.version_info[:2] >= (3, 10):
+        if os.path.isdir(libs_dir):
+            os.add_dll_directory(libs_dir)
+    else:
+        load_order_filepath = os.path.join(libs_dir, '.load-order-wujihandpy-1.5.0rc1')
+        if os.path.isfile(load_order_filepath):
+            import ctypes.wintypes
+            with open(os.path.join(libs_dir, '.load-order-wujihandpy-1.5.0rc1')) as file:
+                load_order = file.read().split()
+            kernel32 = ctypes.WinDLL('kernel32', use_last_error=True)
+            kernel32.LoadLibraryExW.restype = ctypes.wintypes.HMODULE
+            kernel32.LoadLibraryExW.argtypes = ctypes.wintypes.LPCWSTR, ctypes.wintypes.HANDLE, ctypes.wintypes.DWORD
+            for lib in load_order:
+                lib_path = os.path.join(os.path.join(libs_dir, lib))
+                if os.path.isfile(lib_path) and not kernel32.LoadLibraryExW(lib_path, None, 8):
+                    raise OSError('Error loading {}; {}'.format(lib, ctypes.FormatError(ctypes.get_last_error())))
+
+
+_delvewheel_patch_1_10_0()
+del _delvewheel_patch_1_10_0
+# end delvewheel patch
+
+from ._core import *
+from ._version import __version__
+
+__all__ = ["__version__", 'Hand', 'Finger', 'Joint', 'IController', 'filter']

wujihandpy/_core/__init__.pyi

@@ -0,0 +1,625 @@
+from __future__ import annotations
+import numpy
+import numpy.typing
+import typing
+from . import filter
+from . import logging
+__all__: list[str] = ['Finger', 'Hand', 'IController', 'Joint', 'filter', 'logging']
+class Finger:
+    def get_joint_actual_position(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    def get_joint_bus_voltage(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    def get_joint_current_limit(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    def get_joint_effort_limit(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    def get_joint_error_code(self) -> numpy.typing.NDArray[numpy.uint32]:
+        ...
+    def get_joint_firmware_date(self) -> numpy.typing.NDArray[numpy.uint32]:
+        ...
+    def get_joint_firmware_version(self) -> numpy.typing.NDArray[numpy.uint32]:
+        ...
+    def get_joint_lower_limit(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    def get_joint_temperature(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    def get_joint_upper_limit(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    def joint(self, index: typing.SupportsInt) -> Joint:
+        ...
+    def read_joint_actual_position(self, timeout: typing.SupportsFloat = 0.5) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    def read_joint_actual_position_async(self, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[numpy.typing.NDArray[numpy.float64]]:
+        ...
+    def read_joint_actual_position_unchecked(self, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def read_joint_bus_voltage(self, timeout: typing.SupportsFloat = 0.5) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    def read_joint_bus_voltage_async(self, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[numpy.typing.NDArray[numpy.float32]]:
+        ...
+    def read_joint_bus_voltage_unchecked(self, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def read_joint_current_limit(self, timeout: typing.SupportsFloat = 0.5) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    def read_joint_current_limit_async(self, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[numpy.typing.NDArray[numpy.float64]]:
+        ...
+    def read_joint_current_limit_unchecked(self, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def read_joint_effort_limit(self, timeout: typing.SupportsFloat = 0.5) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    def read_joint_effort_limit_async(self, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[numpy.typing.NDArray[numpy.float64]]:
+        ...
+    def read_joint_effort_limit_unchecked(self, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def read_joint_error_code(self, timeout: typing.SupportsFloat = 0.5) -> numpy.typing.NDArray[numpy.uint32]:
+        ...
+    def read_joint_error_code_async(self, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[numpy.typing.NDArray[numpy.uint32]]:
+        ...
+    def read_joint_error_code_unchecked(self, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def read_joint_firmware_date(self, timeout: typing.SupportsFloat = 0.5) -> numpy.typing.NDArray[numpy.uint32]:
+        ...
+    def read_joint_firmware_date_async(self, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[numpy.typing.NDArray[numpy.uint32]]:
+        ...
+    def read_joint_firmware_date_unchecked(self, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def read_joint_firmware_version(self, timeout: typing.SupportsFloat = 0.5) -> numpy.typing.NDArray[numpy.uint32]:
+        ...
+    def read_joint_firmware_version_async(self, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[numpy.typing.NDArray[numpy.uint32]]:
+        ...
+    def read_joint_firmware_version_unchecked(self, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def read_joint_lower_limit(self, timeout: typing.SupportsFloat = 0.5) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    def read_joint_lower_limit_async(self, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[numpy.typing.NDArray[numpy.float64]]:
+        ...
+    def read_joint_lower_limit_unchecked(self, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def read_joint_temperature(self, timeout: typing.SupportsFloat = 0.5) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    def read_joint_temperature_async(self, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[numpy.typing.NDArray[numpy.float32]]:
+        ...
+    def read_joint_temperature_unchecked(self, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def read_joint_upper_limit(self, timeout: typing.SupportsFloat = 0.5) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    def read_joint_upper_limit_async(self, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[numpy.typing.NDArray[numpy.float64]]:
+        ...
+    def read_joint_upper_limit_unchecked(self, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_control_mode(self, value: typing.SupportsInt, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_control_mode(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.uint16], timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_control_mode_async(self, value: typing.SupportsInt, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[None]:
+        ...
+    @typing.overload
+    def write_joint_control_mode_async(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.uint16], timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[None]:
+        ...
+    @typing.overload
+    def write_joint_control_mode_unchecked(self, value: typing.SupportsInt, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_control_mode_unchecked(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.uint16], timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_current_limit(self, value: typing.SupportsFloat, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_current_limit(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.float64], timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_current_limit_async(self, value: typing.SupportsFloat, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[None]:
+        ...
+    @typing.overload
+    def write_joint_current_limit_async(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.float64], timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[None]:
+        ...
+    @typing.overload
+    def write_joint_current_limit_unchecked(self, value: typing.SupportsFloat, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_current_limit_unchecked(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.float64], timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_effort_limit(self, value: typing.SupportsFloat, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_effort_limit(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.float64], timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_effort_limit_async(self, value: typing.SupportsFloat, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[None]:
+        ...
+    @typing.overload
+    def write_joint_effort_limit_async(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.float64], timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[None]:
+        ...
+    @typing.overload
+    def write_joint_effort_limit_unchecked(self, value: typing.SupportsFloat, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_effort_limit_unchecked(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.float64], timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_enabled(self, value: bool, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_enabled(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.bool_], timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_enabled_async(self, value: bool, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[None]:
+        ...
+    @typing.overload
+    def write_joint_enabled_async(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.bool_], timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[None]:
+        ...
+    @typing.overload
+    def write_joint_enabled_unchecked(self, value: bool, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_enabled_unchecked(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.bool_], timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_reset_error(self, value: typing.SupportsInt, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_reset_error(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.uint16], timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_reset_error_async(self, value: typing.SupportsInt, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[None]:
+        ...
+    @typing.overload
+    def write_joint_reset_error_async(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.uint16], timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[None]:
+        ...
+    @typing.overload
+    def write_joint_reset_error_unchecked(self, value: typing.SupportsInt, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_reset_error_unchecked(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.uint16], timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_sin_level(self, value: typing.SupportsInt, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_sin_level(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.uint16], timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_sin_level_async(self, value: typing.SupportsInt, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[None]:
+        ...
+    @typing.overload
+    def write_joint_sin_level_async(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.uint16], timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[None]:
+        ...
+    @typing.overload
+    def write_joint_sin_level_unchecked(self, value: typing.SupportsInt, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_sin_level_unchecked(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.uint16], timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_target_position(self, value: typing.SupportsFloat, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_target_position(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.float64], timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_target_position_async(self, value: typing.SupportsFloat, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[None]:
+        ...
+    @typing.overload
+    def write_joint_target_position_async(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.float64], timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[None]:
+        ...
+    @typing.overload
+    def write_joint_target_position_unchecked(self, value: typing.SupportsFloat, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_target_position_unchecked(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.float64], timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+class Hand:
+    def __init__(self, serial_number: str | None = None, usb_pid: typing.SupportsInt = -1, usb_vid: typing.SupportsInt = 1155, mask: typing.Annotated[numpy.typing.ArrayLike, numpy.bool_] | None = None) -> None:
+        ...
+    def finger(self, index: typing.SupportsInt) -> Finger:
+        ...
+    def get_firmware_date(self) -> numpy.uint32:
+        ...
+    def get_firmware_version(self) -> numpy.uint32:
+        ...
+    def get_handedness(self) -> numpy.uint8:
+        ...
+    def get_input_voltage(self) -> numpy.float32:
+        ...
+    def get_joint_actual_position(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    def get_joint_bus_voltage(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    def get_joint_current_limit(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    def get_joint_effort_limit(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    def get_joint_error_code(self) -> numpy.typing.NDArray[numpy.uint32]:
+        ...
+    def get_joint_firmware_date(self) -> numpy.typing.NDArray[numpy.uint32]:
+        ...
+    def get_joint_firmware_version(self) -> numpy.typing.NDArray[numpy.uint32]:
+        ...
+    def get_joint_lower_limit(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    def get_joint_temperature(self) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    def get_joint_upper_limit(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    def get_product_sn(self) -> str:
+        """
+        Get device product serial number
+        """
+    def get_system_time(self) -> numpy.uint32:
+        ...
+    def get_temperature(self) -> numpy.float32:
+        ...
+    def raw_sdo_read(self, finger_id: typing.SupportsInt, joint_id: typing.SupportsInt, index: typing.SupportsInt, sub_index: typing.SupportsInt, timeout: typing.SupportsFloat = 0.5) -> bytes:
+        ...
+    def raw_sdo_write(self, finger_id: typing.SupportsInt, joint_id: typing.SupportsInt, index: typing.SupportsInt, sub_index: typing.SupportsInt, data: bytes, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def read_firmware_date(self, timeout: typing.SupportsFloat = 0.5) -> numpy.uint32:
+        ...
+    def read_firmware_date_async(self, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[numpy.uint32]:
+        ...
+    def read_firmware_date_unchecked(self, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def read_firmware_version(self, timeout: typing.SupportsFloat = 0.5) -> numpy.uint32:
+        ...
+    def read_firmware_version_async(self, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[numpy.uint32]:
+        ...
+    def read_firmware_version_unchecked(self, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def read_handedness(self, timeout: typing.SupportsFloat = 0.5) -> numpy.uint8:
+        ...
+    def read_handedness_async(self, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[numpy.uint8]:
+        ...
+    def read_handedness_unchecked(self, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def read_input_voltage(self, timeout: typing.SupportsFloat = 0.5) -> numpy.float32:
+        ...
+    def read_input_voltage_async(self, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[numpy.float32]:
+        ...
+    def read_input_voltage_unchecked(self, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def read_joint_actual_position(self, timeout: typing.SupportsFloat = 0.5) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    def read_joint_actual_position_async(self, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[numpy.typing.NDArray[numpy.float64]]:
+        ...
+    def read_joint_actual_position_unchecked(self, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def read_joint_bus_voltage(self, timeout: typing.SupportsFloat = 0.5) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    def read_joint_bus_voltage_async(self, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[numpy.typing.NDArray[numpy.float32]]:
+        ...
+    def read_joint_bus_voltage_unchecked(self, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def read_joint_current_limit(self, timeout: typing.SupportsFloat = 0.5) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    def read_joint_current_limit_async(self, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[numpy.typing.NDArray[numpy.float64]]:
+        ...
+    def read_joint_current_limit_unchecked(self, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def read_joint_effort_limit(self, timeout: typing.SupportsFloat = 0.5) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    def read_joint_effort_limit_async(self, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[numpy.typing.NDArray[numpy.float64]]:
+        ...
+    def read_joint_effort_limit_unchecked(self, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def read_joint_error_code(self, timeout: typing.SupportsFloat = 0.5) -> numpy.typing.NDArray[numpy.uint32]:
+        ...
+    def read_joint_error_code_async(self, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[numpy.typing.NDArray[numpy.uint32]]:
+        ...
+    def read_joint_error_code_unchecked(self, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def read_joint_firmware_date(self, timeout: typing.SupportsFloat = 0.5) -> numpy.typing.NDArray[numpy.uint32]:
+        ...
+    def read_joint_firmware_date_async(self, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[numpy.typing.NDArray[numpy.uint32]]:
+        ...
+    def read_joint_firmware_date_unchecked(self, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def read_joint_firmware_version(self, timeout: typing.SupportsFloat = 0.5) -> numpy.typing.NDArray[numpy.uint32]:
+        ...
+    def read_joint_firmware_version_async(self, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[numpy.typing.NDArray[numpy.uint32]]:
+        ...
+    def read_joint_firmware_version_unchecked(self, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def read_joint_lower_limit(self, timeout: typing.SupportsFloat = 0.5) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    def read_joint_lower_limit_async(self, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[numpy.typing.NDArray[numpy.float64]]:
+        ...
+    def read_joint_lower_limit_unchecked(self, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def read_joint_temperature(self, timeout: typing.SupportsFloat = 0.5) -> numpy.typing.NDArray[numpy.float32]:
+        ...
+    def read_joint_temperature_async(self, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[numpy.typing.NDArray[numpy.float32]]:
+        ...
+    def read_joint_temperature_unchecked(self, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def read_joint_upper_limit(self, timeout: typing.SupportsFloat = 0.5) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    def read_joint_upper_limit_async(self, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[numpy.typing.NDArray[numpy.float64]]:
+        ...
+    def read_joint_upper_limit_unchecked(self, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def read_system_time(self, timeout: typing.SupportsFloat = 0.5) -> numpy.uint32:
+        ...
+    def read_system_time_async(self, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[numpy.uint32]:
+        ...
+    def read_system_time_unchecked(self, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def read_temperature(self, timeout: typing.SupportsFloat = 0.5) -> numpy.float32:
+        ...
+    def read_temperature_async(self, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[numpy.float32]:
+        ...
+    def read_temperature_unchecked(self, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def realtime_controller(self, enable_upstream: bool, filter: filter.IFilter) -> IController:
+        ...
+    def start_latency_test(self) -> None:
+        ...
+    def stop_latency_test(self) -> None:
+        ...
+    @typing.overload
+    def write_joint_control_mode(self, value: typing.SupportsInt, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_control_mode(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.uint16], timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_control_mode_async(self, value: typing.SupportsInt, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[None]:
+        ...
+    @typing.overload
+    def write_joint_control_mode_async(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.uint16], timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[None]:
+        ...
+    @typing.overload
+    def write_joint_control_mode_unchecked(self, value: typing.SupportsInt, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_control_mode_unchecked(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.uint16], timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_current_limit(self, value: typing.SupportsFloat, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_current_limit(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.float64], timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_current_limit_async(self, value: typing.SupportsFloat, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[None]:
+        ...
+    @typing.overload
+    def write_joint_current_limit_async(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.float64], timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[None]:
+        ...
+    @typing.overload
+    def write_joint_current_limit_unchecked(self, value: typing.SupportsFloat, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_current_limit_unchecked(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.float64], timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_effort_limit(self, value: typing.SupportsFloat, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_effort_limit(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.float64], timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_effort_limit_async(self, value: typing.SupportsFloat, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[None]:
+        ...
+    @typing.overload
+    def write_joint_effort_limit_async(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.float64], timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[None]:
+        ...
+    @typing.overload
+    def write_joint_effort_limit_unchecked(self, value: typing.SupportsFloat, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_effort_limit_unchecked(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.float64], timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_enabled(self, value: bool, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_enabled(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.bool_], timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_enabled_async(self, value: bool, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[None]:
+        ...
+    @typing.overload
+    def write_joint_enabled_async(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.bool_], timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[None]:
+        ...
+    @typing.overload
+    def write_joint_enabled_unchecked(self, value: bool, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_enabled_unchecked(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.bool_], timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_reset_error(self, value: typing.SupportsInt, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_reset_error(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.uint16], timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_reset_error_async(self, value: typing.SupportsInt, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[None]:
+        ...
+    @typing.overload
+    def write_joint_reset_error_async(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.uint16], timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[None]:
+        ...
+    @typing.overload
+    def write_joint_reset_error_unchecked(self, value: typing.SupportsInt, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_reset_error_unchecked(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.uint16], timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_sin_level(self, value: typing.SupportsInt, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_sin_level(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.uint16], timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_sin_level_async(self, value: typing.SupportsInt, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[None]:
+        ...
+    @typing.overload
+    def write_joint_sin_level_async(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.uint16], timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[None]:
+        ...
+    @typing.overload
+    def write_joint_sin_level_unchecked(self, value: typing.SupportsInt, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_sin_level_unchecked(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.uint16], timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_target_position(self, value: typing.SupportsFloat, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_target_position(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.float64], timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_target_position_async(self, value: typing.SupportsFloat, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[None]:
+        ...
+    @typing.overload
+    def write_joint_target_position_async(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.float64], timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[None]:
+        ...
+    @typing.overload
+    def write_joint_target_position_unchecked(self, value: typing.SupportsFloat, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    @typing.overload
+    def write_joint_target_position_unchecked(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.float64], timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+class IController:
+    def __enter__(self) -> IController:
+        ...
+    def __exit__(self, arg0: typing.Any, arg1: typing.Any, arg2: typing.Any) -> None:
+        ...
+    def close(self) -> None:
+        ...
+    def get_joint_actual_effort(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    def get_joint_actual_position(self) -> numpy.typing.NDArray[numpy.float64]:
+        ...
+    def set_joint_target_position(self, value_array: typing.Annotated[numpy.typing.ArrayLike, numpy.float64]) -> None:
+        ...
+class Joint:
+    def get_joint_actual_position(self) -> numpy.float64:
+        ...
+    def get_joint_bus_voltage(self) -> numpy.float32:
+        ...
+    def get_joint_current_limit(self) -> numpy.float64:
+        ...
+    def get_joint_effort_limit(self) -> numpy.float64:
+        ...
+    def get_joint_error_code(self) -> numpy.uint32:
+        ...
+    def get_joint_firmware_date(self) -> numpy.uint32:
+        ...
+    def get_joint_firmware_version(self) -> numpy.uint32:
+        ...
+    def get_joint_lower_limit(self) -> numpy.float64:
+        ...
+    def get_joint_temperature(self) -> numpy.float32:
+        ...
+    def get_joint_upper_limit(self) -> numpy.float64:
+        ...
+    def read_joint_actual_position(self, timeout: typing.SupportsFloat = 0.5) -> numpy.float64:
+        ...
+    def read_joint_actual_position_async(self, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[numpy.float64]:
+        ...
+    def read_joint_actual_position_unchecked(self, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def read_joint_bus_voltage(self, timeout: typing.SupportsFloat = 0.5) -> numpy.float32:
+        ...
+    def read_joint_bus_voltage_async(self, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[numpy.float32]:
+        ...
+    def read_joint_bus_voltage_unchecked(self, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def read_joint_current_limit(self, timeout: typing.SupportsFloat = 0.5) -> numpy.float64:
+        ...
+    def read_joint_current_limit_async(self, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[numpy.float64]:
+        ...
+    def read_joint_current_limit_unchecked(self, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def read_joint_effort_limit(self, timeout: typing.SupportsFloat = 0.5) -> numpy.float64:
+        ...
+    def read_joint_effort_limit_async(self, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[numpy.float64]:
+        ...
+    def read_joint_effort_limit_unchecked(self, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def read_joint_error_code(self, timeout: typing.SupportsFloat = 0.5) -> numpy.uint32:
+        ...
+    def read_joint_error_code_async(self, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[numpy.uint32]:
+        ...
+    def read_joint_error_code_unchecked(self, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def read_joint_firmware_date(self, timeout: typing.SupportsFloat = 0.5) -> numpy.uint32:
+        ...
+    def read_joint_firmware_date_async(self, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[numpy.uint32]:
+        ...
+    def read_joint_firmware_date_unchecked(self, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def read_joint_firmware_version(self, timeout: typing.SupportsFloat = 0.5) -> numpy.uint32:
+        ...
+    def read_joint_firmware_version_async(self, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[numpy.uint32]:
+        ...
+    def read_joint_firmware_version_unchecked(self, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def read_joint_lower_limit(self, timeout: typing.SupportsFloat = 0.5) -> numpy.float64:
+        ...
+    def read_joint_lower_limit_async(self, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[numpy.float64]:
+        ...
+    def read_joint_lower_limit_unchecked(self, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def read_joint_temperature(self, timeout: typing.SupportsFloat = 0.5) -> numpy.float32:
+        ...
+    def read_joint_temperature_async(self, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[numpy.float32]:
+        ...
+    def read_joint_temperature_unchecked(self, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def read_joint_upper_limit(self, timeout: typing.SupportsFloat = 0.5) -> numpy.float64:
+        ...
+    def read_joint_upper_limit_async(self, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[numpy.float64]:
+        ...
+    def read_joint_upper_limit_unchecked(self, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def write_joint_control_mode(self, value: typing.SupportsInt, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def write_joint_control_mode_async(self, value: typing.SupportsInt, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[None]:
+        ...
+    def write_joint_control_mode_unchecked(self, value: typing.SupportsInt, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def write_joint_current_limit(self, value: typing.SupportsFloat, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def write_joint_current_limit_async(self, value: typing.SupportsFloat, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[None]:
+        ...
+    def write_joint_current_limit_unchecked(self, value: typing.SupportsFloat, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def write_joint_effort_limit(self, value: typing.SupportsFloat, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def write_joint_effort_limit_async(self, value: typing.SupportsFloat, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[None]:
+        ...
+    def write_joint_effort_limit_unchecked(self, value: typing.SupportsFloat, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def write_joint_enabled(self, value: bool, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def write_joint_enabled_async(self, value: bool, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[None]:
+        ...
+    def write_joint_enabled_unchecked(self, value: bool, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def write_joint_reset_error(self, value: typing.SupportsInt, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def write_joint_reset_error_async(self, value: typing.SupportsInt, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[None]:
+        ...
+    def write_joint_reset_error_unchecked(self, value: typing.SupportsInt, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def write_joint_sin_level(self, value: typing.SupportsInt, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def write_joint_sin_level_async(self, value: typing.SupportsInt, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[None]:
+        ...
+    def write_joint_sin_level_unchecked(self, value: typing.SupportsInt, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def write_joint_target_position(self, value: typing.SupportsFloat, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...
+    def write_joint_target_position_async(self, value: typing.SupportsFloat, timeout: typing.SupportsFloat = 0.5) -> typing.Awaitable[None]:
+        ...
+    def write_joint_target_position_unchecked(self, value: typing.SupportsFloat, timeout: typing.SupportsFloat = 0.5) -> None:
+        ...

wujihandpy/_core/filter.pyi

@@ -0,0 +1,8 @@
+from __future__ import annotations
+import typing
+__all__: list[str] = ['IFilter', 'LowPass']
+class IFilter:
+    pass
+class LowPass(IFilter):
+    def __init__(self, cutoff_freq: typing.SupportsFloat = 10.0) -> None:
+        ...

wujihandpy/_core/logging.pyi

@@ -0,0 +1,65 @@
+from __future__ import annotations
+import typing
+__all__: list[str] = ['Level', 'flush', 'set_log_level', 'set_log_path', 'set_log_to_console', 'set_log_to_file']
+class Level:
+    """
+    Members:
+    
+      Trace
+    
+      Debug
+    
+      Info
+    
+      Warn
+    
+      Error
+    
+      Critical
+    
+      Off
+    """
+    Critical: typing.ClassVar[Level]  # value = <Level.Critical: 5>
+    Debug: typing.ClassVar[Level]  # value = <Level.Debug: 1>
+    Error: typing.ClassVar[Level]  # value = <Level.Error: 4>
+    Info: typing.ClassVar[Level]  # value = <Level.Info: 2>
+    Off: typing.ClassVar[Level]  # value = <Level.Off: 6>
+    Trace: typing.ClassVar[Level]  # value = <Level.Trace: 0>
+    Warn: typing.ClassVar[Level]  # value = <Level.Warn: 3>
+    __members__: typing.ClassVar[dict[str, Level]]  # value = {'Trace': <Level.Trace: 0>, 'Debug': <Level.Debug: 1>, 'Info': <Level.Info: 2>, 'Warn': <Level.Warn: 3>, 'Error': <Level.Error: 4>, 'Critical': <Level.Critical: 5>, 'Off': <Level.Off: 6>}
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    def __init__(self, value: typing.SupportsInt) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __repr__(self) -> str:
+        ...
+    def __setstate__(self, state: typing.SupportsInt) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+def flush() -> None:
+    ...
+def set_log_level(value: Level) -> None:
+    ...
+def set_log_path(value: str) -> None:
+    ...
+def set_log_to_console(value: bool) -> None:
+    ...
+def set_log_to_file(value: bool) -> None:
+    ...

wujihandpy/_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '1.5.0rc1'
+__version_tuple__ = version_tuple = (1, 5, 0, 'rc1')
+
+__commit_id__ = commit_id = 'ge0283a468'

wujihandpy-1.5.0rc1.dist-info/DELVEWHEEL

@@ -0,0 +1,2 @@
+Version: 1.10.0
+Arguments: ['C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-hhrrn7qg\\cp38-win_amd64\\build\\venv\\Scripts\\delvewheel', 'repair', '--add-path', 'C:/vcpkg/installed/x64-windows/bin', '-w', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-hhrrn7qg\\cp38-win_amd64\\repaired_wheel', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-hhrrn7qg\\cp38-win_amd64\\built_wheel\\wujihandpy-1.5.0rc1-cp38-cp38-win_amd64.whl']

wujihandpy-1.5.0rc1.dist-info/METADATA

@@ -0,0 +1,313 @@
+Metadata-Version: 2.2
+Name: wujihandpy
+Version: 1.5.0rc1
+Summary: Python bindings for WujiHandCpp
+Author-Email: Zihan Qin <zihanqin2048@gmail.com>
+Maintainer-Email: Wuji Technology <support@pan-motor.com>
+License: MIT License
+         
+         Copyright (c) 2025 Wuji Technology
+         
+         Permission is hereby granted, free of charge, to any person obtaining a copy
+         of this software and associated documentation files (the "Software"), to deal
+         in the Software without restriction, including without limitation the rights
+         to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+         copies of the Software, and to permit persons to whom the Software is
+         furnished to do so, subject to the following conditions:
+         
+         The above copyright notice and this permission notice shall be included in all
+         copies or substantial portions of the Software.
+         
+         THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+         IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+         FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+         AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+         LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+         OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+         SOFTWARE.
+         
+Project-URL: homepage, https://github.com/wuji-technology/wujihandpy
+Project-URL: repository, https://github.com/wuji-technology/wujihandpy
+Project-URL: Bug Tracker, https://github.com/wuji-technology/wujihandpy/issues
+Requires-Python: >=3.8
+Requires-Dist: numpy
+Description-Content-Type: text/markdown
+
+# wujihandpy
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE) [![Release](https://img.shields.io/github/v/release/wuji-technology/wujihandpy)](https://github.com/wuji-technology/wujihandpy/releases)
+
+Wuji Hand SDK: C++ core with Python bindings, for controlling and communicating with Wuji Hand. WujihandPy is the Python binding of [WujihandCpp](wujihandcpp/README.md), providing an easy-to-use Python API for Wujihand dexterous-hand devices. Supports synchronous, asynchronous, unchecked operations and real-time control.
+
+## Table of Contents
+
+- [Repository Structure](#repository-structure)
+- [Usage](#usage)
+  - [Prerequisites](#prerequisites)
+  - [Installation](#installation)
+  - [Running](#running)
+- [Troubleshooting](#troubleshooting)
+- [Appendix](#appendix)
+- [Contact](#contact)
+
+## Repository Structure
+
+```text
+├── src/
+│   ├── wujihandpy/
+│   │   ├── __init__.py
+│   │   └── _core/
+│   ├── main.cpp
+│   └── *.hpp
+├── example/
+│   ├── 1.read.py
+│   ├── 2.write.py
+│   ├── 3.realtime.py
+│   └── 4.async.py
+├── wujihandcpp/
+│   ├── include/
+│   │   └── wujihandcpp/
+│   ├── src/
+│   └── tests/
+├── .github/
+│   └── workflows/
+├── pyproject.toml
+├── CMakeLists.txt
+└── README.md
+```
+
+### Directory Description
+
+| Directory | Description |
+|-----------|-------------|
+| `src/` | Python binding source code and C++ headers |
+| `src/wujihandpy/` | Python package with type stubs |
+| `example/` | Usage examples for read, write, realtime, and async operations |
+| `wujihandcpp/` | Underlying C++ SDK implementation |
+| `wujihandcpp/include/` | C++ header files |
+| `wujihandcpp/src/` | C++ source files |
+| `.github/workflows/` | CI/CD automation |
+
+## Usage
+
+### Prerequisites
+
+**Supported CPU Architectures:**
+
+- x86_64
+- ARM64
+
+**Minimum System Requirements (Linux):**
+
+- glibc 2.28+ (Debian 10+, Ubuntu 18.10+, Fedora 29+, CentOS/RHEL 8+)
+- Python 3.8-3.14
+
+**Minimum System Requirements (Windows):**
+
+WujihandPy does not support Windows yet; we will work to add support as soon as possible.
+
+### Installation
+
+WujihandPy supports one-line installation via pip:
+
+```bash
+pip install wujihandpy
+```
+
+For Linux users, you need to configure udev rules to allow non-root users to access USB devices:
+
+```bash
+echo 'SUBSYSTEM=="usb", ATTR{idVendor}=="0483", MODE="0666"' | \
+sudo tee /etc/udev/rules.d/95-wujihand.rules && \
+sudo udevadm control --reload-rules && \
+sudo udevadm trigger
+```
+
+### Running
+
+#### Import Modules
+
+```python
+import wujihandpy
+import numpy as np
+```
+
+#### Connect to the Hand
+
+```python
+hand = wujihandpy.Hand()
+```
+
+#### Read Data
+
+```python
+def read_<dataname>(self) -> datatype
+def read_<dataname>(self) -> np.ndarray[datatype]  # For bulk-read
+```
+
+All available data can be found in the [API Reference](https://docs.wuji.tech/docs/en/wuji-hand/latest/sdk-user-guide/api-reference/).
+
+For example, read the hand's powered-on running time (us):
+
+```python
+time = hand.read_system_time()
+```
+
+Besides hand-level data, each joint also has its own data; joint-level data names all use `joint` as the prefix.
+
+For example, read the current position of joint 0 on finger 1 (index finger):
+
+```python
+position = hand.finger(1).joint(0).read_joint_actual_position()
+```
+
+Joint angles are of type `np.float64` in radians. The zero point and positive direction follow the definitions in the [URDF files](https://github.com/wuji-technology/wuji-hand-description).
+
+Reading multiple data items with a single command is called **Bulk-Read**.
+
+For example, the following reads the current position of all (20) joints on the hand:
+
+```python
+positions = hand.read_joint_actual_position()
+```
+
+For bulk reads, the function returns an `np.ndarray[np.float64]` containing all values:
+
+```python
+>>> print(positions)
+[[ 0.975  0.523  0.271 -0.45 ]
+ [ 0.382  0.241 -0.003 -0.275]
+ [-0.299  0.329  0.067 -0.286]
+ [-0.122  0.228  0.315 -0.178]
+ [ 0.205  0.087  0.288 -0.149]]
+```
+
+`read` blocks until the operation completes. When the function returns, the read is guaranteed to have succeeded.
+
+#### Write Data
+
+The write API is similar, but takes an extra parameter for the target value:
+
+```python
+def write_<dataname>(self, datatype)
+def write_<dataname>(self, np.ndarray[datatype])  # For bulk-write
+```
+
+For example, write a target position to a single joint:
+
+```python
+hand.finger(1).joint(0).write_joint_target_position(0.8)
+```
+
+Valid angle limits for each joint can be obtained via:
+
+```python
+upper = <Hand / Finger / Joint>.read_joint_upper_limit()
+lower = <Hand / Finger / Joint>.read_joint_lower_limit()
+```
+
+If the written angle is outside the valid range, it will be automatically clamped to the upper/lower limit.
+
+**Bulk-Write** is also supported. For example, write the same target position to all joints of finger 1 (index finger):
+
+```python
+hand.finger(1).write_joint_target_position(0.8)
+```
+
+If each joint has a different target, pass an `np.ndarray` containing the target values for each joint:
+
+```python
+hand.finger(1).write_joint_target_position(
+    np.array(
+        #   J1    J2    J3    J4
+        [0.8,  0.0,  0.8,  0.8],
+        dtype=np.float64,
+    )
+)
+```
+
+`write` blocks until the operation completes. When the function returns, the write is guaranteed to have succeeded.
+
+#### Realtime Control
+
+By default, both reads and writes use a buffer pool: data is accumulated for a while before being transmitted, so the maximum read/write frequency cannot exceed 100 Hz.
+
+For scenarios that require smooth joint position control, use [Realtime Control](https://docs.wuji.tech/docs/en/wuji-hand/latest/sdk-user-guide/tutorial/#4-real-time-control).
+
+#### Asynchronous Read/Write
+
+All read/write functions have asynchronous versions, with an `_async` suffix.
+
+```python
+async def read_<dataname>_async(self) -> datatype
+async def read_<dataname>_async(self) -> np.ndarray[datatype]  # For bulk-read
+async def write_<dataname>_async(self, datatype)
+async def write_<dataname>_async(self, np.ndarray[datatype])   # For bulk-write
+```
+
+Asynchronous APIs must be awaited. The thread/event loop is not blocked while waiting, and when the call returns the read/write is guaranteed to have succeeded.
+
+#### Unchecked Read/Write
+
+If you do not care whether a read/write succeeds, you can use the Unchecked versions, with an `_unchecked` suffix.
+
+```python
+def read_<dataname>_unchecked(self) -> None
+def write_<dataname>_unchecked(self, datatype)
+def write_<dataname>_unchecked(self, np.ndarray[datatype])  # For bulk-write
+```
+
+Unchecked functions always return immediately without blocking, and are typically used in latency-sensitive scenarios.
+
+#### Get Cached Values
+
+If you want to retrieve results from previous reads/writes, use the `get` family of functions:
+
+```python
+def get_<dataname>(self) -> datatype
+def get_<dataname>(self) -> np.ndarray[datatype]  # For bulk-read
+```
+
+`get` functions also never block. They always return the most recently read value, regardless of whether it came from `read`, `async-read`, or `read-unchecked`.
+
+If the data has never been requested, or the request has not succeeded yet, the return value of `get` is undefined (usually 0).
+
+#### Examples
+
+All example code is located in the [example](example) directory.
+
+## Troubleshooting
+
+1. **Could not find a version that satisfies the requirement**
+
+   If you see this error during installation, upgrade pip first:
+
+   ```bash
+   python3 -m pip install --upgrade pip
+   ```
+
+   Then retry with the upgraded pip:
+
+   ```bash
+   python3 -m pip install wujihandpy
+   ```
+
+## Appendix
+
+### Performance and Optimization
+
+While ensuring usability, WujihandPy has been optimized for performance and efficiency as much as possible.
+
+We recommend prioritizing bulk read/write to maximize performance.
+
+For scenarios that require smooth joint position control, be sure to use `realtime_controller`.
+
+### References
+
+- **Documentation**: [Quick Start](https://docs.wuji.tech/docs/en/wuji-hand/latest/sdk-user-guide/introduction/)
+- **API Reference**: [API Reference](https://docs.wuji.tech/docs/en/wuji-hand/latest/sdk-user-guide/api-reference/)
+- **URDF Files**: [wuji-hand-description](https://github.com/wuji-technology/wuji-hand-description)
+
+## Contact
+
+For any questions, please contact [support@wuji.tech](mailto:support@wuji.tech).

wujihandpy-1.5.0rc1.dist-info/RECORD

@@ -0,0 +1,17 @@
+wujihandpy/_core.cp38-win_amd64.pyd,sha256=8rS8MXuqA_IDdtTMV0IqYkp53SZ2bCQnUrZ5boNLIMo,1126912
+wujihandpy/_version.py,sha256=GTjge0Zf2O0GeQfFhC9V5TZKyEmu3ViACzROoUcrmy8,756
+wujihandpy/__init__.py,sha256=si_A12gcebXlXDQxnOHhHLct0nRd475GisihfIky1E4,1755
+wujihandpy/_core/filter.pyi,sha256=bhf3_lTgyf0BeVhp4TqUw0nJgoE0f-kyzw7vJrt67nI,235
+wujihandpy/_core/logging.pyi,sha256=I35XdCZfBS-M7eslyzX3zUEBSKa_HIOspRXyZYwbvu0,1933
+wujihandpy/_core/__init__.pyi,sha256=RbK_3F3J0qiPVgWwZ4OPKd8mPh0Du0eLNdvMYnq5Ra4,35934
+wujihandpy-1.5.0rc1.dist-info/DELVEWHEEL,sha256=HDWQXEK6h0ew7ovSrGFeyZ3SYz6AaZXweJur0mw-hyo,453
+wujihandpy-1.5.0rc1.dist-info/METADATA,sha256=9T59DhviH_DFfMGKYXRWB2Vr3nq1Li3v5ncp6DOv59E,10231
+wujihandpy-1.5.0rc1.dist-info/RECORD,,
+wujihandpy-1.5.0rc1.dist-info/WHEEL,sha256=yXMtVL9U8RkqJEJfb-z5X2s1_G1r2eGG-REYk3wgjZ0,104
+wujihandpy-1.5.0rc1.dist-info/licenses/LICENSE,sha256=aWRV7TIHNfIAV58Abtu5ubNfqOHUeANdqg_QXb99nto,1093
+wujihandpy.libs/.load-order-wujihandpy-1.5.0rc1,sha256=PDMbbuLU-0mUQ3VqXxdjGcHuhFeXDyIBP4MoLXNTtY0,252
+wujihandpy.libs/libusb-1.0-b8a6a96692604f71b1f8833eda7ca0e9.dll,sha256=l_ZU0jNGBfirQunYUkHFqOt27bUvHAJ9IHPS0hV5wsw,158208
+wujihandpy.libs/msvcp140-6b4456f8f4093623a2447d077cc6f028.dll,sha256=ahXtplqbjEwqs-INszrdCI9SGEf3k4TlcFxlohyXXl8,554496
+wujihandpy.libs/msvcp140_1-096c6fd9306df44b85fc6abdfeecb116.dll,sha256=_zWuTtz8emGvB4nYikaWEMwvvIaiuxCeyXCo1ADHT5Y,15360
+wujihandpy.libs/msvcp140_atomic_wait-73c4359c1efe6b0ca91b3bf40aaf2693.dll,sha256=qNNSRnoTTtwdwI64BlqOlPhoMKFPukI9A1iE6y90USM,29696
+wujihandpy.libs/vcruntime140_1-db3b30bbef3102c0df3cebf52ebc5830.dll,sha256=apm8ASjgx9bLv2FfzCaQlWXhfUyjRRuX-Jh_nGrLxsg,49776

wujihandpy-1.5.0rc1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: scikit-build-core 0.11.6
+Root-Is-Purelib: false
+Tag: cp38-cp38-win_amd64
+

wujihandpy-1.5.0rc1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Wuji Technology
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

wujihandpy.libs/.load-order-wujihandpy-1.5.0rc1

@@ -0,0 +1,5 @@
+libusb-1.0-b8a6a96692604f71b1f8833eda7ca0e9.dll
+msvcp140_atomic_wait-73c4359c1efe6b0ca91b3bf40aaf2693.dll
+msvcp140-6b4456f8f4093623a2447d077cc6f028.dll
+vcruntime140_1-db3b30bbef3102c0df3cebf52ebc5830.dll
+msvcp140_1-096c6fd9306df44b85fc6abdfeecb116.dll