kscale 0.2.2__py3-none-any.whl → 0.3.1__py3-none-any.whl

kscale/__init__.py

@@ -1,6 +1,6 @@
 """Defines the common interface for the K-Scale Python API."""
 
-__version__ = "0.2.2"
+__version__ = "0.3.1"
 
 from pathlib import Path
 

kscale/web/cli/robot_class.py

@@ -1,16 +1,26 @@
 """Defines the CLI for getting information about robot classes."""
 
+import json
 import logging
+import math
+import time
+from typing import Sequence
 
 import click
 from tabulate import tabulate
 
 from kscale.utils.cli import coro
 from kscale.web.clients.robot_class import RobotClassClient
+from kscale.web.gen.api import RobotURDFMetadataInput
 
 logger = logging.getLogger(__name__)
 
 
+class RobotURDFMetadataInputStrict(RobotURDFMetadataInput):
+    class Config:
+        extra = "forbid"
+
+
 @click.group()
 def cli() -> None:
     """Get information about robot classes."""
@@ -70,6 +80,37 @@ async def update(current_name: str, name: str | None = None, description: str |
     click.echo(f"  Description: {click.style(robot_class.description or 'N/A', fg='yellow')}")
 
 
+@cli.command()
+@click.argument("name")
+@click.argument("json_path", type=click.Path(exists=True))
+@coro
+async def update_metadata(name: str, json_path: str) -> None:
+    """Updates the metadata of a robot class."""
+    with open(json_path, "r", encoding="utf-8") as f:
+        raw_metadata = json.load(f)
+    metadata = RobotURDFMetadataInputStrict.model_validate(raw_metadata)
+    async with RobotClassClient() as client:
+        robot_class = await client.update_robot_class(name, new_metadata=metadata)
+    click.echo("Robot class metadata updated:")
+    click.echo(f"  ID: {click.style(robot_class.id, fg='blue')}")
+    click.echo(f"  Name: {click.style(robot_class.class_name, fg='green')}")
+
+
+@cli.command()
+@click.argument("name")
+@click.option("--json-path", type=click.Path(exists=False))
+@coro
+async def get_metadata(name: str, json_path: str | None = None) -> None:
+    """Gets the metadata of a robot class."""
+    async with RobotClassClient() as client:
+        robot_class = await client.get_robot_class(name)
+    if json_path is None:
+        click.echo(robot_class.metadata.model_dump_json(indent=2))
+    else:
+        with open(json_path, "w", encoding="utf-8") as f:
+            json.dump(robot_class.model_dump(), f)
+
+
 @cli.command()
 @click.argument("name")
 @coro
@@ -109,5 +150,283 @@ async def download(class_name: str, no_cache: bool) -> None:
     click.echo(f"URDF downloaded: {click.style(urdf_file, fg='green')}")
 
 
+@urdf.command()
+@click.argument("class_name")
+@click.option("--no-cache", is_flag=True, default=False)
+@click.option("--hide-gui", is_flag=True, default=False)
+@click.option("--hide-origin", is_flag=True, default=False)
+@click.option("--see-thru", is_flag=True, default=False)
+@click.option("--show-collision", is_flag=True, default=False)
+@click.option("--show-inertia", is_flag=True, default=False)
+@click.option("--fixed-base", is_flag=True, default=False)
+@click.option("--no-merge", is_flag=True, default=False)
+@click.option("--dt", type=float, default=0.01)
+@click.option("--start-height", type=float, default=0.0)
+@click.option("--cycle-duration", type=float, default=2.0)
+@coro
+async def pybullet(
+    class_name: str,
+    no_cache: bool,
+    hide_gui: bool,
+    hide_origin: bool,
+    see_thru: bool,
+    show_collision: bool,
+    show_inertia: bool,
+    fixed_base: bool,
+    no_merge: bool,
+    dt: float,
+    start_height: float,
+    cycle_duration: float,
+) -> None:
+    """Shows the URDF file for a robot class in PyBullet."""
+    try:
+        import pybullet as p
+    except ImportError:
+        click.echo(click.style("PyBullet is not installed; install it with `pip install pybullet`", fg="red"))
+        return
+    async with RobotClassClient() as client:
+        urdf_base = await client.download_and_extract_urdf(class_name, cache=not no_cache)
+    try:
+        urdf_path = next(urdf_base.glob("*.urdf"))
+    except StopIteration:
+        click.echo(click.style(f"No URDF file found in {urdf_base}", fg="red"))
+        return
+
+    # Connect to PyBullet.
+    p.connect(p.GUI)
+    p.setGravity(0, 0, -9.81)
+    p.setRealTimeSimulation(0)
+
+    # Create floor plane
+    floor = p.createCollisionShape(p.GEOM_PLANE)
+    p.createMultiBody(0, floor)
+
+    # Turn off panels.
+    if hide_gui:
+        p.configureDebugVisualizer(p.COV_ENABLE_GUI, 0)
+    p.configureDebugVisualizer(p.COV_ENABLE_SEGMENTATION_MARK_PREVIEW, 0)
+    p.configureDebugVisualizer(p.COV_ENABLE_DEPTH_BUFFER_PREVIEW, 0)
+    p.configureDebugVisualizer(p.COV_ENABLE_RGB_BUFFER_PREVIEW, 0)
+
+    # Enable mouse picking.
+    p.configureDebugVisualizer(p.COV_ENABLE_MOUSE_PICKING, 1)
+
+    # Load the robot URDF.
+    start_position = [0.0, 0.0, start_height]
+    start_orientation = p.getQuaternionFromEuler([0.0, 0.0, 0.0])
+    flags = p.URDF_USE_INERTIA_FROM_FILE
+    if not no_merge:
+        flags |= p.URDF_MERGE_FIXED_LINKS
+
+    robot = p.loadURDF(
+        str(urdf_path.resolve().absolute()),
+        start_position,
+        start_orientation,
+        flags=flags,
+        useFixedBase=fixed_base,
+    )
+
+    # Display collision meshes as separate object.
+    if show_collision:
+        collision_flags = p.URDF_USE_INERTIA_FROM_FILE | p.URDF_USE_SELF_COLLISION_EXCLUDE_ALL_PARENTS
+        collision = p.loadURDF(
+            str(urdf_path.resolve().absolute()),
+            start_position,
+            start_orientation,
+            flags=collision_flags,
+            useFixedBase=0,
+        )
+
+        # Make collision shapes semi-transparent.
+        joint_ids = [i for i in range(p.getNumJoints(collision))] + [-1]
+        for i in joint_ids:
+            p.changeVisualShape(collision, i, rgbaColor=[1, 0, 0, 0.5])
+
+    # Initializes physics parameters.
+    p.changeDynamics(floor, -1, lateralFriction=1, spinningFriction=-1, rollingFriction=-1)
+    p.setPhysicsEngineParameter(fixedTimeStep=dt, maxNumCmdPer1ms=1000)
+
+    # Shows the origin of the robot.
+    if not hide_origin:
+        p.addUserDebugLine([0, 0, 0], [0.1, 0, 0], [1, 0, 0], parentObjectUniqueId=robot, parentLinkIndex=-1)
+        p.addUserDebugLine([0, 0, 0], [0, 0.1, 0], [0, 1, 0], parentObjectUniqueId=robot, parentLinkIndex=-1)
+        p.addUserDebugLine([0, 0, 0], [0, 0, 0.1], [0, 0, 1], parentObjectUniqueId=robot, parentLinkIndex=-1)
+
+    # Make the robot see-through.
+    joint_ids = [i for i in range(p.getNumJoints(robot))] + [-1]
+    if see_thru:
+        shape_data = p.getVisualShapeData(robot)
+        for i in joint_ids:
+            prev_color = shape_data[i][-1]
+            p.changeVisualShape(robot, i, rgbaColor=prev_color[:3] + (0.9,))
+
+    def draw_box(pt: Sequence[Sequence[float]], color: tuple[float, float, float], obj_id: int, link_id: int) -> None:
+        """Draw a box in PyBullet debug visualization.
+
+        Args:
+            pt: List of 8 points defining box vertices, each point is [x,y,z]
+            color: RGB color tuple for the box lines
+            obj_id: PyBullet object ID to attach box to
+            link_id: Link ID on the object to attach box to
+        """
+        assert len(pt) == 8
+        assert all(len(p) == 3 for p in pt)
+
+        p.addUserDebugLine(pt[0], pt[1], color, 1, parentObjectUniqueId=obj_id, parentLinkIndex=link_id)
+        p.addUserDebugLine(pt[1], pt[3], color, 1, parentObjectUniqueId=obj_id, parentLinkIndex=link_id)
+        p.addUserDebugLine(pt[3], pt[2], color, 1, parentObjectUniqueId=obj_id, parentLinkIndex=link_id)
+        p.addUserDebugLine(pt[2], pt[0], color, 1, parentObjectUniqueId=obj_id, parentLinkIndex=link_id)
+
+        p.addUserDebugLine(pt[0], pt[4], color, 1, parentObjectUniqueId=obj_id, parentLinkIndex=link_id)
+        p.addUserDebugLine(pt[1], pt[5], color, 1, parentObjectUniqueId=obj_id, parentLinkIndex=link_id)
+        p.addUserDebugLine(pt[2], pt[6], color, 1, parentObjectUniqueId=obj_id, parentLinkIndex=link_id)
+        p.addUserDebugLine(pt[3], pt[7], color, 1, parentObjectUniqueId=obj_id, parentLinkIndex=link_id)
+
+        p.addUserDebugLine(pt[4 + 0], pt[4 + 1], color, 1, parentObjectUniqueId=obj_id, parentLinkIndex=link_id)
+        p.addUserDebugLine(pt[4 + 1], pt[4 + 3], color, 1, parentObjectUniqueId=obj_id, parentLinkIndex=link_id)
+        p.addUserDebugLine(pt[4 + 3], pt[4 + 2], color, 1, parentObjectUniqueId=obj_id, parentLinkIndex=link_id)
+        p.addUserDebugLine(pt[4 + 2], pt[4 + 0], color, 1, parentObjectUniqueId=obj_id, parentLinkIndex=link_id)
+
+    # Shows bounding boxes around each part of the robot representing the inertia frame.
+    if show_inertia:
+        for i in joint_ids:
+            dynamics_info = p.getDynamicsInfo(robot, i)
+            mass = dynamics_info[0]
+            if mass <= 0:
+                continue
+            inertia = dynamics_info[2]
+
+            # Calculate box dimensions.
+            ixx, iyy, izz = inertia[0], inertia[1], inertia[2]
+            box_scale_x = math.sqrt(6 * (iyy + izz - ixx) / mass) / 2
+            box_scale_y = math.sqrt(6 * (ixx + izz - iyy) / mass) / 2
+            box_scale_z = math.sqrt(6 * (ixx + iyy - izz) / mass) / 2
+            half_extents = [box_scale_x, box_scale_y, box_scale_z]
+
+            # Create box vertices in local inertia frame
+            pt = [
+                [half_extents[0], half_extents[1], half_extents[2]],
+                [-half_extents[0], half_extents[1], half_extents[2]],
+                [half_extents[0], -half_extents[1], half_extents[2]],
+                [-half_extents[0], -half_extents[1], half_extents[2]],
+                [half_extents[0], half_extents[1], -half_extents[2]],
+                [-half_extents[0], half_extents[1], -half_extents[2]],
+                [half_extents[0], -half_extents[1], -half_extents[2]],
+                [-half_extents[0], -half_extents[1], -half_extents[2]],
+            ]
+
+            draw_box(pt, (1, 0, 0), robot, i)
+
+    # Show joint controller.
+    joints: dict[str, int] = {}
+    controls: dict[str, float] = {}
+    for i in range(p.getNumJoints(robot)):
+        joint_info = p.getJointInfo(robot, i)
+        name = joint_info[1].decode("utf-8")
+        joint_type = joint_info[2]
+        joints[name] = i
+        if joint_type == p.JOINT_PRISMATIC:
+            joint_min, joint_max = joint_info[8:10]
+            controls[name] = p.addUserDebugParameter(name, joint_min, joint_max, 0.0)
+        elif joint_type == p.JOINT_REVOLUTE:
+            joint_min, joint_max = joint_info[8:10]
+            controls[name] = p.addUserDebugParameter(name, joint_min, joint_max, 0.0)
+
+    def reset_joints_to_zero(robot: int, joints: dict[str, int]) -> None:
+        for joint_id in joints.values():
+            joint_info = p.getJointInfo(robot, joint_id)
+            joint_min, joint_max = joint_info[8:10]
+            zero_position = (joint_min + joint_max) / 2
+            p.setJointMotorControl2(robot, joint_id, p.POSITION_CONTROL, zero_position)
+
+    def reset_camera(position: int) -> None:
+        height = start_height if fixed_base else 0
+        camera_positions = {
+            1: (2.0, 0, -30, [0, 0, height]),  # Default view
+            2: (2.0, 90, -30, [0, 0, height]),  # Side view
+            3: (2.0, 180, -30, [0, 0, height]),  # Back view
+            4: (2.0, 270, -30, [0, 0, height]),  # Other side view
+            5: (2.0, 0, 0, [0, 0, height]),  # Front level view
+            6: (2.0, 0, -80, [0, 0, height]),  # Top-down view
+            7: (1.5, 45, -45, [0, 0, height]),  # Closer angled view
+            8: (3.0, 30, -30, [0, 0, height]),  # Further angled view
+            9: (2.0, 0, 30, [0, 0, height]),  # Low angle view
+        }
+
+        if position in camera_positions:
+            distance, yaw, pitch, target = camera_positions[position]
+            p.resetDebugVisualizerCamera(
+                cameraDistance=distance,
+                cameraYaw=yaw,
+                cameraPitch=pitch,
+                cameraTargetPosition=target,
+            )
+
+    # Run the simulation until the user closes the window.
+    last_time = time.time()
+    prev_control_values = {k: 0.0 for k in controls}
+    cycle_joints = False
+    cycle_start_time = 0.0
+
+    while p.isConnected():
+        # Reset the simulation if "r" was pressed.
+        keys = p.getKeyboardEvents()
+        if ord("r") in keys and keys[ord("r")] & p.KEY_WAS_TRIGGERED:
+            p.resetBasePositionAndOrientation(robot, start_position, start_orientation)
+            p.setJointMotorControlArray(
+                robot,
+                range(p.getNumJoints(robot)),
+                p.POSITION_CONTROL,
+                targetPositions=[0] * p.getNumJoints(robot),
+            )
+
+        # Reset joints to zero position if "z" was pressed
+        if ord("z") in keys and keys[ord("z")] & p.KEY_WAS_TRIGGERED:
+            reset_joints_to_zero(robot, joints)
+            cycle_joints = False  # Stop joint cycling if it was active
+
+        # Reset camera if number keys 1-9 are pressed
+        for i in range(1, 10):
+            if ord(str(i)) in keys and keys[ord(str(i))] & p.KEY_WAS_TRIGGERED:
+                reset_camera(i)
+
+        # Start/stop joint cycling if "c" was pressed
+        if ord("c") in keys and keys[ord("c")] & p.KEY_WAS_TRIGGERED:
+            cycle_joints = not cycle_joints
+            if cycle_joints:
+                cycle_start_time = time.time()
+            else:
+                # When stopping joint cycling, set joints to their current positions
+                for k, v in controls.items():
+                    current_position = p.getJointState(robot, joints[k])[0]
+                    p.setJointMotorControl2(robot, joints[k], p.POSITION_CONTROL, current_position)
+
+        # Set joint positions.
+        if cycle_joints:
+            elapsed_time = time.time() - cycle_start_time
+            cycle_progress = (elapsed_time % cycle_duration) / cycle_duration
+            for k, v in controls.items():
+                joint_info = p.getJointInfo(robot, joints[k])
+                joint_min, joint_max = joint_info[8:10]
+                target_position = joint_min + (joint_max - joint_min) * math.sin(cycle_progress * math.pi)
+                p.setJointMotorControl2(robot, joints[k], p.POSITION_CONTROL, target_position)
+        else:
+            for k, v in controls.items():
+                try:
+                    target_position = p.readUserDebugParameter(v)
+                    if target_position != prev_control_values[k]:
+                        prev_control_values[k] = target_position
+                        p.setJointMotorControl2(robot, joints[k], p.POSITION_CONTROL, target_position)
+                except p.error:
+                    logger.debug("Failed to set joint %s", k)
+                    pass
+
+        # Step simulation.
+        p.stepSimulation()
+        cur_time = time.time()
+        time.sleep(max(0, dt - (cur_time - last_time)))
+        last_time = cur_time
+
+
 if __name__ == "__main__":
     cli()

kscale/web/clients/base.py

@@ -360,9 +360,10 @@ class BaseClient:
         files: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
         url = urljoin(self.base_url, endpoint)
-        kwargs: dict[str, Any] = {"params": params}
-
-        if data:
+        kwargs: dict[str, Any] = {}
+        if params is not None:
+            kwargs["params"] = params
+        if data is not None:
             if isinstance(data, BaseModel):
                 kwargs["json"] = data.model_dump(exclude_unset=True)
             else:

kscale/web/clients/robot.py

@@ -19,16 +19,16 @@ class RobotClient(BaseClient):
         class_name: str,
         description: str | None = None,
     ) -> RobotResponse:
