kscale 0.3.17__tar.gz → 0.3.18__tar.gz

{kscale-0.3.17/kscale.egg-info → kscale-0.3.18}/PKG-INFO

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

{kscale-0.3.17 → kscale-0.3.18}/kscale/__init__.py

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

{kscale-0.3.17 → kscale-0.3.18}/kscale/cli.py

@@ -6,6 +6,9 @@ import click
 import colorlogging
 
 from kscale.utils.cli import recursive_help
+from kscale.web.cli.clip import cli as clip_cli
+from kscale.web.cli.group import cli as group_cli
+from kscale.web.cli.permission import cli as permission_cli
 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.user import cli as user_cli
@@ -24,6 +27,9 @@ def cli() -> None:
 cli.add_command(user_cli, "user")
 cli.add_command(robot_class_cli, "robots")
 cli.add_command(robot_cli, "robot")
+cli.add_command(clip_cli, "clips")
+cli.add_command(group_cli, "groups")
+cli.add_command(permission_cli, "permissions")
 
 if __name__ == "__main__":
     # python -m kscale.cli

kscale-0.3.18/kscale/web/cli/clip.py

@@ -0,0 +1,132 @@
+"""Defines the CLI for managing clips."""
+
+import logging
+
+import click
+from tabulate import tabulate
+
+from kscale.utils.cli import coro
+from kscale.web.clients.clip import ClipClient
+
+logger = logging.getLogger(__name__)
+
+
+@click.group()
+def cli() -> None:
+    """Manage clips."""
+    pass
+
+
+@cli.command()
+@coro
+async def list() -> None:
+    """Lists all clips for the authenticated user."""
+    client = ClipClient()
+    clips = await client.get_clips()
+    if clips:
+        # Prepare table data
+        table_data = [
+            [
+                click.style(clip.id, fg="blue"),
+                clip.description or "N/A",
+                clip.created_at.strftime("%Y-%m-%d %H:%M:%S"),
+                "N/A" if clip.num_downloads is None else f"{clip.num_downloads:,}",
+                "N/A" if clip.file_size is None else f"{clip.file_size:,} bytes",
+            ]
+            for clip in clips
+        ]
+        click.echo(
+            tabulate(
+                table_data,
+                headers=["ID", "Description", "Created", "Downloads", "Size"],
+                tablefmt="simple",
+            )
+        )
+    else:
+        click.echo(click.style("No clips found", fg="red"))
+
+
+@cli.command()
+@click.argument("clip_id")
+@coro
+async def get(clip_id: str) -> None:
+    """Get information about a specific clip."""
+    client = ClipClient()
+    clip = await client.get_clip(clip_id)
+    click.echo(f"ID: {click.style(clip.id, fg='blue')}")
+    click.echo(f"Description: {click.style(clip.description or 'N/A', fg='green')}")
+    click.echo(f"User ID: {click.style(clip.user_id, fg='yellow')}")
+    click.echo(f"Created: {clip.created_at.strftime('%Y-%m-%d %H:%M:%S')}")
+    click.echo(f"Downloads: {clip.num_downloads or 0}")
+    if clip.file_size:
+        click.echo(f"File Size: {clip.file_size:,} bytes")
+
+
+@cli.command()
+@click.option("-d", "--description", type=str, default=None, help="Description for the clip")
+@coro
+async def create(description: str | None = None) -> None:
+    """Create a new clip."""
+    async with ClipClient() as client:
+        clip = await client.create_clip(description)
+    click.echo("Clip created:")
+    click.echo(f"  ID: {click.style(clip.id, fg='blue')}")
+    click.echo(f"  Description: {click.style(clip.description or 'N/A', fg='green')}")
+    click.echo(f"  Created: {clip.created_at.strftime('%Y-%m-%d %H:%M:%S')}")
+
+
+@cli.command()
+@click.argument("clip_id")
+@click.option("-d", "--description", type=str, default=None, help="New description for the clip")
+@coro
+async def update(clip_id: str, description: str | None = None) -> None:
+    """Update a clip's metadata."""
+    async with ClipClient() as client:
+        clip = await client.update_clip(clip_id, description)
+    click.echo("Clip updated:")
+    click.echo(f"  ID: {click.style(clip.id, fg='blue')}")
+    click.echo(f"  Description: {click.style(clip.description or 'N/A', fg='green')}")
+
+
+@cli.command()
+@click.argument("clip_id")
+@click.confirmation_option(prompt="Are you sure you want to delete this clip?")
+@coro
+async def delete(clip_id: str) -> None:
+    """Delete a clip."""
+    async with ClipClient() as client:
+        await client.delete_clip(clip_id)
+    click.echo(f"Clip deleted: {click.style(clip_id, fg='red')}")
+
+
+@cli.command()
+@click.argument("clip_id")
+@click.argument("file_path", type=click.Path(exists=True))
+@coro
+async def upload(clip_id: str, file_path: str) -> None:
+    """Upload a file for a clip."""
+    async with ClipClient() as client:
+        response = await client.upload_clip(clip_id, file_path)
+    click.echo("File uploaded:")
+    click.echo(f"  Filename: {click.style(response.filename, fg='green')}")
+    click.echo(f"  Content Type: {response.content_type}")
+
+
+@cli.command()
+@click.argument("clip_id")
+@click.option("-o", "--output", type=click.Path(), help="Output file path")
+@coro
+async def download(clip_id: str, output: str | None = None) -> None:
+    """Download a clip file."""
+    async with ClipClient() as client:
+        if output:
+            output_path = await client.download_clip_to_file(clip_id, output)
+            click.echo(f"Clip downloaded to: {click.style(str(output_path), fg='green')}")
+        else:
+            download_response = await client.download_clip(clip_id)
+            click.echo(f"Download URL: {click.style(download_response.url, fg='blue')}")
+            click.echo(f"MD5 Hash: {download_response.md5_hash}")
+
+
+if __name__ == "__main__":
+    cli()

