k7-sdk 0.2.0__py3-none-any.whl

k7_sdk/__init__.py

@@ -0,0 +1,11 @@
+"""K7 Python SDK — HTTP client for the k7 API."""
+
+from .client import AsyncClient, Client, SandboxProxy
+
+__all__ = [
+    "Client",
+    "AsyncClient",
+    "SandboxProxy",
+]
+
+__version__ = "0.2.0"

k7_sdk/client.py

@@ -0,0 +1,550 @@
+from __future__ import annotations
+
+import requests
+
+try:
+    import httpx  # optional dependency for async client
+except Exception:  # pragma: no cover
+    httpx = None
+
+
+class SandboxProxy:
+    """Proxy object for sandbox operations."""
+
+    def __init__(self, name: str, namespace: str, client: Client):
+        self.name = name
+        self.namespace = namespace
+        self._client = client
+
+    def exec(self, code: str) -> dict:
+        """Execute code in the sandbox."""
+        return self._client._exec_command(self.name, code, self.namespace)
+
+    def delete(self) -> dict:
+        """Delete this sandbox."""
+        return self._client.delete(self.name, self.namespace)
+
+    def pause(self, snapshot: str | None = None) -> dict:
+        """Pause this sandbox (scale to 0), optionally with a VolumeSnapshot.
+
+        Pass ``snapshot="my-snap"`` to create a crash-consistent
+        ``VolumeSnapshot`` of the sandbox's root PVC before scaling to 0.
+        """
+        return self._client.pause(self.name, namespace=self.namespace, snapshot=snapshot)
+
+    def resume(self) -> dict:
+        """Resume this sandbox (scale back to 1)."""
+        return self._client.resume(self.name, namespace=self.namespace)
+
+    def fork(self, new_name: str, snapshot: str | None = None) -> SandboxProxy:
+        """Fork this sandbox into ``new_name``; returns a proxy for the new sandbox.
+
+        Blocks until the cloned PVC is bound (the server-side `fork_sandbox`
+        waits for the new pod to schedule before returning).
+        """
+        return self._client.fork(self.name, new_name, namespace=self.namespace, snapshot=snapshot)
+
+    def snapshot(self, snapshot_name: str) -> dict:
+        """Snapshot this sandbox's root PVC without pausing it (kind=named)."""
+        return self._client.create_snapshot(self.name, snapshot_name, namespace=self.namespace)
+
+    def logs(self, tail: int = 200, container: str = "sandbox", since: int = 0) -> str:
+        """Return a snapshot of this sandbox's pod logs."""
+        return self._client.logs(self.name, namespace=self.namespace, container=container, tail=tail, since=since)
+
+
+class Client:
+    """K7 Python SDK Client."""
+
+    def __init__(self, endpoint: str, api_key: str, verify_ssl: bool = True):
+        self.base_url = endpoint.rstrip("/")
+        self.api_key = api_key
+        self.session = requests.Session()
+        self.session.headers.update({"X-API-Key": api_key})
+        self.session.verify = verify_ssl
+
+    def _unwrap(self, response) -> dict:
+        data = response.json()
+        if isinstance(data, dict) and "data" in data:
+            return data["data"]
+        return data
+
+    def create(self, sandbox_config: dict) -> SandboxProxy:
+        """Create a new sandbox and return a proxy object."""
+        response = self.session.post(f"{self.base_url}/api/v1/sandboxes", json=sandbox_config)
+        response.raise_for_status()
+
+        name = sandbox_config.get("name")
+        namespace = sandbox_config.get("namespace", "default")
+
+        return SandboxProxy(name, namespace, self)
+
+    def list(self, namespace: str | None = None) -> list[dict]:
+        """List all sandboxes."""
+        params = {"namespace": namespace} if namespace else {}
+        response = self.session.get(f"{self.base_url}/api/v1/sandboxes", params=params)
+        response.raise_for_status()
+        return self._unwrap(response)
+
+    def delete(self, name: str, namespace: str = "default") -> dict:
+        """Delete a sandbox."""
+        response = self.session.delete(f"{self.base_url}/api/v1/sandboxes/{name}", params={"namespace": namespace})
+        response.raise_for_status()
+        return self._unwrap(response)
+
+    def delete_all(self, namespace: str = "default") -> dict:
+        """Delete all sandboxes in a namespace."""
+        response = self.session.delete(f"{self.base_url}/api/v1/sandboxes", params={"namespace": namespace})
+        response.raise_for_status()
+        return self._unwrap(response)
+
+    def install(
+        self,
+        playbook: str | None = None,
+        inventory: str | None = None,
+        verbose: bool = False,
+    ) -> dict:
+        """Install K7 on target hosts."""
+        response = self.session.post(
+            f"{self.base_url}/api/v1/install",
+            json={"playbook": playbook, "inventory": inventory, "verbose": verbose},
+        )
+        response.raise_for_status()
+        return self._unwrap(response)
+
+    def get_metrics(self, namespace: str | None = None) -> dict:
+        """Get resource usage metrics for sandboxes."""
+        params = {"namespace": namespace} if namespace else {}
+        response = self.session.get(f"{self.base_url}/api/v1/sandboxes/metrics", params=params)
+        response.raise_for_status()
+        return self._unwrap(response)
+
+    def nodes_storage(self) -> dict:
+        """Per-node storage-pool utilization (kfd thin-pool + k7d disks).
+
+        Returns a map of node name → ``{kata_thinpool, k7d_disks}`` (or
+        ``{error: ...}`` when that node's agent is unreachable).
+        """
+        response = self.session.get(f"{self.base_url}/api/v1/nodes/storage", timeout=120)
+        response.raise_for_status()
+        return self._unwrap(response)
+
+    def pause(
+        self,
+        name: str,
+        namespace: str = "default",
+        snapshot: str | None = None,
+    ) -> dict:
+        """Pause a sandbox (scale to 0), optionally taking a Longhorn VolumeSnapshot.
+
+        ``snapshot``, when set, names a crash-consistent VolumeSnapshot taken
+        of the sandbox's root PVC. The PVC name and ``VolumeSnapshotClass``
+        are derived server-side (kata-qemu-longhorn convention + the playbook's
+        ``longhorn`` class).
+        """
+        body: dict = {"namespace": namespace}
+        if snapshot is not None:
+            body["snapshot"] = snapshot
+        response = self.session.post(f"{self.base_url}/api/v1/sandboxes/{name}/pause", json=body, timeout=120)
+        response.raise_for_status()
+        return self._unwrap(response)
+
+    def resume(self, name: str, namespace: str = "default") -> dict:
+        """Resume a paused sandbox (scale back to 1)."""
+        response = self.session.post(
+            f"{self.base_url}/api/v1/sandboxes/{name}/resume",
+            json={"namespace": namespace},
+            timeout=30,
+        )
+        response.raise_for_status()
+        return self._unwrap(response)
+
+    def fork(
+        self,
+        source: str,
+        new_name: str,
+        namespace: str = "default",
+        snapshot: str | None = None,
+    ) -> SandboxProxy:
+        """Fork ``source`` into a new sandbox ``new_name``; returns a proxy for it.
+
+        Blocks until the cloned PVC is bound. Today this takes ~45s for
+        kata-qemu-longhorn; the HTTP request stays open for the duration.
+        """
+        body: dict = {"new_name": new_name, "namespace": namespace}
+        if snapshot is not None:
+            body["snapshot"] = snapshot
+        response = self.session.post(f"{self.base_url}/api/v1/sandboxes/{source}/fork", json=body, timeout=600)
+        response.raise_for_status()
+        self._unwrap(response)
+        return SandboxProxy(new_name, namespace, self)
+
+    # ------------------------------------------------------------------
+    # Spec 10e: VolumeSnapshot CRUD + GC.
+    # ------------------------------------------------------------------
+
+    def list_snapshots(
+        self,
+        namespace: str = "default",
+        all_namespaces: bool = False,
+        sandbox: str | None = None,
+        kind: str | None = None,
+    ) -> list[dict]:
+        params: dict = {"namespace": namespace, "all_namespaces": str(all_namespaces).lower()}
+        if sandbox is not None:
+            params["sandbox"] = sandbox
+        if kind is not None:
+            params["kind"] = kind
+        response = self.session.get(f"{self.base_url}/api/v1/snapshots", params=params, timeout=30)
+        response.raise_for_status()
+        return self._unwrap(response)
+
+    def get_snapshot(self, name: str, namespace: str = "default") -> dict | None:
+        response = self.session.get(
+            f"{self.base_url}/api/v1/snapshots/{name}", params={"namespace": namespace}, timeout=15
+        )
+        if response.status_code == 404:
+            return None
+        response.raise_for_status()
+        return self._unwrap(response)
+
+    def create_snapshot(self, sandbox: str, snapshot_name: str, namespace: str = "default") -> dict:
+        response = self.session.post(
+            f"{self.base_url}/api/v1/sandboxes/{sandbox}/snapshot",
+            json={"snapshot_name": snapshot_name, "namespace": namespace},
+            timeout=120,
+        )
+        response.raise_for_status()
+        return self._unwrap(response)
+
+    def delete_snapshot(self, name: str, namespace: str = "default") -> dict:
+        response = self.session.delete(
+            f"{self.base_url}/api/v1/snapshots/{name}", params={"namespace": namespace}, timeout=60
+        )
+        response.raise_for_status()
+        return self._unwrap(response)
+
+    def gc_snapshots(
+        self,
+        namespace: str = "default",
+        all_namespaces: bool = False,
+        keep_fork_for: str = "10m",
+        dry_run: bool = False,
+    ) -> dict:
+        body: dict = {
+            "namespace": namespace,
+            "all_namespaces": all_namespaces,
+            "keep_fork_for": keep_fork_for,
+            "dry_run": dry_run,
+        }
+        response = self.session.post(f"{self.base_url}/api/v1/snapshots/gc", json=body, timeout=120)
+        response.raise_for_status()
+        return self._unwrap(response)
+
+    def restore(
+        self,
+        snapshot_name: str,
+        new_sandbox_name: str,
+        namespace: str = "default",
+        overrides: dict | None = None,
+        keep_snapshot: bool = True,
+    ) -> SandboxProxy:
+        """Restore a brand-new sandbox from a standalone VolumeSnapshot (Spec 10f).
+
+        ``overrides`` is a JSON-serialisable dict matching ``SandboxConfigOverrides``
+        on the server (keys: ``image``, ``backend``, ``root_disk_size``, ``sidecar``,
+        ``limits``, ``entrypoint``, ``cmd``, ``before_script``). Pass at minimum
+        ``{"image": "..."}`` if the snapshot was created before Spec 10f and
+        therefore lacks the ``k7.io/source-image`` annotation.
+
+        Returns a ``SandboxProxy`` for the new sandbox. The server-side restore
+        waits for the cloned PVC to be Bound and the Deployment to be Ready
+        before responding, so the proxy is safe to ``exec`` against immediately.
+        """
+        body: dict = {
+            "new_sandbox_name": new_sandbox_name,
+            "namespace": namespace,
+            "keep_snapshot": keep_snapshot,
+        }
+        if overrides:
+            body["overrides"] = overrides
+        response = self.session.post(
+            f"{self.base_url}/api/v1/snapshots/{snapshot_name}/restore",
+            json=body,
+            timeout=600,
+        )
+        response.raise_for_status()
+        self._unwrap(response)
+        return SandboxProxy(new_sandbox_name, namespace, self)
+
+    def exec(self, name: str, command: str, namespace: str = "default") -> dict:
+        """Execute a shell command in a sandbox; returns ``{stdout, stderr, exit_code, duration_ms}``."""
+        return self._exec_command(name, command, namespace)
+
+    def logs(
+        self,
+        name: str,
+        namespace: str = "default",
+        container: str = "sandbox",
+        tail: int = 200,
+        since: int = 0,
+    ) -> str:
+        """Return a snapshot of the sandbox pod's logs (no streaming yet).
+
+        For interactive follow today, use ``k7 --core logs --follow`` on
+        the node. Streaming support is a separate spec.
+        """
+        params: dict = {"namespace": namespace, "container": container, "tail": tail}
+        if since > 0:
+            params["since"] = since
+        response = self.session.get(
+            f"{self.base_url}/api/v1/sandboxes/{name}/logs",
+            params=params,
+            timeout=60,
+        )
+        response.raise_for_status()
+        data = self._unwrap(response)
+        if isinstance(data, dict):
+            return str(data.get("logs", ""))
+        return str(data)
+
+    def _exec_command(self, name: str, command: str, namespace: str) -> dict:
+        """Internal method to execute command in sandbox."""
+        response = self.session.post(
+            f"{self.base_url}/api/v1/sandboxes/{name}/exec",
+            json={"command": command},
+            params={"namespace": namespace},
+        )
+        response.raise_for_status()
+        return self._unwrap(response)
+
+
+class AsyncClient:
+    """K7 Python SDK Async Client."""
+
+    def __init__(
+        self,
+        endpoint: str,
+        api_key: str,
+        verify_ssl: bool = True,
+        timeout: float = 30.0,
+    ):
+        if httpx is None:
+            raise RuntimeError("httpx is required for AsyncClient. Install with `pip install httpx`.")
+        self.base_url = endpoint.rstrip("/")
+        self._client = httpx.AsyncClient(
+            base_url=self.base_url,
+            headers={"X-API-Key": api_key},
+            verify=verify_ssl,
+            timeout=timeout,
+        )
+
+    async def create(self, sandbox_config: dict) -> dict:
+        r = await self._client.post("/api/v1/sandboxes", json=sandbox_config)
+        r.raise_for_status()
+        return r.json()
+
+    async def list(self, namespace: str | None = None) -> list[dict]:
+        params = {"namespace": namespace} if namespace else {}
+        r = await self._client.get("/api/v1/sandboxes", params=params)
+        r.raise_for_status()
+        data = r.json()
+        if isinstance(data, dict) and "data" in data:
+            return data["data"]
+        return data
+
+    async def delete(self, name: str, namespace: str = "default") -> dict:
+        r = await self._client.delete(f"/api/v1/sandboxes/{name}", params={"namespace": namespace})
+        r.raise_for_status()
+        data = r.json()
+        if isinstance(data, dict) and "data" in data:
+            return data["data"]
+        return data
+
+    async def delete_all(self, namespace: str = "default") -> dict:
+        r = await self._client.delete("/api/v1/sandboxes", params={"namespace": namespace})
+        r.raise_for_status()
+        data = r.json()
+        if isinstance(data, dict) and "data" in data:
+            return data["data"]
+        return data
+
+    async def logs(
+        self,
+        name: str,
+        namespace: str = "default",
+        container: str = "sandbox",
+        tail: int = 200,
+        since: int = 0,
+    ) -> str:
+        params: dict = {"namespace": namespace, "container": container, "tail": tail}
+        if since > 0:
+            params["since"] = since
+        r = await self._client.get(f"/api/v1/sandboxes/{name}/logs", params=params, timeout=60)
+        r.raise_for_status()
+        data = r.json()
+        unwrapped = data["data"] if isinstance(data, dict) and "data" in data else data
+        if isinstance(unwrapped, dict):
+            return str(unwrapped.get("logs", ""))
+        return str(unwrapped)
+
+    async def exec(self, name: str, command: str, namespace: str = "default") -> dict:
+        r = await self._client.post(
+            f"/api/v1/sandboxes/{name}/exec",
+            json={"command": command},
+            params={"namespace": namespace},
+        )
+        r.raise_for_status()
+        data = r.json()
+        if isinstance(data, dict) and "data" in data:
+            return data["data"]
+        return data
+
+    async def get_metrics(self, namespace: str | None = None) -> dict:
+        params = {"namespace": namespace} if namespace else {}
+        r = await self._client.get("/api/v1/sandboxes/metrics", params=params)
+        r.raise_for_status()
+        data = r.json()
+        if isinstance(data, dict) and "data" in data:
+            return data["data"]
+        return data
+
+    async def nodes_storage(self) -> dict:
+        """Per-node storage-pool utilization (kfd thin-pool + k7d disks)."""
+        r = await self._client.get("/api/v1/nodes/storage", timeout=120)
+        r.raise_for_status()
+        data = r.json()
+        if isinstance(data, dict) and "data" in data:
+            return data["data"]
+        return data
+
+    async def pause(
+        self,
+        name: str,
+        namespace: str = "default",
+        snapshot: str | None = None,
+    ) -> dict:
+        body: dict = {"namespace": namespace}
+        if snapshot is not None:
+            body["snapshot"] = snapshot
+        r = await self._client.post(f"/api/v1/sandboxes/{name}/pause", json=body, timeout=120)
+        r.raise_for_status()
+        data = r.json()
+        if isinstance(data, dict) and "data" in data:
+            return data["data"]
+        return data
+
+    async def resume(self, name: str, namespace: str = "default") -> dict:
+        r = await self._client.post(
+            f"/api/v1/sandboxes/{name}/resume",
+            json={"namespace": namespace},
+            timeout=30,
+        )
+        r.raise_for_status()
+        data = r.json()
+        if isinstance(data, dict) and "data" in data:
+            return data["data"]
+        return data
+
+    async def fork(
+        self,
+        source: str,
+        new_name: str,
+        namespace: str = "default",
+        snapshot: str | None = None,
+    ) -> dict:
+        body: dict = {"new_name": new_name, "namespace": namespace}
+        if snapshot is not None:
+            body["snapshot"] = snapshot
+        r = await self._client.post(f"/api/v1/sandboxes/{source}/fork", json=body, timeout=600)
+        r.raise_for_status()
+        data = r.json()
+        if isinstance(data, dict) and "data" in data:
+            return data["data"]
+        return data
+
+    async def list_snapshots(
+        self,
+        namespace: str = "default",
+        all_namespaces: bool = False,
+        sandbox: str | None = None,
+        kind: str | None = None,
+    ) -> list[dict]:
+        params: dict = {"namespace": namespace, "all_namespaces": str(all_namespaces).lower()}
+        if sandbox is not None:
+            params["sandbox"] = sandbox
+        if kind is not None:
+            params["kind"] = kind
+        r = await self._client.get("/api/v1/snapshots", params=params, timeout=30)
+        r.raise_for_status()
+        data = r.json()
+        return data["data"] if isinstance(data, dict) and "data" in data else data
+
+    async def get_snapshot(self, name: str, namespace: str = "default") -> dict | None:
+        r = await self._client.get(f"/api/v1/snapshots/{name}", params={"namespace": namespace}, timeout=15)
+        if r.status_code == 404:
+            return None
+        r.raise_for_status()
+        data = r.json()
+        return data["data"] if isinstance(data, dict) and "data" in data else data
+
+    async def create_snapshot(self, sandbox: str, snapshot_name: str, namespace: str = "default") -> dict:
+        r = await self._client.post(
+            f"/api/v1/sandboxes/{sandbox}/snapshot",
+            json={"snapshot_name": snapshot_name, "namespace": namespace},
+            timeout=120,
+        )
+        r.raise_for_status()
+        data = r.json()
+        return data["data"] if isinstance(data, dict) and "data" in data else data
+
+    async def delete_snapshot(self, name: str, namespace: str = "default") -> dict:
+        r = await self._client.delete(f"/api/v1/snapshots/{name}", params={"namespace": namespace}, timeout=60)
+        r.raise_for_status()
+        data = r.json()
+        return data["data"] if isinstance(data, dict) and "data" in data else data
+
+    async def gc_snapshots(
+        self,
+        namespace: str = "default",
+        all_namespaces: bool = False,
+        keep_fork_for: str = "10m",
+        dry_run: bool = False,
+    ) -> dict:
+        body: dict = {
+            "namespace": namespace,
+            "all_namespaces": all_namespaces,
+            "keep_fork_for": keep_fork_for,
+            "dry_run": dry_run,
+        }
+        r = await self._client.post("/api/v1/snapshots/gc", json=body, timeout=120)
+        r.raise_for_status()
+        data = r.json()
+        return data["data"] if isinstance(data, dict) and "data" in data else data
+
+    async def restore(
+        self,
+        snapshot_name: str,
+        new_sandbox_name: str,
+        namespace: str = "default",
+        overrides: dict | None = None,
+        keep_snapshot: bool = True,
+    ) -> dict:
+        body: dict = {
+            "new_sandbox_name": new_sandbox_name,
+            "namespace": namespace,
+            "keep_snapshot": keep_snapshot,
+        }
+        if overrides:
+            body["overrides"] = overrides
+        r = await self._client.post(
+            f"/api/v1/snapshots/{snapshot_name}/restore",
+            json=body,
+            timeout=600,
+        )
+        r.raise_for_status()
+        data = r.json()
+        return data["data"] if isinstance(data, dict) and "data" in data else data
+
+    async def aclose(self):
+        await self._client.aclose()