-        params = {"class_name": class_name}
+        data = {"class_name": class_name}
         if description is not None:
-            params["description"] = description
-        data = await self._request(
+            data["description"] = description
+        response = await self._request(
             "PUT",
             f"/robot/{robot_name}",
-            params=params,
+            data=data,
             auth=True,
         )
-        return RobotResponse.model_validate(data)
+        return RobotResponse.model_validate(response)
 
     async def get_robot_by_id(self, robot_id: str) -> RobotResponse:
         data = await self._request("GET", f"/robot/id/{robot_id}", auth=True)

kscale/web/clients/robot_class.py

@@ -5,6 +5,7 @@ import json
 import logging
 import tarfile
 from pathlib import Path
+from typing import Any
 
 import httpx
 
@@ -13,6 +14,7 @@ from kscale.web.gen.api import (
     RobotClass,
     RobotDownloadURDFResponse,
     RobotUploadURDFResponse,
+    RobotURDFMetadataInput,
 )
 from kscale.web.utils import get_robots_dir, should_refresh_file
 
@@ -33,14 +35,22 @@ class RobotClassClient(BaseClient):
         )
         return [RobotClass.model_validate(item) for item in data]
 
+    async def get_robot_class(self, class_name: str) -> RobotClass:
+        data = await self._request(
+            "GET",
+            f"/robots/name/{class_name}",
+            auth=True,
+        )
+        return RobotClass.model_validate(data)
+
     async def create_robot_class(self, class_name: str, description: str | None = None) -> RobotClass:
