kuavo-humanoid-sdk 0.1.0__py3-none-any.whl

kuavo_humanoid_sdk/kuavo/robot_state.py

@@ -0,0 +1,258 @@
+#!/usr/bin/env python3
+# coding: utf-8
+import time
+from typing import Tuple
+from kuavo_humanoid_sdk.interfaces.data_types import (
+    KuavoImuData, KuavoJointData, KuavoOdometry, KuavoArmCtrlMode,EndEffectorState)
+from kuavo_humanoid_sdk.kuavo.core.ros.state import KuavoRobotStateCore
+
+class KuavoRobotState:
+    def __init__(self, robot_type: str = "kuavo"):
+        self._rs_core = KuavoRobotStateCore()
+
+    @property
+    def imu_data(self) -> KuavoImuData:
+        """Get Robot IMU Data.
+
+        Gets the current IMU sensor data from the robot, including gyroscope, accelerometer,
+        free acceleration and orientation quaternion measurements.
+
+        Returns:
+            :class:`KuavoImuData`: IMU data containing:
+                * gyro (:obj:`tuple` of :obj:`float`): Gyroscope measurements (x, y, z) in rad/s
+                * acc (:obj:`tuple` of :obj:`float`): Accelerometer measurements (x, y, z) in m/s^2
+                * free_acc (:obj:`tuple` of :obj:`float`): Free acceleration (x, y, z) in m/s^2
+                * quat (:obj:`tuple` of :obj:`float`): Orientation quaternion (x, y, z, w)
+        """
+        return self._rs_core.imu_data
+    
+    @property
+    def joint_state(self) -> KuavoJointData:
+        """Get Robot Joint Data.
+
+        Get Robot Joint Data, including joint positions, velocities, torques and accelerations.
+
+        The data includes:
+            - Joint positions (angles) in radians
+            - Joint velocities in radians/second 
+            - Joint torques/efforts in Newton-meters, A
+            - Joint acceleration
+
+        Returns:
+            KuavoJointData: A dictionary containing joint state data with the following keys:
+                position (list[float]): Joint positions, length = joint_dof(28)
+                velocity (list[float]): Joint velocities, length = joint_dof(28)  
+                torque (list[float]): Joint torques, length = joint_dof(28)
+                acceleration (list[float]): Joint accelerations, length = joint_dof(28)
+        """
+        return self._rs_core.joint_data
+    
+    @property
+    def com_height(self)->float:
+        """Get the height of the robot's center of mass.
+
+        Returns:
+            float: The height of the robot's center of mass in meters.
+        """
+        return self._rs_core.com_height
+    
+    @property
+    def odometry(self) -> KuavoOdometry:
+        """Get Robot Odometry Data.
+
+        Gets the current odometry data from the robot, including position, orientation,
+        linear velocity and angular velocity measurements.
+
+        Returns:
+            KuavoOdometry: A dictionary containing odometry data with the following keys:
+                position (tuple): Position (x, y, z) in meters
+                orientation (tuple): Orientation as quaternion (x, y, z, w)
+                linear (tuple): Linear velocity (x, y, z) in m/s
+                angular (tuple): Angular velocity (x, y, z) in rad/s
+        """
+        return self._rs_core.odom_data   
+
+    
+    def robot_position(self) -> Tuple[float, float, float]:
+        """Returns the robot's position in world coordinates.
+
+        Returns:
+            Tuple[float, float, float]: Position (x, y, z) in meters.
+        """
+        return self._rs_core.odom_data.position
+
+    def robot_orientation(self) -> Tuple[float, float, float, float]:
+        """Returns the robot's orientation in world coordinates.
+
+        Returns:
+            Tuple[float, float, float, float]: Orientation as quaternion (x, y, z, w).
+        """
+        return self._rs_core.odom_data.orientation
+
+    def linear_velocity(self) -> Tuple[float, float, float]:
+        """Returns the robot's linear velocity in world coordinates.
+
+        Returns:
+            Tuple[float, float, float]: Linear velocity (x, y, z) in m/s.
+        """
+        return self._rs_core.odom_data.linear
+    
+
+    def angular_velocity(self) -> Tuple[float, float, float]:
+        """Returns the robot's angular velocity in world coordinates.
+
+        Returns:
+            Tuple[float, float, float]: Angular velocity (x, y, z).
+        """
+        return self._rs_core.odom_data.angular
+
+    def arm_joint_state(self) -> KuavoJointData:
+        """Get the current state of the robot arm joints.
+
+        Get the current state of the robot arm joints, including:
+            - Joint positions (angles) in radians
+            - Joint velocities in radians/second 
+            - Joint torques/efforts in Newton-meters, A
+            - Joint acceleration
+
+        Returns:
+            KuavoJointData: Arm joint data containing:
+                position: list[float] * arm_dof(14)
+                velocity: list[float] * arm_dof(14)
+                torque: list[float]   * arm_dof(14)
+                acceleration: list[float] * arm_dof(14)
+        """
+        # Get arm joint states from index 12 to 25 (14 arm joints)
+        arm_joint_indices = range(12, 12+14)
+        return KuavoJointData(
+            position=[self._rs_core.joint_data.position[i] for i in arm_joint_indices],
+            velocity=[self._rs_core.joint_data.velocity[i] for i in arm_joint_indices],
+            torque=[self._rs_core.joint_data.torque[i] for i in arm_joint_indices],
+            acceleration=[self._rs_core.joint_data.acceleration[i] for i in arm_joint_indices]
+        )
+
+    def arm_control_mode(self) -> KuavoArmCtrlMode:
+        """Get the current control mode of the robot arm.
+
+        Returns:
+            KuavoArmCtrlMode: Current arm control mode:
+                ArmFixed: 0 - The robot arm is in a fixed position.
+                AutoSwing: 1 - The robot arm is in automatic swing mode.
+                ExternalControl: 2 - The robot arm is controlled externally.
+                or None.
+        """
+        return self._rs_core.arm_control_mode
+    
+    def head_joint_state(self) -> KuavoJointData:
+        """Get the current state of the robot head joints.
+
+        Gets the current state data for the robot's head joints, including position,
+        velocity, torque and acceleration values.
+
+        Returns:
+            KuavoJointData: A data structure containing the head joint states:
+                position (list[float]): Joint positions in radians, length=head_dof(2)
+                velocity (list[float]): Joint velocities in rad/s, length=head_dof(2) 
+                torque (list[float]): Joint torques in Nm, length=head_dof(2)
+                acceleration (list[float]): Joint accelerations in rad/s^2, length=head_dof(2)
+                
+            The joint order is [yaw, pitch].
+        """
+        # Get head joint states from last 2 indices
+        head_joint_indices = range(len(self._rs_core.joint_data.position)-2, len(self._rs_core.joint_data.position))
+        return KuavoJointData(
+            position=[self._rs_core.joint_data.position[i] for i in head_joint_indices],
+            velocity=[self._rs_core.joint_data.velocity[i] for i in head_joint_indices], 
+            torque=[self._rs_core.joint_data.torque[i] for i in head_joint_indices],
+            acceleration=[self._rs_core.joint_data.acceleration[i] for i in head_joint_indices]
+        )
+    
+    def eef_state(self)->Tuple[EndEffectorState, EndEffectorState]:
+        """Get the current state of the robot's end effectors.
+
+        Returns:
+            Tuple[EndEffectorState, EndEffectorState]: A tuple containing the state of the left and right end effectors.
+                Each EndEffectorState contains:
+                    - position: (float, float, float) - XYZ position in meters
+                    - orientation: (float, float, float, float) - Quaternion orientation
+                    - state: EndEffectorState.GraspingState - Current grasping state (UNKNOWN, OPEN, CLOSED)
+        """
+        return self._rs_core.eef_state
+
+    def gait_name(self)->str:
+        """Get the current gait name of the robot.
+
+        Returns:
+            str: The name of the current gait, e.g. 'trot', 'walk', 'stance', 'custom_gait'.
+        """
+        return self._rs_core.gait_name()
+    
+
+    def is_stance(self) -> bool:
+        """Check if the robot is currently in stance mode.
+
+        Returns:
+            bool: True if robot is in stance mode, False otherwise.
+        """
+        return self._rs_core.is_gait('stance')
+
+    def is_walk(self) -> bool:
+        """Check if the robot is currently in walk mode.
+
+        Returns:
+            bool: True if robot is in walk mode, False otherwise.
+        """
+        return self._rs_core.is_gait('walk')
+
+    def is_step_control(self) -> bool:
+        """Check if the robot is currently in step control mode.
+
+        Returns:
+            bool: True if robot is in step control mode, False otherwise.
+        """
+        return self._rs_core.is_gait('custom_gait')
+
+    def wait_for_stance(self, timeout:float=5.0)->bool:
+        """Wait for the robot to enter stance state.
+
+        Args:
+            timeout (float): The maximum time to wait for the robot to enter stance state in seconds.
+
+        Returns:
+            bool: True if the robot enters stance state within the specified timeout, False otherwise.
+        """
+        wait_time = 0
+        while not self._rs_core.is_gait('stance') and wait_time < timeout:
+            time.sleep(0.1)
+            wait_time += 0.1
+        return self._rs_core.is_gait('stance')
+    
+    def wait_for_walk(self, timeout:float=5.0)->bool:
+        """Wait for the robot to enter walk state.
+
+        Args:
+            timeout (float): The maximum time to wait for the robot to enter walk state in seconds.
+
+        Returns:
+            bool: True if the robot enters walk state within the specified timeout, False otherwise.
+        """
+        wait_time = 0
+        while not self._rs_core.is_gait('walk') and wait_time < timeout:
+            time.sleep(0.1)
+            wait_time += 0.1
+        return self._rs_core.is_gait('walk')
+
+    def wait_for_step_control(self, timeout:float=5.0)->bool:
+        """Wait for the robot to enter step control state.
+
+        Args:
+            timeout (float): The maximum time to wait for the robot to enter step control state in seconds.
+
+        Returns:
+            bool: True if the robot enters step control state within the specified timeout, False otherwise.
+        """
+        wait_time = 0
+        while not self._rs_core.is_gait('custom_gait') and wait_time < timeout:
+            time.sleep(0.1)
+            wait_time += 0.1
+        return self._rs_core.is_gait('custom_gait')