k7_sdk-0.2.0.dist-info/METADATA

@@ -0,0 +1,512 @@
+Metadata-Version: 2.4
+Name: k7-sdk
+Version: 0.2.0
+Summary: K7 sandbox management Python SDK (HTTP client for the k7 API)
+Home-page: https://github.com/Katakate/k7
+License: Apache-2.0
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.31.0
+Provides-Extra: async
+Requires-Dist: httpx>=0.27.0; extra == "async"
+Provides-Extra: sdk-async
+Requires-Dist: httpx>=0.27.0; extra == "sdk-async"
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+<h1 align="center">k7</h1>
+
+<p align="center">
+  <b>Self-hosted secure VM sandboxes for AI compute at scale</b>
+</p>
+
+
+<p align="center">
+  <a href="https://katakate.org"><img src="https://img.shields.io/badge/website-katakate.org-orange"></a>
+  <a href="https://github.com/Katakate/k7/stargazers"><img src="https://img.shields.io/github/stars/Katakate/k7?style=social"></a>
+  <a href="https://docs.katakate.org">
+    <img src="https://img.shields.io/badge/docs-docs.katakate.org-orange" />
+  </a>
+</p>
+
+
+<p align="center">
+  <a href="https://news.ycombinator.com/item?id=45656952">
+    <img src="https://img.shields.io/badge/Show%20HN-%231%20🔥-orange" alt="Show HN #1">
+  </a>
+  <a href="assets/show-hn_nb1_post-id-45656952.png" title="Screenshot proof">📸</a>
+  <a href="https://console.dev">
+    <img src="https://img.shields.io/badge/Featured%20on-Console.dev-blue" alt="Featured on Console.dev">
+  </a>
+  <a href="assets/k7-console-dev.png" title="Screenshot proof">📸</a>
+  <a href="https://www.youtube.com/watch?v=2tgqzZvmbak">
+    <img src="https://img.shields.io/badge/GitHub%20Trending-Oct%2023%2C%202025-black?logo=github" alt="GitHub Trending (Oct 23, 2025)">
+  </a>
+</p>
+
+
+<p align="center">
+  <img src="assets/k7-cover-upgrade.png" alt="Katakate Logo" width="3600" style="vertical-align: middle;"/>
+
+</p>
+
+<p align="center">
+  <a href="https://deepwiki.com/Katakate/k7">
+    <img src="https://deepwiki.com/badge.svg" />
+  </a>
+  <a href="LICENSE"><img src="https://img.shields.io/badge/license-Apache%202.0-blue.svg"></a>
+  <img src="https://img.shields.io/badge/install%20with-apt-blue?logo=debian">
+  <img src="https://img.shields.io/pypi/v/k7-sdk">
+</p> 
+
+
+
+<p align="center">
+  <img src="assets/demo-k7.gif" alt="K7 Demo" width="900"/>
+</p>
+
+
+
+
+
+<i><b>Katakate</b></i> aims to make it easy to create, manage and orchestrate lightweight safe VM sandboxes for executing untrusted code, at scale. It is built on battle-tested VM isolation with Kata, Firecracker, QEMU, Longhorn, and Kubernetes — plus Katakate's own <i><b>k7d</b></i> runtime. It is orignally motivated by AI agents that need to run arbitrary code at scale but it is also great for:
+- Custom serverless (like AWS Fargate, but yours)
+- Hardened CI/CD runners (no Docker-in-Docker risks)
+- Blockchain execution layers for AI dApps
+
+> <b>100% open‑source</b> (Apache‑2.0). For technical support, write us at: hi@katakate.org
+
+<h3 align="left">
+The Tech Stack
+</h3>
+
+<i><b>Katakate</b></i> is built on:
+- <i><b>Kubernetes</b></i> for orchestration, with K3s which is prod-ready and a great choice for edge nodes,
+- <i><b>Kata</b></i> to encapsulate containers into light-weight virtual-machines,
+- <i><b>Firecracker</b></i> (`kfd`) for super-fast boots, light footprints and minimal attack surface (with the jailer),
+- <i><b>Devmapper Snapshotter</b></i> with <i><b>thin-pool provisioning of logical volumes</b></i> for efficient disk use across many Firecracker VMs per node,
+- <i><b>QEMU</b></i> (`kql`) via Kata when you want a fuller VMM and durable sandbox disks,
+- <i><b>Longhorn</b></i> for replicated PVC-backed root disks on the QEMU path — named snapshots, restore, disk-only fork, and cross-node mobility,
+- <i><b>k7d</b></i> — Katakate's own microVM runtime daemon (<a href="https://github.com/Katakate/k7d">katakate/k7d</a>) with VM-level warm fork (CoW disk+memory) and in-place pause/resume.
+
+<h3 align="left">
+Sandbox backends
+</h3>
+
+`k7 install --backend <kfd|kql|k7d>` provisions one or more backends per node; `k7 create --backend …` picks one per sandbox. See [docs/BACKENDS.md](docs/BACKENDS.md) for the architecture and [PERFORMANCE.md](PERFORMANCE.md) for the full measurements (Hetzner AX41 node, medians).
+
+| | `kfd` (kata-firecracker-devmapper) | `kql` (kata-qemu-longhorn) | `k7d` |
+|---|---|---|---|
+| VMM | Firecracker (Kata) | QEMU (Kata) | k7d (custom KVM VMM) |
+| RuntimeClass | `kata` | `kata-qemu` | `k7` |
+| Sandbox storage | devmapper thin-pool (needs a spare raw disk) | Longhorn PVC (replicated, persistent) | erofs images + reflink XFS + guest tmpfs |
+| Create → Ready* | not re-measured† | 17.1s | **2.1s** |
+| Named snapshot* | — | 6.5s (Longhorn, disk-only) | — (VM snapshot trees via the k7d API) |
+| Fork → usable* | — | 46.7s (disk clone + cold boot) | **~5 ms VM CoW fork**; **~2.4 s** end-to-end via k7/k8s (pod Ready + exec) |
+| Pause / resume* | scale to 0 / 1 | 1.3s / 4.1s (disk survives) | **0.2s / 0.3s (VM frozen in place, memory survives)** |
+| Docker-in-VM sidecar | ✅ (ephemeral docker data) | ✅ (persistent docker data; fastest `docker pull`) | ✅ (VM-lifetime docker data) |
+| Cross-pod persistence | ✗ | ✅ snapshots/restore | ✗ (fork carries state instead) |
+
+\* medians of 3 on one Hetzner AX41 node — methodology, ranges, and the docker-sidecar
+numbers are in [PERFORMANCE.md](PERFORMANCE.md).
+† kfd needs a spare raw disk the benchmark node didn't have; its docker-workload numbers
+are in the [PERFORMANCE.md](PERFORMANCE.md) spec-10b section.
+
+<h3 align="left">
+Also available today
+</h3>
+
+- 🛠️ Docker <code>build</code> / <code>run</code> inside VM sandboxes (docker sidecar on <b>kfd</b>, <b>kql</b>, and <b>k7d</b>; see [PERFORMANCE.md](PERFORMANCE.md))
+- ⚡ <b>Warm VM fork</b> on the k7d backend: <code>k7 fork</code> CoW-clones a running sandbox's disk <i>and memory</i> in ~5&nbsp;ms at the VMM; end-to-end through k7/Kubernetes is ~2&nbsp;s to a Ready pod
+- 🌐 Multi-node clusters (Ansible + Longhorn)
+- 🔍 Cilium CNI with FQDN egress policies
+- 📸 Pause / resume / fork / restore and <code>k7 snapshot</code> lifecycle
+- 🐍 Python SDK: <code>pip install k7-sdk</code> (<code>katakate</code> package deprecated)
+
+📋 **See [ROADMAP.md](ROADMAP.md) for upcoming work (GPU passthrough, …).**
+
+
+<p align="left" style="margin-top: 40px;  font-size: 14px;">
+   <strong>Note:</strong> Katakate is currently in <em>beta</em> and under security review. Use with caution for highly sensitive workloads.
+</p>
+
+
+# Usage
+
+For usage you need:
+- **Node(s)** that will host the VM sandboxes
+- **Client** from where to send requests
+
+We provide a:
+
+- **CLI**: to use on the node(s) directly --> `apt install k7`
+- **API**: deployed automatically by `k7 install` (toggle with `k7 api enable` / `k7 api disable`)
+- **Python SDK**: HTTP client sync/async --> `pip install k7-sdk`
+
+## Current requirements
+
+### For the node(s)
+
+- Ubuntu (amd64 or arm64) host.
+  - **`k7d` backend is amd64 / x86_64 only** (same ISA; Debian calls it `amd64`,
+    the release tarball is `*-x86_64-linux.tar.gz`). `kfd` and `kql` support
+    amd64 and arm64.
+- Hardware virtualization (KVM) available and accessible
+  - Check: `ls /dev/kvm` should exist.
+  - This is typically available on your own Linux machine.
+  - On cloud providers, it varies. 
+    - Hetzner (the only one I tested so far)  yes for their `Robot` instances only, i.e. "dedicated": robot.hetzner.com. 
+    - AWS: only `.metal` EC2 instances. 
+    - GCP: virtualization friendly, most instances, with `--enable-nested-virtualization` flag.
+    - Azure: Dv3, Ev3, Dv4, Ev4, Dv5, Ev5 (Intel/AMD x86) or Dpdsv5, Dpldsv5, Epsv5 (ARM64).
+    - DigitalOcean: Premium Intel and AMD droplets with nested virtualization enabled.
+    - Others: in general, hardware virtualization is not exposed on cloud VPS, so you'll likely want a dedicated / bare metal.
+- One raw disk (unformatted, unpartitioned) for the thin-pool that k7 will provision for efficient disk usage of sandboxes.
+  - Use `./utils/wipe-disk.sh /your/disk` to wipe a disk clean before provisioning. DANGER: destructive - it will remove data/partitions/formatting/SWRAID.
+- Ansible (for installer):
+  ```bash
+  sudo add-apt-repository universe -y
+  sudo apt update
+  sudo apt install -y ansible
+  ```
+- Docker and Docker Compose (for the API):
+  ```bash
+  curl -fsSL https://get.docker.com | sh
+  ```
+
+Already tested setups:
+  - Hetzner Robot dedicated with Ubuntu 24.04 and a **spare raw NVMe** for the `kfd` thin-pool. Dual-NVMe boxes (no third drive): install the OS on one disk only — see [tutorials/k7_hetzner_node_setup.md](tutorials/k7_hetzner_node_setup.md). (Older PDF that assumed an add-on third NVMe: [tutorials/k7_hetzner_node_setup.pdf](tutorials/k7_hetzner_node_setup.pdf).)
+
+### For the client
+
+Recent Python, or the **`k7`** CLI / **`k7-sdk`** from a Linux node or your laptop (API URL + key).
+
+#### Development on macOS
+
+The **`.deb` / PPA package is Linux-only** (amd64/arm64). On a MacBook:
+
+- **CLI from source:** `./src/k7/cli/dev.sh` (same commands as `k7`; uses `uv` + `PYTHONPATH=src`)
+- **API client from laptop:** set `K7_API_URL` and `K7_API_KEY`, then `dev.sh create` / `dev.sh list` (no `--core`)
+- **`k7 install`** targets Linux servers with KVM — run on the node or via SSH, not on macOS locally
+- **`pip install k7-sdk`** for Python scripts only
+
+Do not install the Ubuntu `.deb` on macOS.
+
+## Quick Start
+
+
+### Get your node(s) ready
+
+First install `k7` on your Linux server that will host the VMs:
+```shell
+sudo add-apt-repository ppa:katakate.org/k7
+sudo apt update
+sudo apt install k7
+```
+
+
+Then let `k7` get your node ready with everything:
+```console
+$  k7 install
+Current task: Reminder about logging out and back in for group changes
+  Installing K7 on 1 host(s)... ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 100% 0:01:41
+✅ Installation completed successfully!
+
+```
+
+Optionally pass `-v` for a verbose output.
+
+> It will also tell you which raw disk was auto-selected for the LVM thin-pool. If you prefer, specify the disk explicitly (on a dual-NVMe Hetzner box this is usually the spare, e.g. `/dev/nvme1n1`):
+> ```bash
+> k7 install --disk /dev/nvme1n1
+> ```
+
+This will install and most importantly connect together the following components (depending on `--backend`):
+- Kubernetes (K3s prod-ready distribution)
+- Kata (for container virtualization)
+- Firecracker + Jailer + devmapper thin-pool (`kfd`)
+- QEMU via Kata + Longhorn PVC-backed roots (`kql`)
+- k7d daemon + `containerd-shim-k7-v1` + RuntimeClass `k7` (`k7d`)
+
+
+Careful design: config updates will not touch your existing Docker or containerd setups. We chose to use K3s' own containerd for minimal disruption. Installation may however overwrite existing installations of K3s, Kata, Firecracker, Jailer, QEMU/Kata config, or Longhorn. 
+
+### CLI Usage
+
+You can run workloads directly from the node(s) using the CLI. To create a sandbox, just create a yaml config for it. 
+
+#### k7.yaml example:
+
+```yaml
+name: my-sandbox-123
+image: alpine:latest
+namespace: default
+
+# Optional: restrict egress (safe pattern: whitelist only your own egress proxy IP)
+egress_whitelist:
+  - "10.0.0.5/32"     # Your private egress proxy/gateway
+
+# Optional: resource limits
+limits:
+  cpu: "1"
+  memory: "1Gi"
+  ephemeral-storage: "2Gi"
+
+# Optional: run before_script inside the container once at start. Network restrictions apply after the before-script, so you can install packages here, pull git repos, etc
+before_script: |
+  apk add --no-cache git curl
+
+# Optional: load environment variables from a file. These will be available both during the before-script, and in the sandbox
+env_file: path/to/your/secrets/.env
+```
+
+
+#### Running commands
+
+
+```bash
+# Create a sandbox (uses k7.yaml in the current directory by default, but you can also pass: -f myfile.yaml)
+k7 create
+
+# Or pick a backend explicitly (kfd | kql | k7d — aliases for the full names)
+k7 create -f k7.yaml --backend k7d
+
+# List sandboxes
+k7 list
+
+# Delete a sandbox
+k7 delete my-sandbox-123
+
+# Delete all sandboxes. You can also pass a namespace
+k7 delete-all
+```
+
+#### Fork / pause / snapshot
+
+```bash
+# Warm CoW fork (disk + memory) — source must be a k7d sandbox
+k7 create -f k7.yaml --backend k7d          # name from yaml, e.g. my-sandbox-123
+k7 exec my-sandbox-123 sh -c 'echo hi > /tmp/state.txt'
+k7 fork my-sandbox-123 branch-a
+k7 exec branch-a cat /tmp/state.txt        # inherited memory + disk
+
+# Disk-only fork (cold boot from cloned PVC) — kql / kata-qemu-longhorn
+k7 create -f k7.yaml --backend kql
+k7 fork my-sandbox-123 branch-b
+# optional: pin the Longhorn VolumeSnapshot name used for the clone
+k7 fork my-sandbox-123 branch-c --snapshot my-snap
+
+# Parallel branches from one base
+for i in $(seq 0 7); do k7 fork my-sandbox-123 exp-$i & done; wait
+
+# Pause / resume (kql keeps the PVC; k7d freezes the live VM)
+k7 pause my-sandbox-123
+k7 resume my-sandbox-123
+
+# Named disk snapshot without pausing (kql)
+k7 snapshot create my-sandbox-123 my-named-snap
+```
+
+On **k7d**, the VMM fork itself is ~5&nbsp;ms; end-to-end through Kubernetes
+to a Ready pod is ~2&nbsp;s. On **kql**, fork is a Longhorn snapshot + PVC
+clone + cold boot (~45&nbsp;s). See [PERFORMANCE.md](PERFORMANCE.md) and
+[docs/BACKENDS.md](docs/BACKENDS.md).
+
+### API usage
+
+The K7 API is deployed automatically by `k7 install` as the `k7-api`
+Deployment in `kube-system`. K3s keeps it running on its own; there's no
+separate "start" step.
+
+```shell
+# Check status + endpoint
+k7 api status
+k7 api endpoint
+
+# Generate API key
+k7 generate-api-key my-key1
+
+# Temporarily disable / re-enable
+k7 api disable
+k7 api enable
+```
+
+Generating / listing / revoking keys talks to `/etc/k7/api_keys.json`, so
+those subcommands need to run on the node (typically `sudo` or `root`).
+
+
+### Python SDK Usage
+
+After your k7 API is up, usage is very simple.
+
+Install the Python SDK via:
+```shell
+pip install k7-sdk
+```
+
+Or if you want async support:
+```shell
+pip install "k7-sdk[async]"
+```
+
+The legacy `katakate` PyPI name remains as a one-release shim that re-exports `k7_sdk` with a deprecation warning.
+
+Then use with:
+```python
+from k7_sdk import Client
+
+k7 = Client(
+  endpoint='https://<your-endpoint>', 
+  api_key='your-key')
+
+# Create sandbox (pick backend: kata-firecracker-devmapper | kata-qemu-longhorn | k7d)
+sb = k7.create({
+    "name": "base",
+    "image": "alpine:latest",
+    "backend": "k7d",
+})
+
+# Execute code
+result = sb.exec('echo "Hello World" > /tmp/hi.txt && cat /tmp/hi.txt')
+print(result['stdout'])
+
+# Fork: k7d = warm CoW (disk + memory); kql = disk clone + cold boot
+branch = sb.fork("branch-a")
+print(branch.exec("cat /tmp/hi.txt")["stdout"])  # still there on k7d
+
+# Parallel exploration
+forks = [sb.fork(f"exp-{i}") for i in range(4)]
+
+# List / delete
+sandboxes = k7.list()
+sb.delete()
+```
+
+#### Async variant
+```python
+import asyncio
+from k7_sdk import AsyncClient
+
+async def main():
+    k7 = AsyncClient(
+      endpoint='https://<your-endpoint>', 
+      api_key='your-key'
+    )
+    print(await k7.list())
+    await k7.aclose()
+
+asyncio.run(main())
+```
+
+  
+### Tutorials
+
+- LangChain ReAct agent with a K7 sandbox tool
+  - Path: tutorials/langchain-react-agent
+  - Setup: copy .env.example to .env and fill K7_ENDPOINT/K7_API_KEY/OPENAI_API_KEY
+  - Run: python agent.py
+  - Try asking it anything! e.g. "List files from '/'"
+
+## Build from source
+
+
+First install make if not already available:
+```bash
+sudo add-apt-repository universe -y
+sudo apt update
+sudo apt install make
+```
+
+
+To build the `k7` CLI and API into `.deb` package:
+```shell
+make build
+```
+
+You can then install it with:
+```shell
+sudo make install
+```
+
+To uninstall later:
+```shell
+sudo make uninstall
+```
+
+Note: we recommend running `make uninstall` before reinstalling if it is not your first install, to avoid stale copies of cached files in the .deb package.
+
+
+### Build and run the API container
+
+Local dev image:
+```bash
+# Build the API image locally
+make api-build-local
+
+# Run API using local image (no pull)
+make api-run-local
+```
+
+
+### Build the k7-sdk Python SDK from source
+
+Preferred (uv):
+
+```bash
+# create env
+uv venv .venv-build
+. .venv-build/bin/activate
+
+# install directly from source in editable mode
+uv pip install -e .
+```
+
+
+## Security
+
+K7 sandboxes are hardened by default with multiple layers of security:
+
+- **VM isolation**: Kata Containers (Firecracker or QEMU) or the k7d RuntimeClass provide hardware-level isolation via lightweight VMs
+  - On `kfd`, Firecracker processes are further restricted into a chroot using the Jailer
+  - Kata's Seccomp restrictions are enabled on the Kata backends
+  - `kql` uses QEMU + Longhorn for durable, cross-node-mobile disks; `k7d` has its own CoW-fork isolation trade-offs (see k7d `SECURITY.md`)
+
+- **Linux capabilities**: All capabilities are dropped by default (`drop: ALL`) for defense-in-depth
+  - Only explicitly add back capabilities you need via `cap_add` parameter
+  - `allow_privilege_escalation` is always set to `false`
+  - Seccomp profile: `RuntimeDefault`
+
+- **Non-root execution**: Optionally run containers and pods as non-root user (UID 65532):
+  - `container_non_root`: Run the main container as non-root and disable privilege escalation
+  - `pod_non_root`: Run the entire pod as non-root with consistent filesystem ownership (UID/GID/FSGroup 65532)
+
+- **API security**:
+  - API keys stored as SHA256 hashes with timing-attack-resistant comparison
+  - Expiry enforced; last-used timestamp recorded
+  - File-based storage with 600 permissions (`/etc/k7/api_keys.json` by default)
+
+- **Network policies**: Complete network isolation for VM sandboxes
+  - **Ingress isolation**: All inter-VM communication is blocked by default to prevent sandbox-to-sandbox access
+  - **Egress lockdown**: per-sandbox allowlists — CIDRs via Kubernetes NetworkPolicy, or **FQDN / domain** allowlists via Cilium (`CiliumNetworkPolicy`; default CNI)
+  - **DNS is blocked** when egress is locked down; only entries in `egress_whitelist` (CIDR or domain) are reachable
+  - Administrative access via `kubectl exec` and `k7 shell` is preserved (uses Kubernetes API, not pod networking)
+
+More security features are on the roadmap (e.g. AppArmor).
+
+## Packaging & Releases
+
+- Layout uses `src/`:
+  - CLI, API, core live under `src/k7/`
+  - SDK under `src/k7_sdk/` (PyPI package `k7-sdk`; `src/katakate/` is a deprecation shim)
+- Root `setup.py` publishes the SDK; assets under `src/k7/` belong to the Debian CLI / API image, not the PyPI wheel.
+- User docs: `~/docs/k7/` (Mintlify). See `docs/README.md` in this repo.
+- The CLI Debian package is built via `src/k7/cli/build.sh` and produces `dist/k7_<version>_amd64.deb` and `dist/k7_<version>_arm64.deb`.
+- CI (tags `v*`) can publish the PyPI SDK and upload the `.deb` artifact.