-        params = {}
+        data = {}
         if description is not None:
-            params["description"] = description
+            data["description"] = description
         data = await self._request(
             "PUT",
             f"/robots/{class_name}",
-            params=params,
+            data=data,
             auth=True,
         )
         return RobotClass.model_validate(data)
@@ -50,18 +60,21 @@ class RobotClassClient(BaseClient):
         class_name: str,
         new_class_name: str | None = None,
         new_description: str | None = None,
+        new_metadata: RobotURDFMetadataInput | None = None,
     ) -> RobotClass:
-        params = {}
+        data: dict[str, Any] = {}
         if new_class_name is not None:
-            params["new_class_name"] = new_class_name
+            data["new_class_name"] = new_class_name
         if new_description is not None:
-            params["new_description"] = new_description
-        if not params:
+            data["new_description"] = new_description
+        if new_metadata is not None:
+            data["new_metadata"] = new_metadata.model_dump()
+        if not data:
             raise ValueError("No parameters to update")
         data = await self._request(
             "POST",
             f"/robots/{class_name}",
-            params=params,
+            data=data,
             auth=True,
         )
         return RobotClass.model_validate(data)
@@ -84,7 +97,7 @@ class RobotClassClient(BaseClient):
         data = await self._request(
             "PUT",
             f"/robots/urdf/{class_name}",
-            params={"filename": urdf_file.name, "content_type": content_type},
+            data={"filename": urdf_file.name, "content_type": content_type},
             auth=True,
         )
         response = RobotUploadURDFResponse.model_validate(data)