kuavo_humanoid_sdk-0.1.0.dist-info/METADATA

@@ -0,0 +1,217 @@
+Metadata-Version: 2.1
+Name: kuavo-humanoid-sdk
+Version: 0.1.0
+Summary: A Python SDK for kuavo humanoid robot.
+Home-page: https://gitee.com/leju-robot/kuavo-ros-opensource/
+Author: ['lejurobot']
+Author-email: ['edu@lejurobot.com']
+License: MIT
+Project-URL: Documentation, https://gitee.com/leju-robot/kuavo-ros-opensource/
+Project-URL: Source Code, https://gitee.com/leju-robot/kuavo-ros-opensource/
+Keywords: kuavo,humanoid,robot,robotics,lejurobot,ros
+Platform: UNKNOWN
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: transitions
+
+# Kuavo Humanoid SDK
+
+A comprehensive Python SDK for controlling Kuavo humanoid robots. This SDK provides interfaces for robot state management, arm and head control, and end-effector operations. It is designed to work with ROS (Robot Operating System) environments.
+
+**Warning**: This SDK currently only supports **ROS1**. ROS2 support is not available.
+
+![Kuavo 4Pro Robot](https://kuavo.lejurobot.com/manual/assets/images/kuavo_4pro-cf84d43f1c370666c6e810d2807ae3e4.png)
+
+## Features
+
+- Robot State Management
+  - IMU data (acceleration, angular velocity, euler angles)
+  - Joint/motor states (position, velocity, torque)
+  - Torso state (position, orientation, velocity)
+  - Odometry information
+  - End-effector states:
+    - Gripper: position, velocity, torque, grasp status
+    - Dexterous hand: position, velocity, torque
+    - End-effector position and orientation
+  - Motion states: stand, walk, step_control, trot
+
+- Motion Control
+  - Arm Control
+    - Joint position control
+    - End-effector 6D control via inverse kinematics
+    - Forward kinematics (FK) for computing end-effector pose
+    - Keyframe sequence control for complex motions
+  - End-effector Control
+    - Gripper control (position control with configurable velocity and torque)
+    - Dexterous hand control
+      - Position control
+      - Pre-defined hand gestures (OK, 666, fist, etc.)
+  - Head Control
+    - Position control
+  - Torso Control
+    - Height control (squatting)
+    - Forward/backward tilt control
+  - Dynamic Motion Control
+    - Stance
+    - Trot
+    - Walking (xy and yaw velocity control)
+    - Stepping (gait switching)
+
+- Robot Basic Information
+  - Robot type (kuavo)
+  - Robot version
+  - End-effector type
+  - Joint names
+  - Total degrees of freedom (28)
+  - Arm degrees of freedom (7 per arm)
+  - Head degrees of freedom (2)
+  - Leg degrees of freedom (12)
+
+## Installation
+
+To install Kuavo Humanoid SDK, you can use pip:
+```bash
+ pip install kuavo-humanoid-sdk
+```
+
+For development installation (editable mode), use:
+```bash
+ pip install -e .
+```
+
+## Package Information
+
+You can check the package information using pip:
+```bash
+pip show kuavo-humanoid-sdk
+```
+
+## Quick Start
+
+Here's a simple example to get started with Kuavo Humanoid SDK:
+
+> **Warning**: Before running any code, make sure to start the robot first by executing either:
+> - For simulation: `roslaunch humanoid_controllers load_kuavo_mujoco_sim.launch` (Example command)
+> - For real robot: `roslaunch humanoid_controllers load_kuavo_real.launch` (Example command)
+```python3
+# Copyright (c) 2025 Leju Robotics. Licensed under the MIT License.
+import time
+from kuavo_humanoid_sdk import KuavoSDK, KuavoRobot
+
+def main():
+    if not KuavoSDK().Init():  # Init! !!! IMPORTANT !!!
+        print("Init KuavoSDK failed, exit!")
+        exit(1)
+    robot = KuavoRobot()    
+
+    """ arm reset """
+    print("Switching to arm reset mode...")
+    robot.arm_reset()
+
+    """ stance """
+    print("Switching to stance mode...")
+    robot.stance()
+
+    """ trot """
+    print("Switching to trot mode...")
+    robot.trot()
+
+    """ walk forward """
+    print("Starting forward walk...")
+    duration = 4.0  # seconds
+    speed = 0.3     # m/s
+    start_time = time.time()
+    while (time.time() - start_time < duration):
+        robot.walk(linear_x=speed, linear_y=0.0, angular_z=0.0)
+        time.sleep(0.1)  # Small sleep to prevent busy loop
+
+if __name__ == "__main__":
+    main()
+```
+
+## Examples
+
+#### WARNING
+Before running any code examples, make sure to start the robot first by executing either:
+
+- For simulation: `roslaunch humanoid_controllers load_kuavo_mujoco_sim.launch` (Example command)
+- For real robot: `roslaunch humanoid_controllers load_kuavo_real.launch` (Example command)
+
+### Robot Info
+
+Examples showing how to get basic robot information.
+
+[https://gitee.com/leju-robot/kuavo-ros-opensource/tree/master/src/kuavo_humanoid_sdk/examples/robot_info_example.py](https://gitee.com/leju-robot/kuavo-ros-opensource/tree/master/src/kuavo_humanoid_sdk/examples/robot_info_example.py)
+
+### Basic Robot Control
+
+A basic example showing how to initialize the SDK and control the robot’s movement.
+
+[https://gitee.com/leju-robot/kuavo-ros-opensource/tree/master/src/kuavo_humanoid_sdk/examples/motion_example.py](https://gitee.com/leju-robot/kuavo-ros-opensource/tree/master/src/kuavo_humanoid_sdk/examples/motion_example.py)
+
+### End Effector Control
+
+#### LejuClaw Gripper
+
+Examples demonstrating how to control the LejuClaw gripper end effector, including position, velocity and torque control.
+
+[https://gitee.com/leju-robot/kuavo-ros-opensource/tree/master/src/kuavo_humanoid_sdk/examples/lejuclaw_example.py](https://gitee.com/leju-robot/kuavo-ros-opensource/tree/master/src/kuavo_humanoid_sdk/examples/lejuclaw_example.py)
+
+#### QiangNao DexHand
+
+Examples showing how to control the QiangNao DexHand, a dexterous robotic hand with multiple degrees of freedom for complex manipulation tasks.
+
+[https://gitee.com/leju-robot/kuavo-ros-opensource/tree/master/src/kuavo_humanoid_sdk/examples/dexhand_example.py](https://gitee.com/leju-robot/kuavo-ros-opensource/tree/master/src/kuavo_humanoid_sdk/examples/dexhand_example.py)
+
+### Arm Control
+
+Examples showing arm trajectory control and target pose control.
+
+[https://gitee.com/leju-robot/kuavo-ros-opensource/tree/master/src/kuavo_humanoid_sdk/examples/ctrl_arm_example.py](https://gitee.com/leju-robot/kuavo-ros-opensource/tree/master/src/kuavo_humanoid_sdk/examples/ctrl_arm_example.py)
+
+### Forward and Inverse Kinematics
+
+Examples demonstrating how to use forward kinematics (FK) to compute end-effector positions from joint angles, and inverse kinematics (IK) to calculate joint angles needed to achieve desired end-effector poses.
+
+[https://gitee.com/leju-robot/kuavo-ros-opensource/tree/master/src/kuavo_humanoid_sdk/examples/arm_ik_example.py](https://gitee.com/leju-robot/kuavo-ros-opensource/tree/master/src/kuavo_humanoid_sdk/examples/arm_ik_example.py)
+
+### Head Control
+
+Examples showing how to control the robot’s head movements, including nodding (pitch) and shaking (yaw) motions.
+
+[https://gitee.com/leju-robot/kuavo-ros-opensource/tree/master/src/kuavo_humanoid_sdk/examples/ctrl_head_example.py](https://gitee.com/leju-robot/kuavo-ros-opensource/tree/master/src/kuavo_humanoid_sdk/examples/ctrl_head_example.py)
+
+### Step-by-Step Control
+
+Examples showing how to control the robot’s movements step by step, including individual foot placement and trajectory control.
+
+[https://gitee.com/leju-robot/kuavo-ros-opensource/tree/master/src/kuavo_humanoid_sdk/examples/step_control_example.py](https://gitee.com/leju-robot/kuavo-ros-opensource/tree/master/src/kuavo_humanoid_sdk/examples/step_control_example.py)
+
+
+## Docs
+
+https://gitee.com/leju-robot/kuavo-ros-opensource/tree/master/src/kuavo_humanoid_sdk/docs/markdown/index.md
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## Contact & Support
+
+For any questions, support, or bug reports, please contact:
+- Email: edu@lejurobot.com
+- Website: https://gitee.com/leju-robot/kuavo-ros-opensource/
+- Source Code: https://gitee.com/leju-robot/kuavo-ros-opensource/
+- Issue Tracker: https://gitee.com/leju-robot/kuavo-ros-opensource/issues
+
+

kuavo_humanoid_sdk-0.1.0.dist-info/RECORD

@@ -0,0 +1,27 @@
+kuavo_humanoid_sdk/__init__.py,sha256=alEgqxypKm-gg2CSlhoHK5P3Crg1f8NEI74bbX37uDI,122
+kuavo_humanoid_sdk/common/logger.py,sha256=nSIbsJaW4nDcaQdhZebZkjtji6kmWVR8tYO-sUTz3Gg,1246
+kuavo_humanoid_sdk/interfaces/__init__.py,sha256=_zXDinj2T3X7UH19-Xrotc7uYZWHmZqHaMCWU1FYR5I,100
+kuavo_humanoid_sdk/interfaces/data_types.py,sha256=fQ_9ZPL8KFsFExDnfRI3II_qy7-WgcNYudywA7iLCAQ,4266
+kuavo_humanoid_sdk/interfaces/end_effector.py,sha256=gOnbZudoFHL2ZZjfcbteqcFVhF-T6khtEpoF6PjVffo,1244
+kuavo_humanoid_sdk/interfaces/robot.py,sha256=qqnq7gRc_mK8xEWnF5pJ7AJUPtry1bpN9eDl8nmE3EM,393
+kuavo_humanoid_sdk/interfaces/robot_info.py,sha256=-rh7VXjMJFYTsx7Ktok5VuI6JF_W2BpJBUbqtYJRkkA,1176
+kuavo_humanoid_sdk/kuavo/__init__.py,sha256=s4UZkSKP22K1712vLR96dBiXgOAaWd88bCr-WAKNuus,271
+kuavo_humanoid_sdk/kuavo/dexterous_hand.py,sha256=tHqpKH5Bti4qcI4U_AnAGg9s7qSAVHMwDvsPOzUwt0I,8026
+kuavo_humanoid_sdk/kuavo/leju_claw.py,sha256=HqTg3Q4NO9icwv7MJzLFxTADLJAjrD92Z3AQULJ5Epo,9624
+kuavo_humanoid_sdk/kuavo/robot.py,sha256=Xou9Zi5j8HyiClXzEXbNBgBc1QZf8Q5EKW17D37Cj2Y,13132
+kuavo_humanoid_sdk/kuavo/robot_arm.py,sha256=M7u_cwBLF7TKCbU85rGKMHAu3E3WKvUCsvadVtBMkVw,6690
+kuavo_humanoid_sdk/kuavo/robot_head.py,sha256=8caHrPNwg98b4jf5cLJUbsGNovgtXetOqBvuG5vWSXA,1526
+kuavo_humanoid_sdk/kuavo/robot_info.py,sha256=XcrShWG0yG2kuuVbiM0RW8Frh-M9dcFASlSuwJX_pVo,3850
+kuavo_humanoid_sdk/kuavo/robot_state.py,sha256=dE2bqdYdev_pQyAAgpU9vS_69brF92EmqQxYJzP7grw,10470
+kuavo_humanoid_sdk/kuavo/core/core.py,sha256=QHneyt7UqX73XqrC0mCmRnMtCEOtrl9kjJPjUT6gKyU,17668
+kuavo_humanoid_sdk/kuavo/core/dex_hand_control.py,sha256=pJr50Nxx1OGJa7D5pg1w6BkX3_k8a3Ot70N-OAJ-Mlw,3665
+kuavo_humanoid_sdk/kuavo/core/leju_claw_control.py,sha256=RCrnWTMW-L0fOMa1op7t43aGWSyMVqrOjR0lVtIFzqY,3432
+kuavo_humanoid_sdk/kuavo/core/ros_env.py,sha256=P0tiURlwxhW_WUrPUmz_bigTTFm0XuQqjQsh2hK8FMs,7871
+kuavo_humanoid_sdk/kuavo/core/ros/control.py,sha256=8DKfxqKFWy3zRSTWYPWyiJWsq6NIA8Oa3yWY95qWrwg,31996
+kuavo_humanoid_sdk/kuavo/core/ros/param.py,sha256=H-Kvy5QokHuYB3vCplwd6IFuVFK4lJV0KuYErVV5Qcs,6625
+kuavo_humanoid_sdk/kuavo/core/ros/sat_utils.py,sha256=AhBNM-s9nVwRiLZ8gtqC2RvPImkT9uulONSLXk3KooI,3317
+kuavo_humanoid_sdk/kuavo/core/ros/state.py,sha256=ZmP8Ku18nTzCSO-VNWXdr9BKVN0IS-8N6xeHjNEMNHw,13776
+kuavo_humanoid_sdk-0.1.0.dist-info/METADATA,sha256=0LYI0m07z70-zRKb_sMsZu_Mytyjrejiso2IZ2pIrQY,8336
+kuavo_humanoid_sdk-0.1.0.dist-info/WHEEL,sha256=bFJAMchF8aTQGUgMZzHJyDDMPTO3ToJ7x23SLJa1SVo,92
+kuavo_humanoid_sdk-0.1.0.dist-info/top_level.txt,sha256=9uSyZoiOEykRMOf0Gm-N9mkyQQg9yOSimfsb632G99c,19
+kuavo_humanoid_sdk-0.1.0.dist-info/RECORD,,

kuavo_humanoid_sdk-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.45.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

kuavo_humanoid_sdk-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+kuavo_humanoid_sdk