kscale-0.3.18/kscale/web/cli/group.py

@@ -0,0 +1,241 @@
+"""Defines the CLI for managing groups."""
+
+import logging
+
+import click
+from tabulate import tabulate
+
+from kscale.utils.cli import coro
+from kscale.web.clients.group import GroupClient
+
+logger = logging.getLogger(__name__)
+
+
+@click.group()
+def cli() -> None:
+    """Manage groups."""
+    pass
+
+
+@cli.command()
+@coro
+async def list() -> None:
+    """Lists all groups for the authenticated user."""
+    client = GroupClient()
+    groups = await client.get_groups()
+    if groups:
+        # Prepare table data
+        table_data = [
+            [
+                click.style(group.id, fg="blue"),
+                click.style(group.name, fg="green"),
+                group.description or "N/A",
+                group.created_at,
+                "Active" if group.is_active else "Inactive",
+            ]
+            for group in groups
+        ]
+        click.echo(
+            tabulate(
+                table_data,
+                headers=["ID", "Name", "Description", "Created", "Status"],
+                tablefmt="simple",
+            )
+        )
+    else:
+        click.echo(click.style("No groups found", fg="red"))
+
+
+@cli.command()
+@click.argument("group_id")
+@coro
+async def get(group_id: str) -> None:
+    """Get information about a specific group."""
+    client = GroupClient()
+    group = await client.get_group(group_id)
+    click.echo(f"ID: {click.style(group.id, fg='blue')}")
+    click.echo(f"Name: {click.style(group.name, fg='green')}")
+    click.echo(f"Description: {click.style(group.description or 'N/A', fg='yellow')}")
+    click.echo(f"Owner ID: {click.style(group.owner_id, fg='cyan')}")
+    click.echo(f"Created: {group.created_at}")
+    click.echo(f"Updated: {group.updated_at}")
+    click.echo(f"Status: {'Active' if group.is_active else 'Inactive'}")
+
+
+@cli.command()
+@click.argument("name")
+@click.option("-d", "--description", type=str, default=None, help="Description for the group")
+@coro
+async def create(name: str, description: str | None = None) -> None:
+    """Create a new group."""
+    async with GroupClient() as client:
+        group = await client.create_group(name, description)
+    click.echo("Group created:")
+    click.echo(f"  ID: {click.style(group.id, fg='blue')}")
+    click.echo(f"  Name: {click.style(group.name, fg='green')}")
+    click.echo(f"  Description: {click.style(group.description or 'N/A', fg='yellow')}")
+
+
+@cli.command()
+@click.argument("group_id")
+@click.option("-n", "--name", type=str, default=None, help="New name for the group")
+@click.option("-d", "--description", type=str, default=None, help="New description for the group")
+@coro
+async def update(group_id: str, name: str | None = None, description: str | None = None) -> None:
+    """Update a group's metadata."""
+    async with GroupClient() as client:
+        group = await client.update_group(group_id, name, description)
+    click.echo("Group updated:")
+    click.echo(f"  ID: {click.style(group.id, fg='blue')}")
+    click.echo(f"  Name: {click.style(group.name, fg='green')}")
+    click.echo(f"  Description: {click.style(group.description or 'N/A', fg='yellow')}")
+
+
+@cli.command()
+@click.argument("group_id")
+@click.confirmation_option(prompt="Are you sure you want to delete this group?")
+@coro
+async def delete(group_id: str) -> None:
+    """Delete a group."""
+    async with GroupClient() as client:
+        await client.delete_group(group_id)
+    click.echo(f"Group deleted: {click.style(group_id, fg='red')}")
+
+
+@cli.group()
+def membership() -> None:
+    """Manage group memberships."""
+    pass
+
+
+@membership.command("list")
+@click.argument("group_id")
+@coro
+async def list_memberships(group_id: str) -> None:
+    """List all memberships for a group."""
+    client = GroupClient()
+    memberships = await client.get_group_memberships(group_id)
+    if memberships:
+        table_data = [
+            [
+                click.style(membership.id, fg="blue"),
+                click.style(membership.user_id, fg="green"),
+                membership.status,
+                membership.requested_at,
+                membership.approved_at or "N/A",
+                membership.approved_by or "N/A",
+            ]
+            for membership in memberships
+        ]
+        click.echo(
+            tabulate(
+                table_data,
+                headers=["ID", "User ID", "Status", "Requested", "Approved", "Approved By"],
+                tablefmt="simple",
+            )
+        )
+    else:
+        click.echo(click.style("No memberships found", fg="red"))
+
+
+@membership.command("request")
+@click.argument("group_id")
+@coro
+async def request_membership(group_id: str) -> None:
+    """Request to join a group."""
+    async with GroupClient() as client:
+        membership = await client.request_group_membership(group_id)
+    click.echo("Membership request sent:")
+    click.echo(f"  ID: {click.style(membership.id, fg='blue')}")
+    click.echo(f"  Status: {membership.status}")
+
+
+@membership.command("approve")
+@click.argument("group_id")
+@click.argument("user_id")
+@coro
+async def approve_membership(group_id: str, user_id: str) -> None:
+    """Approve a membership request."""
+    async with GroupClient() as client:
+        membership = await client.approve_group_membership(group_id, user_id)
+    click.echo("Membership approved:")
+    click.echo(f"  ID: {click.style(membership.id, fg='blue')}")
+    click.echo(f"  Status: {membership.status}")
+
+
+@membership.command("reject")
+@click.argument("group_id")
+@click.argument("user_id")
+@click.confirmation_option(prompt="Are you sure you want to reject this membership?")
+@coro
+async def reject_membership(group_id: str, user_id: str) -> None:
+    """Reject a membership request."""
+    async with GroupClient() as client:
+        await client.reject_group_membership(group_id, user_id)
+    click.echo(f"Membership rejected for user: {click.style(user_id, fg='red')}")
+
+
+@cli.group()
+def share() -> None:
+    """Manage group resource sharing."""
+    pass
+
+
+@share.command("list")
+@click.argument("group_id")
+@coro
+async def list_shares(group_id: str) -> None:
+    """List all resources shared with a group."""
+    client = GroupClient()
+    shares = await client.get_group_shares(group_id)
+    if shares:
+        table_data = [
+            [
+                click.style(share.id, fg="blue"),
+                share.resource_type,
+                click.style(share.resource_id, fg="green"),
+                click.style(share.shared_by, fg="yellow"),
+                share.shared_at,
+            ]
+            for share in shares
+        ]
+        click.echo(
+            tabulate(
+                table_data,
+                headers=["ID", "Type", "Resource ID", "Shared By", "Shared At"],
+                tablefmt="simple",
+            )
+        )
+    else:
+        click.echo(click.style("No shared resources found", fg="red"))
+
+
+@share.command("add")
+@click.argument("group_id")
+@click.argument("resource_type")
+@click.argument("resource_id")
+@coro
+async def add_share(group_id: str, resource_type: str, resource_id: str) -> None:
+    """Share a resource with a group."""
+    async with GroupClient() as client:
+        share = await client.share_resource_with_group(group_id, resource_type, resource_id)
+    click.echo("Resource shared:")
+    click.echo(f"  ID: {click.style(share.id, fg='blue')}")
+    click.echo(f"  Type: {share.resource_type}")
+    click.echo(f"  Resource ID: {click.style(share.resource_id, fg='green')}")
+
+
+@share.command("remove")
+@click.argument("group_id")
+@click.argument("share_id")
+@click.confirmation_option(prompt="Are you sure you want to remove this share?")
+@coro
+async def remove_share(group_id: str, share_id: str) -> None:
+    """Remove a resource share from a group."""
+    async with GroupClient() as client:
+        await client.unshare_resource_from_group(group_id, share_id)
+    click.echo(f"Share removed: {click.style(share_id, fg='red')}")
+
+
+if __name__ == "__main__":
+    cli()

