kscale 0.0.10__py3-none-any.whl → 0.1.0__py3-none-any.whl

kscale/__init__.py

@@ -1,9 +1,9 @@
 """Defines the common interface for the K-Scale Python API."""
 
-__version__ = "0.0.10"
+__version__ = "0.1.0"
 
 from pathlib import Path
 
-from kscale.api import KScale
+from kscale.api import K
 
 ROOT_DIR = Path(__file__).parent

kscale/api.py

@@ -1,14 +1,11 @@
 """Defines common functionality for the K-Scale API."""
 
-from kscale.store.api import StoreAPI
 from kscale.utils.api_base import APIBase
+from kscale.web.api import WebAPI
 
 
-class KScale(
-    StoreAPI,
+class K(
+    WebAPI,
     APIBase,
 ):
     """Defines a common interface for the K-Scale API."""
-
-    def __init__(self, api_key: str | None = None) -> None:
-        self.api_key = api_key

kscale/cli.py

@@ -0,0 +1,32 @@
+"""Defines the top-level KOL CLI."""
+
+import logging
+
+import click
+import colorlogging
+
+from kscale.utils.cli import recursive_help
+from kscale.web.cli.robot import cli as robot_cli
+from kscale.web.cli.robot_class import cli as robot_class_cli
+from kscale.web.cli.token import cli as token_cli
+from kscale.web.cli.user import cli as user_cli
+
+
+@click.group()
+def cli() -> None:
+    """Command line interface for interacting with the K-Scale web API."""
+    colorlogging.configure()
+
+    # Suppress aiohttp access logging
+    logging.getLogger("httpx").setLevel(logging.WARNING)
+    logging.getLogger("aiohttp.access").setLevel(logging.WARNING)
+
+
+cli.add_command(token_cli, "token")
+cli.add_command(user_cli, "user")
+cli.add_command(robot_class_cli, "robots")
+cli.add_command(robot_cli, "robot")
+
+if __name__ == "__main__":
+    # python -m kscale.cli
+    print(recursive_help(cli))

kscale/conf.py

@@ -8,6 +8,9 @@ from pathlib import Path
 
 from omegaconf import II, OmegaConf
 
+# This is the public API endpoint for the K-Scale WWW API.
+DEFAULT_API_ROOT = "https://api.kscale.dev"
+
 
 def get_path() -> Path:
     if "KSCALE_CONFIG_DIR" in os.environ:
@@ -16,14 +19,14 @@ def get_path() -> Path:
 
 
 @dataclass
-class StoreSettings:
-    api_key: str | None = field(default=None)
+class WWWSettings:
+    api_root: str = field(default=DEFAULT_API_ROOT)
     cache_dir: str = field(default=II("oc.env:KSCALE_CACHE_DIR,'~/.kscale/cache/'"))
 
 
 @dataclass
 class Settings:
-    store: StoreSettings = field(default_factory=StoreSettings)
+    www: WWWSettings = field(default_factory=WWWSettings)
 
     def save(self) -> None:
         (dir_path := get_path()).mkdir(parents=True, exist_ok=True)

kscale/requirements.txt

@@ -3,8 +3,24 @@
 # Configuration
 omegaconf
 email_validator
+colorlogging
 
 # HTTP requests
+aiohttp
+cryptography
 httpx
-requests
 pydantic
+pyjwt
+requests
+yarl
+
+# CLI
+aiofiles
+click
+tabulate
+
+# Async
+async-lru
+
+# K-Scale
+krec

kscale/utils/checksum.py

@@ -0,0 +1,41 @@
+"""Utility functions for file checksums."""
+
+import hashlib
+from pathlib import Path
+from typing import Tuple
+
+CHUNK_SIZE = 8192
+
+
+async def calculate_sha256(file_path: str | Path) -> Tuple[str, int]:
+    """Calculate SHA256 checksum and size of a file.
+
+    Args:
+        file_path: Path to the file
+
+    Returns:
+        Tuple of (checksum hex string, file size in bytes)
+    """
+    sha256_hash = hashlib.sha256()
+    file_size = 0
+
+    with open(file_path, "rb") as f:
+        for chunk in iter(lambda: f.read(CHUNK_SIZE), b""):
+            sha256_hash.update(chunk)
+            file_size += len(chunk)
+
+    return sha256_hash.hexdigest(), file_size
+
+
+class FileChecksum:
+    """Helper class for handling file checksums."""
+
+    @staticmethod
+    async def calculate(file_path: str | Path) -> Tuple[str, int]:
+        """Calculate SHA256 checksum and size of a file."""
+        return await calculate_sha256(file_path)
+
+    @staticmethod
+    def update_hash(hash_obj: "hashlib._Hash", chunk: bytes) -> None:
+        """Update a hash object with new data."""
+        hash_obj.update(chunk)

kscale/utils/cli.py

@@ -0,0 +1,28 @@
+"""Defines utilities for working with asyncio."""
+
+import asyncio
+import textwrap
+from functools import wraps
+from typing import Any, Callable, Coroutine, ParamSpec, TypeVar
+
+import click
+
+T = TypeVar("T")
+P = ParamSpec("P")
+
+
+def coro(f: Callable[P, Coroutine[Any, Any, T]]) -> Callable[P, T]:
+    @wraps(f)
+    def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
+        return asyncio.run(f(*args, **kwargs))
+
+    return wrapper
+
+
+def recursive_help(cmd: click.Command, parent: click.Context | None = None, indent: int = 0) -> str:
+    ctx = click.core.Context(cmd, info_name=cmd.name, parent=parent)
+    help_text = cmd.get_help(ctx)
+    commands = getattr(cmd, "commands", {})
+    for sub in commands.values():
+        help_text += recursive_help(sub, ctx, indent + 2)
+    return textwrap.indent(help_text, " " * indent)

kscale/web/api.py

@@ -0,0 +1,14 @@
+"""Defines a common interface for the K-Scale WWW API."""
+
+from kscale.utils.api_base import APIBase
+from kscale.web.clients.client import WWWClient
+from kscale.web.gen.api import ProfileResponse
+
+
+class WebAPI(APIBase):
+    async def www_client(self) -> WWWClient:
+        return WWWClient()
+
+    async def get_profile_info(self) -> ProfileResponse:
+        client = await self.www_client()
+        return await client.get_profile_info()

kscale/web/cli/robot.py

@@ -0,0 +1,100 @@
+"""Defines the CLI for getting information about robots."""
+
+import click
+from tabulate import tabulate
+
+from kscale.utils.cli import coro
+from kscale.web.clients.robot import RobotClient
+
+
+@click.group()
+def cli() -> None:
+    """Get information about robots."""
+    pass
+
+
+@cli.command()
+@coro
+async def list() -> None:
+    client = RobotClient()
+    robots = await client.get_all_robots()
+    if robots:
+        table_data = [
+            [
+                click.style(robot.id, fg="blue"),
+                click.style(robot.robot_name, fg="green"),
+                click.style(robot.class_id, fg="yellow"),
+                robot.description or "N/A",
+            ]
+            for robot in robots
+        ]
+        click.echo(tabulate(table_data, headers=["ID", "Name", "Class", "Description"], tablefmt="simple"))
+    else:
+        click.echo(click.style("No robots found", fg="red"))
+
+
+@cli.command()
+@click.option("-u", "--user-id", type=str, default="me")
+@coro
+async def user(user_id: str = "me") -> None:
+    client = RobotClient()
+    robots = await client.get_user_robots(user_id)
+    if robots:
+        table_data = [
+            [
+                click.style(robot.id, fg="blue"),
+                click.style(robot.robot_name, fg="green"),
+                click.style(robot.class_id, fg="yellow"),
+                robot.description or "N/A",
+            ]
+            for robot in robots
+        ]
+        click.echo(tabulate(table_data, headers=["ID", "Name", "Class", "Description"], tablefmt="simple"))
+    else:
+        click.echo(click.style("No robots found", fg="red"))
+
+
+@cli.command()
+@click.argument("robot_id")
+@coro
+async def id(robot_id: str) -> None:
+    client = RobotClient()
+    robot = await client.get_robot_by_id(robot_id)
+    click.echo("Robot:")
+    click.echo(f"  ID: {click.style(robot.id, fg='blue')}")
+    click.echo(f"  Name: {click.style(robot.robot_name, fg='green')}")
+    click.echo(f"  Class: {click.style(robot.class_name, fg='yellow')}")
+    click.echo(f"  Description: {click.style(robot.description or 'N/A', fg='yellow')}")
+
+
+@cli.command()
+@click.argument("robot_name")
+@coro
+async def name(robot_name: str) -> None:
+    client = RobotClient()
+    robot = await client.get_robot_by_name(robot_name)
+    click.echo("Robot:")
+    click.echo(f"  ID: {click.style(robot.id, fg='blue')}")
+    click.echo(f"  Name: {click.style(robot.robot_name, fg='green')}")
+    click.echo(f"  Class: {click.style(robot.class_name, fg='yellow')}")
+    click.echo(f"  Description: {click.style(robot.description or 'N/A', fg='yellow')}")
+
+
+@cli.command()
+@click.argument("class_name")
+@click.argument("name")
+@click.option("-c", "--class-name", type=str, required=True)
+@click.option("-d", "--description", type=str, default=None)
+@coro
+async def add(name: str, class_name: str, description: str | None = None) -> None:
+    client = RobotClient()
+    robot = await client.add_robot(name, class_name, description)
+    click.echo("Robot added:")
+    click.echo(f"  ID: {click.style(robot.id, fg='blue')}")
+    click.echo(f"  Name: {click.style(robot.robot_name, fg='green')}")
+    click.echo(f"  Class: {click.style(robot.class_name, fg='yellow')}")
+    click.echo(f"  Description: {click.style(robot.description or 'N/A', fg='yellow')}")
+
+
+if __name__ == "__main__":
+    cli()

kscale/web/cli/robot_class.py

@@ -0,0 +1,113 @@
+"""Defines the CLI for getting information about robot classes."""
+
+import logging
+
+import click
+from tabulate import tabulate
+
+from kscale.utils.cli import coro
+from kscale.web.clients.robot_class import RobotClassClient
+
+logger = logging.getLogger(__name__)
+
+
+@click.group()
+def cli() -> None:
+    """Get information about robot classes."""
+    pass
+
+
+@cli.command()
+@coro
+async def list() -> None:
+    """Lists all robot classes."""
+    client = RobotClassClient()
+    robot_classes = await client.get_robot_classes()
+    if robot_classes:
+        # Prepare table data
+        table_data = [
+            [
+                click.style(rc.id, fg="blue"),
+                click.style(rc.class_name, fg="green"),
+                rc.description or "N/A",
+            ]
+            for rc in robot_classes
+        ]
+        click.echo(tabulate(table_data, headers=["ID", "Name", "Description"], tablefmt="simple"))
+    else:
+        click.echo(click.style("No robot classes found", fg="red"))
+
+
+@cli.command()
+@click.argument("name")
+@click.option("-d", "--description", type=str, default=None)
+@coro
+async def add(
+    name: str,
+    description: str | None = None,
+) -> None:
+    """Adds a new robot class."""
+    async with RobotClassClient() as client:
+        robot_class = await client.create_robot_class(name, description)
+    click.echo("Robot class created:")
+    click.echo(f"  ID: {click.style(robot_class.id, fg='blue')}")
+    click.echo(f"  Name: {click.style(robot_class.class_name, fg='green')}")
+    click.echo(f"  Description: {click.style(robot_class.description or 'N/A', fg='yellow')}")
+
+
+@cli.command()
+@click.argument("current_name")
+@click.option("-n", "--name", type=str, default=None)
+@click.option("-d", "--description", type=str, default=None)
+@coro
+async def update(current_name: str, name: str | None = None, description: str | None = None) -> None:
+    """Updates a robot class."""
+    async with RobotClassClient() as client:
+        robot_class = await client.update_robot_class(current_name, name, description)
+    click.echo("Robot class updated:")
+    click.echo(f"  ID: {click.style(robot_class.id, fg='blue')}")
+    click.echo(f"  Name: {click.style(robot_class.class_name, fg='green')}")
+    click.echo(f"  Description: {click.style(robot_class.description or 'N/A', fg='yellow')}")
+
+
+@cli.command()
+@click.argument("name")
+@coro
+async def delete(name: str) -> None:
+    """Deletes a robot class."""
+    async with RobotClassClient() as client:
+        await client.delete_robot_class(name)
+    click.echo(f"Robot class deleted: {click.style(name, fg='red')}")
+
+
+@cli.group()
+def urdf() -> None:
+    """Handle the robot class URDF."""
+    pass
+
+
+@urdf.command()
+@click.argument("class_name")
+@click.argument("urdf_file")
+@coro
+async def upload(class_name: str, urdf_file: str) -> None:
+    """Uploads a URDF file to a robot class."""
+    async with RobotClassClient() as client:
+        response = await client.upload_robot_class_urdf(class_name, urdf_file)
+    click.echo("URDF uploaded:")
+    click.echo(f"  Filename: {click.style(response.filename, fg='green')}")
+
+
+@urdf.command()
+@click.argument("class_name")
+@click.option("--no-cache", is_flag=True, default=False)
+@coro
+async def download(class_name: str, no_cache: bool) -> None:
+    """Downloads a URDF file from a robot class."""
+    async with RobotClassClient() as client:
+        urdf_file = await client.download_robot_class_urdf(class_name, cache=not no_cache)
+    click.echo(f"URDF downloaded: {click.style(urdf_file, fg='green')}")
+
+
+if __name__ == "__main__":
+    cli()

kscale/web/cli/token.py

@@ -0,0 +1,33 @@
+"""Defines the CLI for interacting with K-Scale's OpenID Connect server."""
+
+import logging
+
+import click
+
+from kscale.utils.cli import coro
+from kscale.web.clients.base import BaseClient
+
+logger = logging.getLogger(__name__)
+
+
+@click.group()
+def cli() -> None:
+    """Retrieve an OICD token from the K-Scale authentication server."""
+    pass
+
+
+@cli.command()
+@coro
+async def get() -> None:
+    """Get a bearer token from OpenID Connect."""
+    logging.getLogger("aiohttp.access").setLevel(logging.WARNING)
+    async with BaseClient() as client:
+        try:
+            token = await client.get_bearer_token()
+            logger.info("Bearer token: %s", token)
+        except Exception:
+            logger.exception("Error getting bearer token")
+
+
+if __name__ == "__main__":
+    cli()

kscale/web/cli/user.py

@@ -0,0 +1,33 @@
+"""Defines the CLI for getting information about the current user."""
+
+import logging
+
+import click
+
+from kscale.utils.cli import coro
+from kscale.web.clients.user import UserClient
+
+logger = logging.getLogger(__name__)
+
+
+@click.group()
+def cli() -> None:
+    """Get information about the currently-authenticated user."""
+    pass
+
+
+@cli.command()
+@coro
+async def me() -> None:
+    client = UserClient()
+    profile = await client.get_profile_info()
+    logger.info("Email: %s", profile.email)
+    logger.info("Email verified: %s", profile.email_verified)
+    logger.info("User ID: %s", profile.user.user_id)
+    logger.info("Is admin: %s", profile.user.is_admin)
+    logger.info("Can upload: %s", profile.user.can_upload)
+    logger.info("Can test: %s", profile.user.can_test)
+
+
+if __name__ == "__main__":
+    cli()