kscale 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

kscale/__init__.py

@@ -1 +1 @@
-__version__ = "0.0.1"
+__version__ = "0.0.3"

kscale/conf.py

@@ -17,21 +17,13 @@ def get_path() -> Path:
 
 @dataclass
 class StoreSettings:
-    api_key: str = field(default=II("oc.env:KSCALE_API_KEY"))
-
-    def get_api_key(self) -> str:
-        try:
-            return self.api_key
-        except AttributeError:
-            raise ValueError(
-                "API key not found! Get one here and set it as the `KSCALE_API_KEY` "
-                "environment variable: https://kscale.store/keys"
-            )
+    api_key: str = field(default=II("oc.env:KSCALE_API_KEY,"))
+    cache_dir: str = field(default=II("oc.env:KSCALE_CACHE_DIR,'~/.kscale/cache/'"))
 
 
 @dataclass
 class Settings:
-    store: StoreSettings = StoreSettings()
+    store: StoreSettings = field(default_factory=StoreSettings)
 
     def save(self) -> None:
         (dir_path := get_path()).mkdir(parents=True, exist_ok=True)

kscale/store/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.0.1"

kscale/store/cli.py

@@ -0,0 +1,35 @@
+"""Defines the top-level KOL CLI."""
+
+import argparse
+import asyncio
+from typing import Sequence
+
+from kscale.store import pybullet, urdf
+
+
+async def main(args: Sequence[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(description="K-Scale OnShape Library", add_help=False)
+    parser.add_argument(
+        "subcommand",
+        choices=[
+            "urdf",
+            "pybullet",
+        ],
+        help="The subcommand to run",
+    )
+    parsed_args, remaining_args = parser.parse_known_args(args)
+
+    match parsed_args.subcommand:
+        case "urdf":
+            await urdf.main(remaining_args)
+        case "pybullet":
+            await pybullet.main(remaining_args)
+
+
+def sync_main(args: Sequence[str] | None = None) -> None:
+    asyncio.run(main(args))
+
+
+if __name__ == "__main__":
+    # python3 -m kscale.store.cli
+    sync_main()

kscale/store/pybullet.py

@@ -0,0 +1,179 @@
+"""Simple script to interact with a URDF in PyBullet."""
+
+import argparse
+import asyncio
+import itertools
+import logging
+import math
+import time
+from pathlib import Path
+from typing import Sequence
+
+from kscale.store.urdf import download_urdf
+
+logger = logging.getLogger(__name__)
+
+
+async def main(args: Sequence[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(description="Show a URDF in PyBullet")
+    parser.add_argument("listing_id", help="Listing ID for the URDF")
+    parser.add_argument("--dt", type=float, default=0.01, help="Time step")
+    parser.add_argument("-n", "--hide-gui", action="store_true", help="Hide the GUI")
+    parser.add_argument("--no-merge", action="store_true", help="Do not merge fixed links")
+    parser.add_argument("--hide-origin", action="store_true", help="Do not show the origin")
+    parser.add_argument("--show-inertia", action="store_true", help="Visualizes the inertia frames")
+    parser.add_argument("--see-thru", action="store_true", help="Use see-through mode")
+    parser.add_argument("--show-collision", action="store_true", help="Show collision meshes")
+    parsed_args = parser.parse_args(args)
+
+    # Gets the URDF path.
+    urdf_path = await download_urdf(parsed_args.listing_id)
+
+    breakpoint()
+
+    try:
+        import pybullet as p  # type: ignore[import-not-found]
+    except ImportError:
+        raise ImportError("pybullet is required to run this script")
+
+    # Connect to PyBullet.
+    p.connect(p.GUI)
+    p.setGravity(0, 0, -9.81)
+    p.setRealTimeSimulation(0)
+
+    # Turn off panels.
+    if parsed_args.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)
+
+    # Loads the floor plane.
+    floor = p.loadURDF(str((Path(__file__).parent / "bullet" / "plane.urdf").resolve()))
+
+    # Load the robot URDF.
+    start_position = [0.0, 0.0, 1.0]
+    start_orientation = p.getQuaternionFromEuler([0.0, 0.0, 0.0])
+    flags = p.URDF_USE_INERTIA_FROM_FILE
+    if not parsed_args.no_merge:
+        flags |= p.URDF_MERGE_FIXED_LINKS
+    robot = p.loadURDF(str(urdf_path), start_position, start_orientation, flags=flags, useFixedBase=0)
+
+    # Display collision meshes as separate object.
+    if parsed_args.show_collision:
+        collision_flags = p.URDF_USE_INERTIA_FROM_FILE | p.URDF_USE_SELF_COLLISION_EXCLUDE_ALL_PARENTS
+        collision = p.loadURDF(str(urdf_path), 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=parsed_args.dt, maxNumCmdPer1ms=1000)
+
+    # Shows the origin of the robot.
+    if not parsed_args.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 parsed_args.see_thru:
+        for i in joint_ids:
+            p.changeVisualShape(robot, i, rgbaColor=[1, 1, 1, 0.5])
+
+    def draw_box(pt: list[list[float]], color: tuple[float, float, float], obj_id: int, link_id: int) -> None:
+        assert len(pt) == 8
+        assert all(len(p) == 3 for p in pt)
+
+        mapping = [1, 3, 0, 2]
+        for i in range(4):
+            p.addUserDebugLine(pt[i], pt[i + 4], color, 1, parentObjectUniqueId=obj_id, parentLinkIndex=link_id)
+            p.addUserDebugLine(pt[i], pt[mapping[i]], color, 1, parentObjectUniqueId=obj_id, parentLinkIndex=link_id)
+            p.addUserDebugLine(
+                pt[i + 4], pt[mapping[i] + 4], color, 1, parentObjectUniqueId=obj_id, parentLinkIndex=link_id
+            )
+
+    # Shows bounding boxes around each part of the robot representing the inertia frame.
+    if parsed_args.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]
+            ixx = inertia[0]
+            iyy = inertia[1]
+            izz = inertia[2]
+            box_scale_x = 0.5 * math.sqrt(6 * (izz + iyy - ixx) / mass)
+            box_scale_y = 0.5 * math.sqrt(6 * (izz + ixx - iyy) / mass)
+            box_scale_z = 0.5 * math.sqrt(6 * (ixx + iyy - izz) / mass)
+
+            half_extents = [box_scale_x, box_scale_y, box_scale_z]
+            pt = [
+                [x, y, z]
+                for x, y, z in itertools.product(
+                    [-half_extents[0], half_extents[0]],
+                    [-half_extents[1], half_extents[1]],
+                    [-half_extents[2], 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)
+
+    # Run the simulation until the user closes the window.
+    last_time = time.time()
+    prev_control_values = {k: 0.0 for k in controls}
+    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),
+            )
+
+        # Set joint positions.
+        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, parsed_args.dt - (cur_time - last_time)))
+        last_time = cur_time
+
+
+if __name__ == "__main__":
+    # python -m kscale.store.pybullet
+    asyncio.run(main())