kscale-0.3.18/kscale/web/cli/permission.py

@@ -0,0 +1,110 @@
+"""Defines the CLI for managing permissions."""
+
+import logging
+
+import click
+from tabulate import tabulate
+
+from kscale.utils.cli import coro
+from kscale.web.clients.permission import PermissionClient
+
+logger = logging.getLogger(__name__)
+
+
+@click.group()
+def cli() -> None:
+    """Manage user permissions."""
+    pass
+
+
+@cli.command("list-all")
+@coro
+async def list_all_permissions() -> None:
+    """List all available permissions."""
+    client = PermissionClient()
+    permissions = await client.get_all_permissions()
+    if permissions:
+        table_data = [
+            [
+                click.style(perm.permission, fg="blue"),
+                perm.description,
+            ]
+            for perm in permissions
+        ]
+        click.echo(
+            tabulate(
+                table_data,
+                headers=["Permission", "Description"],
+                tablefmt="simple",
+            )
+        )
+    else:
+        click.echo(click.style("No permissions found", fg="red"))
+
+
+@cli.command()
+@click.option("-u", "--user-id", type=str, default="me", help="User ID (default: me)")
+@coro
+async def list(user_id: str = "me") -> None:
+    """List permissions for a user."""
+    client = PermissionClient()
+    user_perms = await client.get_user_permissions(user_id)
+
+    click.echo(f"User: {click.style(user_perms.display_name, fg='green')} ({user_perms.email})")
+    click.echo(f"User ID: {click.style(user_perms.user_id, fg='blue')}")
+    click.echo(f"Status: {'Active' if user_perms.is_active else 'Inactive'}")
+    click.echo("\nPermissions:")
+
+    if user_perms.permissions:
+        for perm in user_perms.permissions:
+            click.echo(f"  • {click.style(perm, fg='yellow')}")
+    else:
+        click.echo(click.style("  No permissions assigned", fg="red"))
+
+
+@cli.command()
+@click.argument("user_id")
+@click.argument("permissions", nargs=-1, required=True)
+@coro
+async def set(user_id: str, permissions: tuple[str, ...]) -> None:
+    """Set permissions for a user (replaces all existing permissions)."""
+    async with PermissionClient() as client:
+        user_perms = await client.update_user_permissions(user_id, list(permissions))
+
+    click.echo("Permissions updated:")
+    click.echo(f"  User: {click.style(user_perms.display_name, fg='green')}")
+    click.echo(f"  Permissions: {', '.join([click.style(p, fg='yellow') for p in user_perms.permissions])}")
+
+
+@cli.command()
+@click.argument("user_id")
+@click.argument("permission")
+@coro
+async def add(user_id: str, permission: str) -> None:
+    """Add a permission to a user."""
+    async with PermissionClient() as client:
+        user_perms = await client.add_user_permission(user_id, permission)
+
+    click.echo("Permission added:")
+    click.echo(f"  User: {click.style(user_perms.display_name, fg='green')}")
+    click.echo(f"  Added: {click.style(permission, fg='yellow')}")
+    click.echo(f"  All permissions: {', '.join([click.style(p, fg='yellow') for p in user_perms.permissions])}")
+
+
+@cli.command()
+@click.argument("user_id")
+@click.argument("permission")
+@coro
+async def remove(user_id: str, permission: str) -> None:
+    """Remove a permission from a user."""
+    async with PermissionClient() as client:
+        user_perms = await client.remove_user_permission(user_id, permission)
+
+    click.echo("Permission removed:")
+    click.echo(f"  User: {click.style(user_perms.display_name, fg='green')}")
+    click.echo(f"  Removed: {click.style(permission, fg='red')}")
+    click.echo(f"  Remaining permissions: {', '.join([click.style(p, fg='yellow') for p in user_perms.permissions])}")
+
+
+if __name__ == "__main__":
+    cli()