kscale/web/gen/api.py

@@ -2,15 +2,48 @@
 
 # generated by datamodel-codegen:
 #   filename:  openapi.json
-#   timestamp: 2025-01-15T22:35:42+00:00
+#   timestamp: 2025-01-22T04:20:37+00:00
 
 from __future__ import annotations
 
-from typing import List, Optional, Union
+from typing import Dict, List, Optional, Union
 
 from pydantic import BaseModel, Field
 
 
+class APIKeyRequest(BaseModel):
+    num_hours: Optional[int] = Field(24, title="Num Hours")
+
+
+class APIKeyResponse(BaseModel):
+    api_key: str = Field(..., title="Api Key")
+
+
+class AddRobotClassRequest(BaseModel):
+    description: Optional[str] = Field(None, title="Description")
+
+
+class AddRobotRequest(BaseModel):
+    description: Optional[str] = Field(None, title="Description")
+    class_name: str = Field(..., title="Class Name")
+
+
+class JointMetadataInput(BaseModel):
+    id: Optional[int] = Field(None, title="Id")
+    kp: Optional[Union[float, str]] = Field(None, title="Kp")
+    kd: Optional[Union[float, str]] = Field(None, title="Kd")
+    offset: Optional[Union[float, str]] = Field(None, title="Offset")
+    flipped: Optional[bool] = Field(None, title="Flipped")
+
+
+class JointMetadataOutput(BaseModel):
+    id: Optional[int] = Field(None, title="Id")
+    kp: Optional[str] = Field(None, title="Kp")
+    kd: Optional[str] = Field(None, title="Kd")
+    offset: Optional[str] = Field(None, title="Offset")
+    flipped: Optional[bool] = Field(None, title="Flipped")
+
+
 class OICDInfo(BaseModel):
     authority: str = Field(..., title="Authority")
     client_id: str = Field(..., title="Client Id")
