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

kscale/__init__.py

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

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,30 @@
+"""Defines the top-level KOL CLI."""
+
+import argparse
+from typing import Sequence
+
+from kscale.store import pybullet, urdf
+
+
+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":
+            urdf.main(remaining_args)
+        case "pybullet":
+            pybullet.main(remaining_args)
+
+
+if __name__ == "__main__":
+    # python3 -m kscale.store.cli
+    main()

kscale/store/pybullet.py

@@ -0,0 +1,178 @@
+"""Simple script to interact with a URDF in PyBullet."""
+
+import argparse
+import itertools
+import logging
+import math
+import time
+from pathlib import Path
+from typing import Sequence
+
+logger = logging.getLogger(__name__)
+
+
+def main(args: Sequence[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(description="Show a URDF in PyBullet")
+    parser.add_argument("urdf", nargs="?", help="Path to the URDF file")
+    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)
+
+    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()))
+
+    urdf_path = Path("robot" if parsed_args.urdf is None else parsed_args.urdf)
+    if urdf_path.is_dir():
+        try:
+            urdf_path = next(urdf_path.glob("*.urdf"))
+        except StopIteration:
+            raise FileNotFoundError(f"No URDF files found in {urdf_path}")
+
+    # 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
+    main()

kscale/store/urdf.py

@@ -1 +1,174 @@
 """Utility functions for managing artifacts in the K-Scale store."""
+
+import argparse
+import asyncio
+import logging
+import os
+import sys
+import tarfile
+from pathlib import Path
+from typing import Literal, Sequence
+
+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 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) -> str:
+    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 = os.path.join(cache_dir, os.path.splitext(os.path.basename(filename))[0])
+    if not os.path.exists(extract_dir):
+        logger.info(f"Extracting {filename} to {extract_dir}")
+        with tarfile.open(filename, "r:gz") as tar:
+            tar.extractall(path=extract_dir)
+        logger.info("Extraction complete")
+    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)
+
+
+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", "info", "upload"],
+        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: Literal["get", "info", "upload"] = parsed_args.command
+    listing_id: str = parsed_args.listing_id
+
+    def get_listing_dir() -> Path:
+        (cache_dir := get_cache_dir() / listing_id).mkdir(parents=True, exist_ok=True)
+        return cache_dir
+
+    match command:
+        case "get":
+            try:
+                urdf_info = fetch_urdf_info(listing_id)
+
+                if urdf_info.urdf:
+                    artifact_url = urdf_info.urdf.url
+                    asyncio.run(download_artifact(artifact_url, get_listing_dir()))
+                else:
+                    logger.info("No URDF found for listing %s" % listing_id)
+            except requests.RequestException as e:
+                logger.error("Failed to fetch URDF info: %s" % e)
+                sys.exit(1)
+
+        case "info":
+            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 as e:
+                logger.error("Failed to fetch URDF info: %s" % e)
+                sys.exit(1)
+
+        case "upload":
+            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(remaining_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())
+
+            try:
+                urdf_info = fetch_urdf_info(listing_id)
+                asyncio.run(upload_artifact(tarball_path, listing_id))
+            except requests.RequestException as e:
+                logger.error("Failed to upload artifact: %s" % e)
+                sys.exit(1)
+
+        case _:
+            logger.error("Invalid command")
+            sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

kscale-0.0.2.dist-info/METADATA

@@ -0,0 +1,52 @@
+Metadata-Version: 2.1
+Name: kscale
+Version: 0.0.2
+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.2.dist-info/RECORD

@@ -0,0 +1,15 @@
+kscale/__init__.py,sha256=QvlVh4JTl3JL7jQAja76yKtT-IvF4631ASjWY1wS6AQ,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=sf6F8ZLMenNpxi9dPB6kpaUOmRdfNBcKSnAcoN7EMo0,733
+kscale/store/pybullet.py,sha256=2Pog9wPSyyhmhTJY6x5KhuUQgenpTPIvp_9wxOy9ZaU,7622
+kscale/store/urdf.py,sha256=-dp0DEMoDNIqieG9egPv_XaV7Cg0GthMI_QIYvG2Xjk,6185
+kscale/store/gen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kscale/store/gen/api.py,sha256=7r6KvlZyB-kWKSCixc-YOtaWPy2mn0v11d2tuLlRMSc,7700
+kscale-0.0.2.dist-info/LICENSE,sha256=HCN2bImAzUOXldAZZI7JZ9PYq6OwMlDAP_PpX1HnuN0,1071
+kscale-0.0.2.dist-info/METADATA,sha256=fNvMO1rM9-UfnHjp3BZ4t4FmcQ-CRPAmBDAdXRkBu-8,2028
+kscale-0.0.2.dist-info/WHEEL,sha256=Mdi9PDNwEZptOjTlUcAth7XJDFtKrHYaQMPulZeBCiQ,91
+kscale-0.0.2.dist-info/entry_points.txt,sha256=Vfj9O643497OONpgwy5UJLJ5a5Q1CfHZSuYKDB9D_GI,49
+kscale-0.0.2.dist-info/top_level.txt,sha256=C2ynjYwopg6YjgttnI2dJjasyq3EKNmYp-IfQg9Xms4,7
+kscale-0.0.2.dist-info/RECORD,,

{kscale-0.0.1.dist-info → kscale-0.0.2.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.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+kscale = kscale.store.cli: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,,