{kscale-0.3.17 → kscale-0.3.18}/kscale/web/cli/user.py

@@ -30,8 +30,6 @@ async def me() -> None:
                 ["Email verified", profile.email_verified],
                 ["User ID", profile.user.user_id],
                 ["Is admin", profile.user.is_admin],
-                ["Can upload", profile.user.can_upload],
-                ["Can test", profile.user.can_test],
             ],
             headers=["Key", "Value"],
             tablefmt="simple",

{kscale-0.3.17 → kscale-0.3.18}/kscale/web/clients/base.py

@@ -90,7 +90,7 @@ class BaseClient:
                 logger.info("Use KSCALE_VERBOSE_ERROR=1 to see the full error message")
                 logger.info("If this persists, please create an issue here: https://github.com/kscalelabs/kscale")
 
-            logger.error("Got error %d from the K-Scale API", error_code)
+            logger.error("Got error %d from the K-Scale API %s endpoint %s", error_code, method, url)
             if isinstance(error_json, Mapping):
                 for key, value in error_json.items():
                     logger.error("  [%s] %s", key, value)

{kscale-0.3.17 → kscale-0.3.18}/kscale/web/clients/client.py

@@ -1,6 +1,9 @@
 """Defines a unified client for the K-Scale WWW API."""
 
 from kscale.web.clients.base import BaseClient