@@ -24,13 +57,6 @@ class Robot(BaseModel):
     class_id: str = Field(..., title="Class Id")
 
 
-class RobotClass(BaseModel):
-    id: str = Field(..., title="Id")
-    class_name: str = Field(..., title="Class Name")
-    description: str = Field(..., title="Description")
-    user_id: str = Field(..., title="User Id")
-
-
 class RobotDownloadURDFResponse(BaseModel):
     url: str = Field(..., title="Url")
     md5_hash: str = Field(..., title="Md5 Hash")
@@ -44,12 +70,36 @@ class RobotResponse(BaseModel):
     class_name: str = Field(..., title="Class Name")
 
 
+class RobotURDFMetadataInput(BaseModel):
+    joint_name_to_metadata: Optional[Dict[str, JointMetadataInput]] = Field(None, title="Joint Name To Metadata")
+
+
+class RobotURDFMetadataOutput(BaseModel):
+    joint_name_to_metadata: Optional[Dict[str, JointMetadataOutput]] = Field(None, title="Joint Name To Metadata")
+
+
+class RobotUploadURDFRequest(BaseModel):
+    filename: str = Field(..., title="Filename")
+    content_type: str = Field(..., title="Content Type")
+
+
 class RobotUploadURDFResponse(BaseModel):
     url: str = Field(..., title="Url")
     filename: str = Field(..., title="Filename")
     content_type: str = Field(..., title="Content Type")
 
 