k7_sdk-0.2.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+k7_sdk/__init__.py,sha256=I1_tE4JG0IPN_ZxLMHbayaNgBMk6sq3pF_CQ_Um-2eM,198
+k7_sdk/client.py,sha256=m_l-3TtkmErWinDTvYy_DtrwgQKDpdE-nvNVwoK0Gak,20951
+k7_sdk-0.2.0.dist-info/licenses/LICENSE,sha256=Hp2KxCkjKstZxex7Q5HUfDHekGYqDCQzObK4G9L_taw,11346
+katakate/__init__.py,sha256=laNubgO2CnBTkcDr4qkWn7Zllxj017h8yLlFTRPIVhI,400
+k7_sdk-0.2.0.dist-info/METADATA,sha256=yZh9rApF6VpYJ9ZEleVUAzD33OzXWgetaZRh58OJtsE,19039
+k7_sdk-0.2.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+k7_sdk-0.2.0.dist-info/top_level.txt,sha256=rHv5V3_UB_wnBAf4YfqLS4TgiYcGtwAhNAS9eXrQVqQ,16
+k7_sdk-0.2.0.dist-info/RECORD,,

k7_sdk-0.2.0.dist-info/WHEEL

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

k7_sdk-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,203 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Gary Becigneul
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+

k7_sdk-0.2.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+k7_sdk
+katakate

katakate/__init__.py

@@ -0,0 +1,15 @@
+"""Deprecated compatibility shim — use ``k7_sdk`` (``pip install k7-sdk``)."""
+
+from __future__ import annotations
+
+import warnings
+
+from k7_sdk import AsyncClient, Client, SandboxProxy
+
+warnings.warn(
+    "The 'katakate' package is deprecated; pip install k7-sdk and use: from k7_sdk import Client",
+    DeprecationWarning,
+    stacklevel=2,
+)
+
+__all__ = ["Client", "AsyncClient", "SandboxProxy"]