+from kscale.web.clients.clip import ClipClient
+from kscale.web.clients.group import GroupClient
+from kscale.web.clients.permission import PermissionClient
 from kscale.web.clients.robot import RobotClient
 from kscale.web.clients.robot_class import RobotClassClient
 from kscale.web.clients.user import UserClient
@@ -10,6 +13,9 @@ class WWWClient(
     RobotClient,
     RobotClassClient,
     UserClient,
+    ClipClient,
+    GroupClient,
+    PermissionClient,
     BaseClient,
 ):
     pass

kscale-0.3.18/kscale/web/clients/clip.py

@@ -0,0 +1,118 @@
+"""Defines the client for interacting with the K-Scale clip endpoints."""
+
+import hashlib
+import logging
+from pathlib import Path
+
+import httpx
+
+from kscale.web.clients.base import BaseClient
+from kscale.web.gen.api import (
+    Clip,
+    ClipDownloadResponse,
+    ClipUploadResponse,
+)
+
+logger = logging.getLogger(__name__)
+
+UPLOAD_TIMEOUT = 300.0
+DOWNLOAD_TIMEOUT = 60.0
+
+
+class ClipClient(BaseClient):
+    async def get_clips(self) -> list[Clip]:
+        """Get all clips for the authenticated user."""
+        data = await self._request("GET", "/clips/", auth=True)
+        return [Clip.model_validate(item) for item in data]
+
+    async def get_clip(self, clip_id: str) -> Clip:
+        """Get a specific clip by ID."""
+        data = await self._request("GET", f"/clips/{clip_id}", auth=True)
+        return Clip.model_validate(data)
+
+    async def create_clip(self, description: str | None = None) -> Clip:
+        """Create a new clip."""
+        data = {}
+        if description is not None:
+            data["description"] = description
+        response_data = await self._request("POST", "/clips/", data=data, auth=True)
+        return Clip.model_validate(response_data)
+
+    async def update_clip(self, clip_id: str, new_description: str | None = None) -> Clip:
+        """Update a clip's metadata."""
+        data = {}
+        if new_description is not None:
+            data["new_description"] = new_description
+        response_data = await self._request("POST", f"/clips/{clip_id}", data=data, auth=True)
+        return Clip.model_validate(response_data)
+
+    async def delete_clip(self, clip_id: str) -> None:
+        """Delete a clip."""
+        await self._request("DELETE", f"/clips/{clip_id}", auth=True)
+
+    async def upload_clip(self, clip_id: str, file_path: str | Path) -> ClipUploadResponse:
+        """Upload a file for a clip."""
+        if not (file_path := Path(file_path)).exists():
+            raise FileNotFoundError(f"File not found: {file_path}")
+
+        # Determine content type based on file extension
+        ext = file_path.suffix.lower()
+        content_type_map = {
+            ".mp4": "video/mp4",
+            ".avi": "video/x-msvideo",
+            ".mov": "video/quicktime",
+            ".mkv": "video/x-matroska",
+            ".webm": "video/webm",
+            ".json": "application/json",
+            ".txt": "text/plain",
+        }
+        content_type = content_type_map.get(ext, "application/octet-stream")
+
+        # Get upload URL
+        data = await self._request(
+            "PUT",
+            f"/clips/{clip_id}/upload",
+            data={"filename": file_path.name, "content_type": content_type},
+            auth=True,
+        )
+        response = ClipUploadResponse.model_validate(data)
+
+        # Upload the file
+        async with httpx.AsyncClient(timeout=httpx.Timeout(UPLOAD_TIMEOUT)) as client:
+            async with client.stream(
+                "PUT",
+                response.url,
+                content=file_path.read_bytes(),
+                headers={"Content-Type": response.content_type},
+            ) as r:
+                r.raise_for_status()
+
+        return response
+
+    async def download_clip(self, clip_id: str) -> ClipDownloadResponse:
+        """Get download URL and metadata for a clip."""
+        data = await self._request("GET", f"/clips/{clip_id}/download", auth=True)
+        return ClipDownloadResponse.model_validate(data)
+
+    async def download_clip_to_file(self, clip_id: str, output_path: str | Path) -> Path:
+        """Download a clip to a local file."""
+        download_response = await self.download_clip(clip_id)
+        output_path = Path(output_path)
+
+        async with httpx.AsyncClient(timeout=httpx.Timeout(DOWNLOAD_TIMEOUT)) as client:
+            async with client.stream("GET", download_response.url) as response:
+                response.raise_for_status()
+                with output_path.open("wb") as f:
+                    async for chunk in response.aiter_bytes():
+                        f.write(chunk)
+
+        # Verify download integrity if hash is provided
+        if download_response.md5_hash:
+            with output_path.open("rb") as f:
+                file_hash = hashlib.md5(f.read()).hexdigest()
+                if file_hash != download_response.md5_hash:
+                    raise ValueError(
+                        f"Downloaded file hash mismatch: expected {download_response.md5_hash}, got {file_hash}"
+                    )
+
+        return output_path