kscale/store/urdf.py

@@ -1 +1,213 @@
 """Utility functions for managing artifacts in the K-Scale store."""
+
+import argparse
+import asyncio
+import logging
+import os
+import shutil
+import sys
+import tarfile
+from pathlib import Path
+from typing import Literal, Sequence, get_args
+
+import httpx
+import requests
+
+from kscale.conf import Settings
+from kscale.store.gen.api import UrdfResponse
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+def get_api_key() -> str:
+    api_key = Settings.load().store.api_key
+    if not api_key:
+        raise ValueError(
+            "API key not found! Get one here and set it as the `KSCALE_API_KEY` environment variable or in your "
+            "config file: https://kscale.store/keys"
+        )
+    return api_key
+
+
+def get_cache_dir() -> Path:
+    return Path(Settings.load().store.cache_dir).expanduser().resolve()
+
+
+def get_listing_dir(listing_id: str) -> Path:
+    (cache_dir := get_cache_dir() / listing_id).mkdir(parents=True, exist_ok=True)
+    return cache_dir
+
+
+def fetch_urdf_info(listing_id: str) -> UrdfResponse:
+    url = f"https://api.kscale.store/urdf/info/{listing_id}"
+    headers = {
+        "Authorization": f"Bearer {get_api_key()}",
+    }
+    response = requests.get(url, headers=headers)
+    response.raise_for_status()
+    return UrdfResponse(**response.json())
+
+
+async def download_artifact(artifact_url: str, cache_dir: Path) -> Path:
+    filename = os.path.join(cache_dir, artifact_url.split("/")[-1])
+    headers = {
+        "Authorization": f"Bearer {get_api_key()}",
+    }
+
+    if not os.path.exists(filename):
+        logger.info("Downloading artifact from %s", artifact_url)
+
+        async with httpx.AsyncClient() as client:
+            response = await client.get(artifact_url, headers=headers)
+            response.raise_for_status()
+            with open(filename, "wb") as f:
+                for chunk in response.iter_bytes(chunk_size=8192):
+                    f.write(chunk)
+            logger.info("Artifact downloaded to %s", filename)
+    else:
+        logger.info("Artifact already cached at %s", filename)
+
+    # Extract the .tgz file
+    extract_dir = cache_dir / os.path.splitext(os.path.basename(filename))[0]
+    if not extract_dir.exists():
+        logger.info("Extracting %s to %s", filename, extract_dir)
+        with tarfile.open(filename, "r:gz") as tar:
+            tar.extractall(path=extract_dir)
+    else:
+        logger.info("Artifact already extracted at %s", extract_dir)
+
+    return extract_dir
+
+
+def create_tarball(folder_path: str | Path, output_filename: str, cache_dir: Path) -> str:
+    tarball_path = os.path.join(cache_dir, output_filename)
+    with tarfile.open(tarball_path, "w:gz") as tar:
+        for root, _, files in os.walk(folder_path):
+            for file in files:
+                file_path = os.path.join(root, file)
+                arcname = os.path.relpath(file_path, start=folder_path)
+                tar.add(file_path, arcname=arcname)
+                logger.info("Added %s as %s", file_path, arcname)
+    logger.info("Created tarball %s", tarball_path)
+    return tarball_path
+
+
+async def upload_artifact(tarball_path: str, listing_id: str) -> None:
+    url = f"https://api.kscale.store/urdf/upload/{listing_id}"
+    headers = {
+        "Authorization": f"Bearer {get_api_key()}",
+    }
+
+    async with httpx.AsyncClient() as client:
+        with open(tarball_path, "rb") as f:
+            files = {"file": (f.name, f, "application/gzip")}
+            response = await client.post(url, headers=headers, files=files)
+
+            response.raise_for_status()
+
+    logger.info("Uploaded artifact to %s", url)
+
+
+async def download_urdf(listing_id: str) -> Path:
+    try:
+        urdf_info = fetch_urdf_info(listing_id)
+
+        if urdf_info.urdf is None:
+            breakpoint()
+            raise ValueError(f"No URDF found for listing {listing_id}")
+
+        artifact_url = urdf_info.urdf.url
+        return await download_artifact(artifact_url, get_listing_dir(listing_id))
+
+    except requests.RequestException:
+        logger.exception("Failed to fetch URDF info")
+        raise
+
+
+async def show_urdf_info(listing_id: str) -> None:
+    try:
+        urdf_info = fetch_urdf_info(listing_id)
+
+        if urdf_info.urdf:
+            logger.info("URDF Artifact ID: %s", urdf_info.urdf.artifact_id)
+            logger.info("URDF URL: %s", urdf_info.urdf.url)
+        else:
+            logger.info("No URDF found for listing %s", listing_id)
+    except requests.RequestException:
+        logger.exception("Failed to fetch URDF info")
+        raise
+
+
+async def upload_urdf(listing_id: str, args: Sequence[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(description="Upload a URDF artifact to the K-Scale store")
+    parser.add_argument("folder_path", help="The path to the folder containing the URDF files")
+    parsed_args = parser.parse_args(args)
+    folder_path = Path(parsed_args.folder_path).expanduser().resolve()
+
+    output_filename = f"{listing_id}.tgz"
+    tarball_path = create_tarball(folder_path, output_filename, get_listing_dir(listing_id))
+
+    try:
+        fetch_urdf_info(listing_id)
+        await upload_artifact(tarball_path, listing_id)
+    except requests.RequestException:
+        logger.exception("Failed to upload artifact")
+        raise
+
+
+async def remove_local_urdf(listing_id: str) -> None:
+    try:
+        if listing_id.lower() == "all":
+            cache_dir = get_cache_dir()
+            if cache_dir.exists():
+                logger.info("Removing all local caches at %s", cache_dir)
+                shutil.rmtree(cache_dir)
+            else:
+                logger.error("No local caches found")
+        else:
+            listing_dir = get_listing_dir(listing_id)
+            if listing_dir.exists():
+                logger.info("Removing local cache at %s", listing_dir)
+                shutil.rmtree(listing_dir)
+            else:
+                logger.error("No local cache found for listing %s", listing_id)
+
+    except Exception:
+        logger.error("Failed to remove local cache")
+        raise
+
+
+Command = Literal["download", "info", "upload", "remove-local"]
+
+
+async def main(args: Sequence[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(description="K-Scale URDF Store", add_help=False)
+    parser.add_argument("command", choices=get_args(Command), help="The command to run")
+    parser.add_argument("listing_id", help="The listing ID to operate on")
+    parsed_args, remaining_args = parser.parse_known_args(args)
+
+    command: Command = parsed_args.command
+    listing_id: str = parsed_args.listing_id
+
+    match command:
+        case "download":
+            await download_urdf(listing_id)
+
+        case "info":
+            await show_urdf_info(listing_id)
+
+        case "upload":
+            await upload_urdf(listing_id, remaining_args)
+
+        case "remove-local":
+            await remove_local_urdf(listing_id)
+
+        case _:
+            logger.error("Invalid command")
+            sys.exit(1)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

kscale-0.0.3.dist-info/METADATA

@@ -0,0 +1,52 @@
+Metadata-Version: 2.1
+Name: kscale
+Version: 0.0.3
+Summary: The kscale project
+Home-page: https://github.com/kscalelabs/kscale
+Author: Benjamin Bolte
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: omegaconf
+Requires-Dist: httpx
+Requires-Dist: requests
+Provides-Extra: dev
+Requires-Dist: black ; extra == 'dev'
+Requires-Dist: darglint ; extra == 'dev'
+Requires-Dist: mypy ; extra == 'dev'
+Requires-Dist: pytest ; extra == 'dev'
+Requires-Dist: ruff ; extra == 'dev'
+Requires-Dist: datamodel-code-generator ; extra == 'dev'
+
+<p align="center">
+  <picture>
+    <img alt="K-Scale Open Source Robotics" src="https://media.kscale.dev/kscale-open-source-header.png" style="max-width: 100%;">
+  </picture>
+</p>
+
+<div align="center">
+
+[![License](https://img.shields.io/badge/license-MIT-green)](https://github.com/kscalelabs/ksim/blob/main/LICENSE)
+[![Discord](https://img.shields.io/discord/1224056091017478166)](https://discord.gg/k5mSvCkYQh)
+[![Wiki](https://img.shields.io/badge/wiki-humanoids-black)](https://humanoids.wiki)
+<br />
+[![python](https://img.shields.io/badge/-Python_3.11-blue?logo=python&logoColor=white)](https://github.com/pre-commit/pre-commit)
+[![black](https://img.shields.io/badge/Code%20Style-Black-black.svg?labelColor=gray)](https://black.readthedocs.io/en/stable/)
+[![ruff](https://img.shields.io/badge/Linter-Ruff-red.svg?labelColor=gray)](https://github.com/charliermarsh/ruff)
+<br />
+[![Python Checks](https://github.com/kscalelabs/kscale/actions/workflows/test.yml/badge.svg)](https://github.com/kscalelabs/kscale/actions/workflows/test.yml)
+[![Publish Python Package](https://github.com/kscalelabs/kscale/actions/workflows/publish.yml/badge.svg)](https://github.com/kscalelabs/kscale/actions/workflows/publish.yml)
+
+</div>
+
+# K-Scale Command Line Interface
+
+This is a command line tool for interacting with various services provided by K-Scale Labs, such as:
+
+- [K-Scale Store](https://kscale.store/)
+
+## Installation
+
+```bash
+pip install kscale
+```

kscale-0.0.3.dist-info/RECORD

@@ -0,0 +1,15 @@
+kscale/__init__.py,sha256=4GZKi13lDTD25YBkGakhZyEQZWTER_OWQMNPoH_UM2c,22
+kscale/conf.py,sha256=dnO8qii7JeMPMdjfuxnFXURRM4krwzL404RnwDkyL2M,1441
+kscale/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kscale/store/__init__.py,sha256=sXLh7g3KC4QCFxcZGBTpG2scR7hmmBsMjq6LqRptkRg,22
+kscale/store/cli.py,sha256=8ygg_1tZzOOHJotEIgSN9pfumcriPmA31sI_FCFQiTo,859
+kscale/store/pybullet.py,sha256=y51Oc6ZjOGe38O-L-Lm6HDbgNWc-5mpeXCeXRtCUl18,7522
+kscale/store/urdf.py,sha256=0u6c2UxYlKwgUl0n3VmMSmfTqdixNP5b-hjox5mIgqM,7064
+kscale/store/gen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kscale/store/gen/api.py,sha256=7r6KvlZyB-kWKSCixc-YOtaWPy2mn0v11d2tuLlRMSc,7700
+kscale-0.0.3.dist-info/LICENSE,sha256=HCN2bImAzUOXldAZZI7JZ9PYq6OwMlDAP_PpX1HnuN0,1071
+kscale-0.0.3.dist-info/METADATA,sha256=KN2mHTYV9mkJFxYqe4u1PFkCFQkc5o-E3460k66gN_M,2028
+kscale-0.0.3.dist-info/WHEEL,sha256=Mdi9PDNwEZptOjTlUcAth7XJDFtKrHYaQMPulZeBCiQ,91
+kscale-0.0.3.dist-info/entry_points.txt,sha256=PaVs1ivqB0BBdGUsiFkxGUYjGLz05VqagxwRVwi4yV4,54
+kscale-0.0.3.dist-info/top_level.txt,sha256=C2ynjYwopg6YjgttnI2dJjasyq3EKNmYp-IfQg9Xms4,7
+kscale-0.0.3.dist-info/RECORD,,

{kscale-0.0.1.dist-info → kscale-0.0.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (72.2.0)
+Generator: setuptools (73.0.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

kscale-0.0.3.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+kscale = kscale.store.cli:sync_main

kscale/store/auth.py

@@ -1,13 +0,0 @@
-"""Defines utility functions for authenticating the K-Scale Store API."""
-
-from kscale.conf import Settings
-
-
-def get_api_key() -> str:
-    try:
-        return Settings.load().store.api_key
-    except AttributeError:
-        raise ValueError(
-            "API key not found! Get one here and set it as the `KSCALE_API_KEY` "
-            "environment variable: https://kscale.store/keys"
-        )

kscale-0.0.1.dist-info/METADATA

@@ -1,29 +0,0 @@
-Metadata-Version: 2.1
-Name: kscale
-Version: 0.0.1
-Summary: The kscale project
-Home-page: https://github.com/kscalelabs/kscale
-Author: Benjamin Bolte
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: omegaconf
-Provides-Extra: dev
-Requires-Dist: black ; extra == 'dev'
-Requires-Dist: darglint ; extra == 'dev'
-Requires-Dist: mypy ; extra == 'dev'
-Requires-Dist: pytest ; extra == 'dev'
-Requires-Dist: ruff ; extra == 'dev'
-Requires-Dist: datamodel-code-generator ; extra == 'dev'
-
-# K-Scale Command Line Interface
-
-This is a command line tool for interacting with various services provided by K-Scale Labs, such as:
-
-- [K-Scale Store](https://kscale.store/)
-
-## Installation
-
-```bash
-pip install kscale
-```

kscale-0.0.1.dist-info/RECORD

@@ -1,13 +0,0 @@
-kscale/__init__.py,sha256=sXLh7g3KC4QCFxcZGBTpG2scR7hmmBsMjq6LqRptkRg,22
-kscale/conf.py,sha256=jLGM_bn-QdbZlZyqkhEYo07iIJBsIbuA1sg93YBOqhw,1641
-kscale/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kscale/store/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kscale/store/auth.py,sha256=f84jTwrPXb5OFaY2UGfb9lNqoL1Kqac4N1Q61P2qthk,397
-kscale/store/urdf.py,sha256=QNwXe677pZm3brUStqu6LLbZrGHCQqpGYQtDOxid4WM,69
-kscale/store/gen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kscale/store/gen/api.py,sha256=7r6KvlZyB-kWKSCixc-YOtaWPy2mn0v11d2tuLlRMSc,7700
-kscale-0.0.1.dist-info/LICENSE,sha256=HCN2bImAzUOXldAZZI7JZ9PYq6OwMlDAP_PpX1HnuN0,1071
-kscale-0.0.1.dist-info/METADATA,sha256=xXZUlVlvE5Z0RGl5I-MWamdB2-Pwc3m8WeJfJEBNHkk,756
-kscale-0.0.1.dist-info/WHEEL,sha256=HiCZjzuy6Dw0hdX5R3LCFPDmFS4BWl8H-8W39XfmgX4,91
-kscale-0.0.1.dist-info/top_level.txt,sha256=C2ynjYwopg6YjgttnI2dJjasyq3EKNmYp-IfQg9Xms4,7
-kscale-0.0.1.dist-info/RECORD,,