+class UpdateRobotClassRequest(BaseModel):
+    new_class_name: Optional[str] = Field(None, title="New Class Name")
+    new_description: Optional[str] = Field(None, title="New Description")
+    new_metadata: Optional[RobotURDFMetadataInput] = None
+
+
+class UpdateRobotRequest(BaseModel):
+    new_robot_name: Optional[str] = Field(None, title="New Robot Name")
+    new_description: Optional[str] = Field(None, title="New Description")
+
+
 class UserResponse(BaseModel):
     user_id: str = Field(..., title="User Id")
     is_admin: bool = Field(..., title="Is Admin")
@@ -71,3 +121,11 @@ class ProfileResponse(BaseModel):
     email: str = Field(..., title="Email")
     email_verified: bool = Field(..., title="Email Verified")
     user: UserResponse
+
+
+class RobotClass(BaseModel):
+    id: str = Field(..., title="Id")
+    class_name: str = Field(..., title="Class Name")
+    description: str = Field(..., title="Description")
+    user_id: str = Field(..., title="User Id")
+    metadata: Optional[RobotURDFMetadataOutput] = None

{kscale-0.2.2.dist-info → kscale-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: kscale
-Version: 0.2.2
+Version: 0.3.1
 Summary: The kscale project
 Home-page: https://github.com/kscalelabs/kscale
 Author: Benjamin Bolte

{kscale-0.2.2.dist-info → kscale-0.3.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-kscale/__init__.py,sha256=A1hh6cfKSMUSIDxYuPny2OkMm4-WcRlZsRYow_TO9Vo,200
+kscale/__init__.py,sha256=-OcBAUjdp5FhyUODsZsnOZVo757_jut66wsb_MEGq7Y,200
 kscale/cli.py,sha256=PMHLKR5UwdbbReVmqHXpJ-K9-mGHv_0I7KQkwxmFcUA,881
 kscale/conf.py,sha256=dm35XSnzJp93St-ixVtYN4Nvqvb5upPGBrWkSI6Yb-4,1743
 kscale/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -15,20 +15,20 @@ kscale/web/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kscale/web/utils.py,sha256=Mme-FAQ0_zbjjOQeX8wyq8F4kL4i9fH7ytri16U6qOA,1046
 kscale/web/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kscale/web/cli/robot.py,sha256=rI-A4_0uvJPeA71Apl4Z3mV5fIfWkgmzT9JRmJYxz3A,3307
-kscale/web/cli/robot_class.py,sha256=8igY6oWUDafb644QzmqC5cX6Az0rNJau_jvLr7YkCd0,3573
+kscale/web/cli/robot_class.py,sha256=3cCn1fvwgtPE80SJnqJcU3bbi1obyob7NVrUqzWwTJ8,17357
 kscale/web/cli/token.py,sha256=1rFC8MYKtqbNsQa2KIqwW1tqpaMtFaxuNsallwejXTU,787
 kscale/web/cli/user.py,sha256=aaJJCL1P5lfhK6ZC9OwOHXKA-I3MWqVZ_k7TYnx33CY,1303
 kscale/web/clients/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kscale/web/clients/base.py,sha256=uovIxtkotRxrIFL0PhLYDIhhfXrIGjXxNY2FLVO3L18,15110
+kscale/web/clients/base.py,sha256=A70BF9ZnHEBds0RKrowbeUNsX_WwsgV349csUlM4iMc,15174
 kscale/web/clients/client.py,sha256=rzW2s8T7bKVuybOSQ65-ghl02rcXBoOxnx_nUDwgEPw,362
-kscale/web/clients/robot.py,sha256=HMfJnkDxaJ_o7X2vdYYS9iob1JRoBG2qiGmQpCQZpAk,1485
-kscale/web/clients/robot_class.py,sha256=zCFL-Y_jIfO9_qOwzBAHzfgFxzpltMte4LM5haCC24U,6385
+kscale/web/clients/robot.py,sha256=PI8HHkU-4Re9I5rLpp6dGbekRE-rBNVfXZxR_mO2MqE,1485
+kscale/web/clients/robot_class.py,sha256=G8Nk6V7LGJE9Wpg9tyyCkIfz1fRTsxXQRgHtleiUVqo,6834
 kscale/web/clients/user.py,sha256=jsa1_s6qXRM-AGBbHlPhd1NierUtynjY9tVAPNr6_Os,568
 kscale/web/gen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kscale/web/gen/api.py,sha256=SovcII36JFgK9jd2CXlLPMjiUROGB4vEnapOsYMUrkU,2188
-kscale-0.2.2.dist-info/LICENSE,sha256=HCN2bImAzUOXldAZZI7JZ9PYq6OwMlDAP_PpX1HnuN0,1071
-kscale-0.2.2.dist-info/METADATA,sha256=c0duCLdAcxXv6SXhRpkoSO99-ahyAwV2HRhYiBZXK1k,2340
-kscale-0.2.2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-kscale-0.2.2.dist-info/entry_points.txt,sha256=N_0pCpPnwGDYVzOeuaSOrbJkS5L3lS9d8CxpJF1f8UI,62
-kscale-0.2.2.dist-info/top_level.txt,sha256=C2ynjYwopg6YjgttnI2dJjasyq3EKNmYp-IfQg9Xms4,7
-kscale-0.2.2.dist-info/RECORD,,
+kscale/web/gen/api.py,sha256=PMxBujxwL65yTFL8YIfZXWvcTRsENG0xkmG7kcmfRlw,4224
+kscale-0.3.1.dist-info/LICENSE,sha256=HCN2bImAzUOXldAZZI7JZ9PYq6OwMlDAP_PpX1HnuN0,1071
+kscale-0.3.1.dist-info/METADATA,sha256=i5_QyJOBwLagAjazc2VtkhuAgaxiUfwYKDHGsEnzCYY,2340
+kscale-0.3.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+kscale-0.3.1.dist-info/entry_points.txt,sha256=N_0pCpPnwGDYVzOeuaSOrbJkS5L3lS9d8CxpJF1f8UI,62
+kscale-0.3.1.dist-info/top_level.txt,sha256=C2ynjYwopg6YjgttnI2dJjasyq3EKNmYp-IfQg9Xms4,7
+kscale-0.3.1.dist-info/RECORD,,