kscale-0.3.18/kscale/web/clients/group.py

@@ -0,0 +1,85 @@
+"""Defines the client for interacting with the K-Scale group endpoints."""
+
+from kscale.web.clients.base import BaseClient
+from kscale.web.gen.api import (
+    GroupMembershipResponse,
+    GroupResponse,
+    GroupShareResponse,
+)
+
+
+class GroupClient(BaseClient):
+    async def get_groups(self) -> list[GroupResponse]:
+        """Get all groups for the authenticated user."""
+        data = await self._request("GET", "/groups/", auth=True)
+        return [GroupResponse.model_validate(item) for item in data]
+
+    async def get_group(self, group_id: str) -> GroupResponse:
+        """Get a specific group by ID."""
+        data = await self._request("GET", f"/groups/{group_id}", auth=True)
+        return GroupResponse.model_validate(data)
+
+    async def create_group(self, name: str, description: str | None = None) -> GroupResponse:
+        """Create a new group."""
+        data = {"name": name}
+        if description is not None:
+            data["description"] = description
+        response_data = await self._request("POST", "/groups/", data=data, auth=True)
+        return GroupResponse.model_validate(response_data)
+
+    async def update_group(
+        self,
+        group_id: str,
+        name: str | None = None,
+        description: str | None = None,
+    ) -> GroupResponse:
+        """Update a group's metadata."""
+        data = {}
+        if name is not None:
+            data["name"] = name
+        if description is not None:
+            data["description"] = description
+        response_data = await self._request("POST", f"/groups/{group_id}", data=data, auth=True)
+        return GroupResponse.model_validate(response_data)
+
+    async def delete_group(self, group_id: str) -> None:
+        """Delete a group."""
+        await self._request("DELETE", f"/groups/{group_id}", auth=True)
+
+    # Group membership management
+    async def get_group_memberships(self, group_id: str) -> list[GroupMembershipResponse]:
+        """Get all memberships for a group."""
+        data = await self._request("GET", f"/groups/{group_id}/memberships", auth=True)
+        return [GroupMembershipResponse.model_validate(item) for item in data]
+
+    async def request_group_membership(self, group_id: str) -> GroupMembershipResponse:
+        """Request to join a group."""
+        data = await self._request("POST", f"/groups/{group_id}/memberships", auth=True)
+        return GroupMembershipResponse.model_validate(data)
+
+    async def approve_group_membership(self, group_id: str, user_id: str) -> GroupMembershipResponse:
+        """Approve a membership request."""
+        data = await self._request("POST", f"/groups/{group_id}/memberships/{user_id}/approve", auth=True)
+        return GroupMembershipResponse.model_validate(data)
+
+    async def reject_group_membership(self, group_id: str, user_id: str) -> None:
+        """Reject a membership request."""
+        await self._request("DELETE", f"/groups/{group_id}/memberships/{user_id}", auth=True)
+
+    # Group sharing management
+    async def get_group_shares(self, group_id: str) -> list[GroupShareResponse]:
+        """Get all resources shared with a group."""
+        data = await self._request("GET", f"/groups/{group_id}/shares", auth=True)
+        return [GroupShareResponse.model_validate(item) for item in data]
+
+    async def share_resource_with_group(
+        self, group_id: str, resource_type: str, resource_id: str
+    ) -> GroupShareResponse:
+        """Share a resource with a group."""
+        data = {"resource_type": resource_type, "resource_id": resource_id}
+        response_data = await self._request("POST", f"/groups/{group_id}/shares", data=data, auth=True)
+        return GroupShareResponse.model_validate(response_data)
+
+    async def unshare_resource_from_group(self, group_id: str, share_id: str) -> None:
+        """Remove a resource share from a group."""
+        await self._request("DELETE", f"/groups/{group_id}/shares/{share_id}", auth=True)

kscale-0.3.18/kscale/web/clients/permission.py

@@ -0,0 +1,35 @@
+"""Defines the client for interacting with the K-Scale permission endpoints."""
+
+from kscale.web.clients.base import BaseClient
+from kscale.web.gen.api import PermissionResponse, UserPermissionsResponse
+
+
+class PermissionClient(BaseClient):
+    async def get_all_permissions(self) -> list[PermissionResponse]:
+        """Get all available permissions."""
+        data = await self._request("GET", "/permissions/list")
+        return [PermissionResponse.model_validate(item) for item in data]
+
+    async def get_user_permissions(self, user_id: str = "me") -> UserPermissionsResponse:
+        """Get permissions for a specific user."""
+        data = {"user_id": user_id}
+        data = await self._request("GET", "/permissions/user", data=data, auth=True)
+        return UserPermissionsResponse.model_validate(data)
+
+    async def update_user_permissions(self, user_id: str, permissions: list[str]) -> UserPermissionsResponse:
+        """Update permissions for a user."""
+        data = {"user_id": user_id, "permissions": permissions}
+        response_data = await self._request("PUT", "/permissions/user", data=data, auth=True)
+        return UserPermissionsResponse.model_validate(response_data)
+
+    async def add_user_permission(self, user_id: str, permission: str) -> UserPermissionsResponse:
+        """Add a single permission to a user."""
+        data = {"user_id": user_id, "permission": permission}
+        response_data = await self._request("POST", "/permissions/user", data=data, auth=True)
+        return UserPermissionsResponse.model_validate(response_data)
+
+    async def remove_user_permission(self, user_id: str, permission: str) -> UserPermissionsResponse:
+        """Remove a single permission from a user."""
+        params = {"user_id": user_id, "permission": permission}
+        response_data = await self._request("DELETE", "/permissions/user", params=params, auth=True)
+        return UserPermissionsResponse.model_validate(response_data)

{kscale-0.3.17 → kscale-0.3.18}/kscale/web/gen/api.py

@@ -2,7 +2,7 @@
 
 # generated by datamodel-codegen:
 #   filename:  openapi.json
-#   timestamp: 2025-07-10T20:02:21+00:00
+#   timestamp: 2025-09-03T23:04:34+00:00
 
 from __future__ import annotations
 
@@ -24,6 +24,7 @@ class APIKey(BaseModel):
     last_used_at: Optional[datetime] = Field(None, title="Last Used At")
     expires_at: Optional[datetime] = Field(None, title="Expires At")
     is_active: Optional[bool] = Field(True, title="Is Active")
+    is_admin: Optional[bool] = Field(False, title="Is Admin")
 
 
 class APIKeyRequest(BaseModel):
@@ -78,6 +79,14 @@ class ActuatorMetadataOutput(BaseModel):
     error_gain: Optional[str] = Field(None, title="Error Gain")
 
 
+class AddClipRequest(BaseModel):
+    description: Optional[str] = Field(None, title="Description")
+
+
+class AddPermissionRequest(BaseModel):
+    permission: str = Field(..., title="Permission")
+
+
 class AddRobotClassRequest(BaseModel):
     description: Optional[str] = Field(None, title="Description")
 
@@ -111,6 +120,31 @@ class AgentUploadResponse(BaseModel):
     content_type: str = Field(..., title="Content Type")
 
 
+class Clip(BaseModel):
+    id: str = Field(..., title="Id")
+    description: Optional[str] = Field(None, title="Description")
+    user_id: str = Field(..., title="User Id")
+    created_at: datetime = Field(..., title="Created At")
+    num_downloads: Optional[int] = Field(0, title="Num Downloads")
+    file_size: Optional[int] = Field(None, title="File Size")
+
+
+class ClipDownloadResponse(BaseModel):
+    url: str = Field(..., title="Url")
+    md5_hash: str = Field(..., title="Md5 Hash")
+
+
+class ClipUploadRequest(BaseModel):
+    filename: str = Field(..., title="Filename")
+    content_type: str = Field(..., title="Content Type")
+
+
+class ClipUploadResponse(BaseModel):
+    url: str = Field(..., title="Url")
+    filename: str = Field(..., title="Filename")
+    content_type: str = Field(..., title="Content Type")
+
+
 class CreateAPIKeyRequest(BaseModel):
     name: str = Field(..., title="Name")
     permissions: List[str] = Field(..., title="Permissions")
@@ -126,6 +160,45 @@ class CreateAgentRequest(BaseModel):
     description: Optional[str] = Field(None, title="Description")
 
 
+class CreateGroupRequest(BaseModel):
+    name: str = Field(..., title="Name")
+    description: Optional[str] = Field(None, title="Description")
+
+
+class GroupMembershipResponse(BaseModel):
+    id: str = Field(..., title="Id")
+    group_id: str = Field(..., title="Group Id")
+    user_id: str = Field(..., title="User Id")
+    status: str = Field(..., title="Status")
+    requested_at: str = Field(..., title="Requested At")
+    approved_at: Optional[str] = Field(..., title="Approved At")
+    approved_by: Optional[str] = Field(..., title="Approved By")
+
+
+class GroupResponse(BaseModel):
+    id: str = Field(..., title="Id")
+    name: str = Field(..., title="Name")
+    description: Optional[str] = Field(..., title="Description")
+    owner_id: str = Field(..., title="Owner Id")
+    created_at: str = Field(..., title="Created At")
+    updated_at: str = Field(..., title="Updated At")
+    is_active: bool = Field(..., title="Is Active")
+
+
+class GroupShareRequest(BaseModel):
+    resource_type: str = Field(..., title="Resource Type")
+    resource_id: str = Field(..., title="Resource Id")
+
+
+class GroupShareResponse(BaseModel):
+    id: str = Field(..., title="Id")
+    group_id: str = Field(..., title="Group Id")
+    resource_type: str = Field(..., title="Resource Type")
+    resource_id: str = Field(..., title="Resource Id")
+    shared_by: str = Field(..., title="Shared By")
+    shared_at: str = Field(..., title="Shared At")
+
+
 class JointMetadataInput(BaseModel):
     id: Optional[int] = Field(None, title="Id")
     kp: Optional[Union[float, str]] = Field(None, title="Kp")
@@ -161,6 +234,11 @@ class OIDCInfo(BaseModel):
     client_id: str = Field(..., title="Client Id")
 
 
+class PermissionResponse(BaseModel):
+    permission: str = Field(..., title="Permission")
+    description: str = Field(..., title="Description")
+
+
 class Robot(BaseModel):
     id: str = Field(..., title="Id")
     robot_name: str = Field(..., title="Robot Name")
@@ -217,6 +295,15 @@ class UpdateAgentRequest(BaseModel):
     description: Optional[str] = Field(None, title="Description")
 
 
+class UpdateClipRequest(BaseModel):
+    new_description: Optional[str] = Field(None, title="New Description")
+
+
+class UpdateGroupRequest(BaseModel):
+    name: Optional[str] = Field(None, title="Name")
+    description: Optional[str] = Field(None, title="Description")
+
+
 class UpdateRobotClassRequest(BaseModel):
     new_class_name: Optional[str] = Field(None, title="New Class Name")
     new_description: Optional[str] = Field(None, title="New Description")
@@ -228,11 +315,21 @@ class UpdateRobotRequest(BaseModel):
     new_description: Optional[str] = Field(None, title="New Description")
 
 
+class UpdateUserPermissionsRequest(BaseModel):
+    permissions: List[str] = Field(..., title="Permissions")
+
+
+class UserPermissionsResponse(BaseModel):
+    user_id: str = Field(..., title="User Id")
+    display_name: str = Field(..., title="Display Name")
+    email: str = Field(..., title="Email")
+    permissions: List[str] = Field(..., title="Permissions")
+    is_active: bool = Field(..., title="Is Active")
+
+
 class UserResponse(BaseModel):
     user_id: str = Field(..., title="User Id")
     is_admin: bool = Field(..., title="Is Admin")
-    can_upload: bool = Field(..., title="Can Upload")
-    can_test: bool = Field(..., title="Can Test")
 
 
 class ValidationError(BaseModel):

{kscale-0.3.17 → kscale-0.3.18/kscale.egg-info}/PKG-INFO

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

{kscale-0.3.17 → kscale-0.3.18}/kscale.egg-info/SOURCES.txt

@@ -26,12 +26,18 @@ kscale/utils/cli.py
 kscale/web/__init__.py
 kscale/web/utils.py
 kscale/web/cli/__init__.py
+kscale/web/cli/clip.py
+kscale/web/cli/group.py
+kscale/web/cli/permission.py
 kscale/web/cli/robot.py
 kscale/web/cli/robot_class.py
 kscale/web/cli/user.py
 kscale/web/clients/__init__.py
 kscale/web/clients/base.py
 kscale/web/clients/client.py
+kscale/web/clients/clip.py
+kscale/web/clients/group.py
+kscale/web/clients/permission.py
 kscale/web/clients/robot.py
 kscale/web/clients/robot_class.py
 kscale/web/clients/user.py

{kscale-0.3.17 → kscale-0.3.18}/pyproject.toml

@@ -74,7 +74,6 @@ select = [
 ]
 
 ignore = [
-    "ANN101", "ANN102",
     "D101", "D102", "D103", "D104", "D105", "D106", "D107",
     "N812", "N817",
     "PLR0911", "PLR0912", "PLR0913", "PLR0915", "PLR2004",