jupyterhub-exec 0.1.0__tar.gz

jupyterhub_exec-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Quantiota
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

jupyterhub_exec-0.1.0/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: jupyterhub-exec
+Version: 0.1.0
+Summary: Execute code on a remote JupyterHub kernel from any terminal — zero dependencies.
+License: MIT
+Project-URL: Homepage, https://github.com/quantiota/jupyterhub-exec
+Project-URL: Repository, https://github.com/quantiota/jupyterhub-exec
+Project-URL: Issues, https://github.com/quantiota/jupyterhub-exec/issues
+Keywords: jupyterhub,jupyter,kernel,gpu,offload,agent
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: System :: Distributed Computing
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# jupyterhub-exec
+
+Execute code on a remote JupyterHub kernel from any terminal — zero external dependencies.
+
+```
+pip install jupyterhub-exec
+```
+
+## Why
+
+JupyterHub provides GPU compute. Your agent terminal does not.
+`jh-exec` bridges the two using the Jupyter kernel protocol over a raw WebSocket —
+no browser, no notebook UI, no library dependencies beyond the Python standard library.
+
+```
+┌─────────────────────────┐        WebSocket         ┌──────────────────────────┐
+│   Agent Terminal (CPU)  │ ───────────────────────► │  JupyterHub Kernel (GPU) │
+│   Claude Code / CLI     │ ◄─────────────────────── │  PyTorch / CUDA          │
+└─────────────────────────┘        stdout stream      └──────────────────────────┘
+```
+
+## Usage
+
+```bash
+# Execute a script on the remote GPU kernel
+jh-exec run train.py
+
+# Execute inline code
+jh-exec exec "import torch; print(torch.cuda.is_available())"
+
+# List running kernels
+jh-exec kernels
+
+# Start a new kernel
+jh-exec new-kernel
+```
+
+## Configuration
+
+Set via environment variables or a `.env` file in the working or home directory:
+
+```bash
+JH_HOST=192.168.1.100
+JH_PORT=8000
+JH_USER=agent-01
+JH_TOKEN=your_token_here
+JH_TIMEOUT=600
+```
+
+Or pass directly:
+
+```bash
+jh-exec --host 192.168.1.100 --user agent-01 --token your_token run script.py
+```
+
+## Python API
+
+```python
+from jh_exec import execute, list_kernels, new_kernel
+
+# Execute code, stream output to stdout
+execute("import torch; print(torch.cuda.get_device_name(0))")
+
+# List running kernels
+kernels = list_kernels()
+
+# Start a new kernel, get its ID
+kid = new_kernel()
+```
+
+## Dedicated GPU per agent
+
+In `jupyterhub_config.py`:
+
+```python
+def assign_gpu(spawner):
+    gpu_map = {
+        "agent-01": "0",
+        "agent-02": "1",
+        "agent-03": "2",
+    }
+    spawner.environment["CUDA_VISIBLE_DEVICES"] = gpu_map.get(spawner.user.name, "")
+
+c.Spawner.pre_spawn_hook = assign_gpu
+```
+
+## License
+
+MIT

jupyterhub_exec-0.1.0/README.md

@@ -0,0 +1,89 @@
+# jupyterhub-exec
+
+Execute code on a remote JupyterHub kernel from any terminal — zero external dependencies.
+
+```
+pip install jupyterhub-exec
+```
+
+## Why
+
+JupyterHub provides GPU compute. Your agent terminal does not.
+`jh-exec` bridges the two using the Jupyter kernel protocol over a raw WebSocket —
+no browser, no notebook UI, no library dependencies beyond the Python standard library.
+
+```
+┌─────────────────────────┐        WebSocket         ┌──────────────────────────┐
+│   Agent Terminal (CPU)  │ ───────────────────────► │  JupyterHub Kernel (GPU) │
+│   Claude Code / CLI     │ ◄─────────────────────── │  PyTorch / CUDA          │
+└─────────────────────────┘        stdout stream      └──────────────────────────┘
+```
+
+## Usage
+
+```bash
+# Execute a script on the remote GPU kernel
+jh-exec run train.py
+
+# Execute inline code
+jh-exec exec "import torch; print(torch.cuda.is_available())"
+
+# List running kernels
+jh-exec kernels
+
+# Start a new kernel
+jh-exec new-kernel
+```
+
+## Configuration
+
+Set via environment variables or a `.env` file in the working or home directory:
+
+```bash
+JH_HOST=192.168.1.100
+JH_PORT=8000
+JH_USER=agent-01
+JH_TOKEN=your_token_here
+JH_TIMEOUT=600
+```
+
+Or pass directly:
+
+```bash
+jh-exec --host 192.168.1.100 --user agent-01 --token your_token run script.py
+```
+
+## Python API
+
+```python
+from jh_exec import execute, list_kernels, new_kernel
+
+# Execute code, stream output to stdout
+execute("import torch; print(torch.cuda.get_device_name(0))")
+
+# List running kernels
+kernels = list_kernels()
+
+# Start a new kernel, get its ID
+kid = new_kernel()
+```
+
+## Dedicated GPU per agent
+
+In `jupyterhub_config.py`:
+
+```python
+def assign_gpu(spawner):
+    gpu_map = {
+        "agent-01": "0",
+        "agent-02": "1",
+        "agent-03": "2",
+    }
+    spawner.environment["CUDA_VISIBLE_DEVICES"] = gpu_map.get(spawner.user.name, "")
+
+c.Spawner.pre_spawn_hook = assign_gpu
+```
+
+## License
+
+MIT

jupyterhub_exec-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "jupyterhub-exec"
+version = "0.1.0"
+description = "Execute code on a remote JupyterHub kernel from any terminal — zero dependencies."
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.8"
+keywords = ["jupyterhub", "jupyter", "kernel", "gpu", "offload", "agent"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: System :: Distributed Computing",
+]
+
+[project.urls]
+Homepage = "https://github.com/quantiota/jupyterhub-exec"
+Repository = "https://github.com/quantiota/jupyterhub-exec"
+Issues = "https://github.com/quantiota/jupyterhub-exec/issues"
+
+[project.scripts]
+jh-exec = "jh_exec.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

jupyterhub_exec-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

jupyterhub_exec-0.1.0/src/jh_exec/__init__.py

@@ -0,0 +1,9 @@
+"""
+jh_exec — Execute code on a remote JupyterHub kernel from any terminal.
+"""
+
+__version__ = "0.1.0"
+
+from .client import execute, list_kernels, new_kernel, get_or_create_kernel
+
+__all__ = ["execute", "list_kernels", "new_kernel", "get_or_create_kernel"]

jupyterhub_exec-0.1.0/src/jh_exec/cli.py

@@ -0,0 +1,99 @@
+"""
+Command-line interface for jh_exec.
+"""
+
+import argparse, sys, os, pathlib
+from .client import JupyterHubClient
+from . import __version__
+
+
+def load_env(env_file=None):
+    candidates = []
+    if env_file:
+        candidates.append(pathlib.Path(env_file))
+    candidates += [pathlib.Path.cwd() / ".env", pathlib.Path.home() / ".env"]
+    for candidate in candidates:
+        if candidate.exists():
+            with open(candidate) as f:
+                for line in f:
+                    line = line.strip()
+                    if line and not line.startswith("#") and "=" in line:
+                        k, v = line.split("=", 1)
+                        os.environ.setdefault(k.strip(), v.strip())
+            break
+
+
+def build_client(args):
+    return JupyterHubClient(
+        host    = args.host    or os.getenv("JH_HOST",    "localhost"),
+        port    = args.port    or os.getenv("JH_PORT",    "8000"),
+        user    = args.user    or os.getenv("JH_USER",    ""),
+        token   = args.token   or os.getenv("JH_TOKEN",   ""),
+        timeout = args.timeout or int(os.getenv("JH_TIMEOUT", "600")),
+    )
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="jh-exec",
+        description="Execute code on a remote JupyterHub kernel from any terminal."
+    )
+    parser.add_argument("--version", action="version", version=f"jh-exec {__version__}")
+    parser.add_argument("--host",    help="JupyterHub host")
+    parser.add_argument("--port",    help="JupyterHub port (default: 8000)")
+    parser.add_argument("--user",    help="JupyterHub username")
+    parser.add_argument("--token",   help="JupyterHub API token")
+    parser.add_argument("--timeout", type=int, help="Execution timeout in seconds (default: 600)")
+    parser.add_argument("--kernel",  help="Kernel ID (auto-discovered if omitted)")
+    parser.add_argument("--env",     help="Path to .env file")
+
+    sub = parser.add_subparsers(dest="command")
+
+    # run
+    run_p = sub.add_parser("run", help="Execute a Python script file")
+    run_p.add_argument("script", help="Path to the Python script")
+
+    # exec
+    exec_p = sub.add_parser("exec", help="Execute inline Python code")
+    exec_p.add_argument("code", help="Python code to execute")
+
+    # kernels
+    sub.add_parser("kernels", help="List running kernels")
+
+    # new-kernel
+    sub.add_parser("new-kernel", help="Start a new kernel and print its ID")
+
+    args = parser.parse_args()
+
+    if args.command is None:
+        parser.print_help()
+        sys.exit(0)
+
+    load_env(args.env)
+    client = build_client(args)
+
+    if args.command == "kernels":
+        kernels = client.list_kernels()
+        if not kernels:
+            print("No running kernels.")
+        for k in kernels:
+            print(f"{k['id']}  name={k['name']}  state={k['execution_state']}  last_activity={k['last_activity']}")
+
+    elif args.command == "new-kernel":
+        kid = client.new_kernel()
+        print(kid)
+
+    elif args.command in ("run", "exec"):
+        if args.command == "run":
+            with open(args.script) as f:
+                code = f.read()
+        else:
+            code = args.code
+
+        kernel_id = args.kernel or client.get_or_create_kernel()
+        status    = client.execute(code, kernel_id=kernel_id)
+        sys.exit(0 if status == "ok" else 1)
+
+
+if __name__ == "__main__":
+    main()

jupyterhub_exec-0.1.0/src/jh_exec/client.py

@@ -0,0 +1,250 @@
+"""
+Core WebSocket client for JupyterHub kernel execution.
+Zero external dependencies — uses only Python built-ins.
+"""
+
+import socket, base64, struct, json, uuid, time, os, sys
+import urllib.request, urllib.error
+
+
+class JupyterHubClient:
+    def __init__(self, host, port, user, token, timeout=600):
+        self.host    = host
+        self.port    = int(port)
+        self.user    = user
+        self.token   = token
+        self.timeout = timeout
+
+    # ── Kernel management ────────────────────────────────────────────────────
+
+    def list_kernels(self):
+        url = f"http://{self.host}:{self.port}/user/{self.user}/api/kernels?token={self.token}"
+        with urllib.request.urlopen(url, timeout=10) as resp:
+            data = resp.read()
+        try:
+            result = json.loads(data)
+            return result if isinstance(result, list) else []
+        except json.JSONDecodeError:
+            return []
+
+    def start_server(self):
+        """Start the JupyterHub single-user server if not running."""
+        url = f"http://{self.host}:{self.port}/hub/api/users/{self.user}/server"
+        req = urllib.request.Request(
+            url, data=b"",
+            headers={"Authorization": f"token {self.token}",
+                     "Content-Type": "application/json"},
+            method="POST"
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=30) as resp:
+                return resp.status in (201, 202)
+        except urllib.error.HTTPError as e:
+            if e.code == 400:  # already running
+                return True
+            raise
+
+    def new_kernel(self, kernel_name="python3"):
+        url = f"http://{self.host}:{self.port}/user/{self.user}/api/kernels?token={self.token}"
+        req = urllib.request.Request(
+            url, data=json.dumps({"name": kernel_name}).encode(),
+            headers={"Content-Type": "application/json"}, method="POST"
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=10) as resp:
+                return json.loads(resp.read())["id"]
+        except urllib.error.HTTPError as e:
+            if e.code == 405:
+                # Single-user server not running — start it and retry
+                self.start_server()
+                time.sleep(3)
+                with urllib.request.urlopen(req, timeout=10) as resp:
+                    return json.loads(resp.read())["id"]
+            raise
+
+    def get_or_create_kernel(self, kernel_name="python3"):
+        for k in self.list_kernels():
+            if k["name"] == kernel_name:
+                return k["id"]
+        return self.new_kernel(kernel_name)
+
+    # ── WebSocket ─────────────────────────────────────────────────────────────
+
+    def _handshake(self, sock, kernel_id):
+        path = f"/user/{self.user}/api/kernels/{kernel_id}/channels?token={self.token}"
+        key  = base64.b64encode(os.urandom(16)).decode()
+        req  = (
+            f"GET {path} HTTP/1.1\r\n"
+            f"Host: {self.host}:{self.port}\r\n"
+            f"Upgrade: websocket\r\n"
+            f"Connection: Upgrade\r\n"
+            f"Sec-WebSocket-Key: {key}\r\n"
+            f"Sec-WebSocket-Version: 13\r\n"
+            f"\r\n"
+        )
+        sock.sendall(req.encode())
+        resp = b""
+        while b"\r\n\r\n" not in resp:
+            resp += sock.recv(4096)
+        if b"101" not in resp:
+            raise ConnectionError(f"WebSocket handshake failed: {resp[:200]}")
+
+    def _ws_send(self, sock, data):
+        if isinstance(data, str):
+            data = data.encode()
+        mask   = os.urandom(4)
+        masked = bytes(b ^ mask[i % 4] for i, b in enumerate(data))
+        length = len(data)
+        if length < 126:
+            header = bytes([0x81, 0x80 | length]) + mask
+        elif length < 65536:
+            header = bytes([0x81, 0xFE]) + struct.pack(">H", length) + mask
+        else:
+            header = bytes([0x81, 0xFF]) + struct.pack(">Q", length) + mask
+        sock.sendall(header + masked)
+
+    def _ws_recv(self, sock):
+        def recv_exact(n):
+            buf = b""
+            while len(buf) < n:
+                chunk = sock.recv(n - len(buf))
+                if not chunk:
+                    raise ConnectionError("Socket closed")
+                buf += chunk
+            return buf
+
+        b1, b2   = recv_exact(2)
+        opcode   = b1 & 0x0F
+        masked   = (b2 & 0x80) != 0
+        length   = b2 & 0x7F
+        if length == 126:
+            length = struct.unpack(">H", recv_exact(2))[0]
+        elif length == 127:
+            length = struct.unpack(">Q", recv_exact(8))[0]
+        mask_key = recv_exact(4) if masked else b""
+        payload  = recv_exact(length)
+        if masked:
+            payload = bytes(b ^ mask_key[i % 4] for i, b in enumerate(payload))
+        if opcode == 8:
+            return None
+        if opcode == 9:
+            self._ws_send(sock, b"")
+            return ""
+        return payload.decode("utf-8", errors="replace")
+
+    # ── Execute ───────────────────────────────────────────────────────────────
+
+    def execute(self, code, kernel_id=None, stdout=None):
+        """
+        Execute code on the kernel. Streams output to stdout (default: sys.stdout).
+        Returns the kernel execution status ('ok' or 'error').
+        """
+        if stdout is None:
+            stdout = sys.stdout
+        if kernel_id is None:
+            kernel_id = self.get_or_create_kernel()
+
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.connect((self.host, self.port))
+        sock.settimeout(self.timeout)
+
+        self._handshake(sock, kernel_id)
+
+        msg_id = str(uuid.uuid4())
+        execute_msg = {
+            "header": {
+                "msg_id": msg_id, "username": self.user,
+                "session": str(uuid.uuid4()),
+                "msg_type": "execute_request",
+                "version": "5.3", "date": ""
+            },
+            "parent_header": {},
+            "metadata": {},
+            "content": {
+                "code": code, "silent": False,
+                "store_history": False,
+                "user_expressions": {}, "allow_stdin": False
+            },
+            "channel": "shell",
+            "buffers": []
+        }
+        self._ws_send(sock, json.dumps(execute_msg))
+
+        status   = "unknown"
+        deadline = time.time() + self.timeout
+        while time.time() < deadline:
+            try:
+                frame = self._ws_recv(sock)
+            except socket.timeout:
+                continue
+            if frame is None:
+                break
+            if not frame:
+                continue
+            try:
+                msg = json.loads(frame)
+            except json.JSONDecodeError:
+                continue
+
+            mt = msg.get("msg_type", "")
+            if mt == "stream":
+                stdout.write(msg["content"]["text"])
+                stdout.flush()
+            elif mt in ("execute_result", "display_data"):
+                stdout.write(msg["content"]["data"].get("text/plain", "") + "\n")
+                stdout.flush()
+            elif mt == "error":
+                sys.stderr.write("KERNEL ERROR: " + msg["content"]["evalue"] + "\n")
+                for line in msg["content"]["traceback"]:
+                    sys.stderr.write(line + "\n")
+                status = "error"
+                break
+            elif mt == "execute_reply":
+                status = msg["content"]["status"]
+                break
+
+        sock.close()
+        return status
+
+
+# ── Module-level convenience functions ────────────────────────────────────────
+
+def _client_from_env():
+    """Build a JupyterHubClient from environment variables or .env file."""
+    import pathlib
+
+    def load_env():
+        for candidate in [pathlib.Path.cwd() / ".env", pathlib.Path.home() / ".env"]:
+            if candidate.exists():
+                with open(candidate) as f:
+                    for line in f:
+                        line = line.strip()
+                        if line and not line.startswith("#") and "=" in line:
+                            k, v = line.split("=", 1)
+                            os.environ.setdefault(k.strip(), v.strip())
+                break
+
+    load_env()
+    return JupyterHubClient(
+        host    = os.getenv("JH_HOST",    "localhost"),
+        port    = os.getenv("JH_PORT",    "8000"),
+        user    = os.getenv("JH_USER",    ""),
+        token   = os.getenv("JH_TOKEN",   ""),
+        timeout = int(os.getenv("JH_TIMEOUT", "600")),
+    )
+
+
+def execute(code, kernel_id=None):
+    return _client_from_env().execute(code, kernel_id=kernel_id)
+
+
+def list_kernels():
+    return _client_from_env().list_kernels()
+
+
+def new_kernel(kernel_name="python3"):
+    return _client_from_env().new_kernel(kernel_name)
+
+
+def get_or_create_kernel(kernel_name="python3"):
+    return _client_from_env().get_or_create_kernel(kernel_name)

jupyterhub_exec-0.1.0/src/jupyterhub_exec.egg-info/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: jupyterhub-exec
+Version: 0.1.0
+Summary: Execute code on a remote JupyterHub kernel from any terminal — zero dependencies.
+License: MIT
+Project-URL: Homepage, https://github.com/quantiota/jupyterhub-exec
+Project-URL: Repository, https://github.com/quantiota/jupyterhub-exec
+Project-URL: Issues, https://github.com/quantiota/jupyterhub-exec/issues
+Keywords: jupyterhub,jupyter,kernel,gpu,offload,agent
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: System :: Distributed Computing
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# jupyterhub-exec
+
+Execute code on a remote JupyterHub kernel from any terminal — zero external dependencies.
+
+```
+pip install jupyterhub-exec
+```
+
+## Why
+
+JupyterHub provides GPU compute. Your agent terminal does not.
+`jh-exec` bridges the two using the Jupyter kernel protocol over a raw WebSocket —
+no browser, no notebook UI, no library dependencies beyond the Python standard library.
+
+```
+┌─────────────────────────┐        WebSocket         ┌──────────────────────────┐
+│   Agent Terminal (CPU)  │ ───────────────────────► │  JupyterHub Kernel (GPU) │
+│   Claude Code / CLI     │ ◄─────────────────────── │  PyTorch / CUDA          │
+└─────────────────────────┘        stdout stream      └──────────────────────────┘
+```
+
+## Usage
+
+```bash
+# Execute a script on the remote GPU kernel
+jh-exec run train.py
+
+# Execute inline code
+jh-exec exec "import torch; print(torch.cuda.is_available())"
+
+# List running kernels
+jh-exec kernels
+
+# Start a new kernel
+jh-exec new-kernel
+```
+
+## Configuration
+
+Set via environment variables or a `.env` file in the working or home directory:
+
+```bash
+JH_HOST=192.168.1.100
+JH_PORT=8000
+JH_USER=agent-01
+JH_TOKEN=your_token_here
+JH_TIMEOUT=600
+```
+
+Or pass directly:
+
+```bash
+jh-exec --host 192.168.1.100 --user agent-01 --token your_token run script.py
+```
+
+## Python API
+
+```python
+from jh_exec import execute, list_kernels, new_kernel
+
+# Execute code, stream output to stdout
+execute("import torch; print(torch.cuda.get_device_name(0))")
+
+# List running kernels
+kernels = list_kernels()
+
+# Start a new kernel, get its ID
+kid = new_kernel()
+```
+
+## Dedicated GPU per agent
+
+In `jupyterhub_config.py`:
+
+```python
+def assign_gpu(spawner):
+    gpu_map = {
+        "agent-01": "0",
+        "agent-02": "1",
+        "agent-03": "2",
+    }
+    spawner.environment["CUDA_VISIBLE_DEVICES"] = gpu_map.get(spawner.user.name, "")
+
+c.Spawner.pre_spawn_hook = assign_gpu
+```
+
+## License
+
+MIT

jupyterhub_exec-0.1.0/src/jupyterhub_exec.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+src/jh_exec/__init__.py
+src/jh_exec/cli.py
+src/jh_exec/client.py
+src/jupyterhub_exec.egg-info/PKG-INFO
+src/jupyterhub_exec.egg-info/SOURCES.txt
+src/jupyterhub_exec.egg-info/dependency_links.txt
+src/jupyterhub_exec.egg-info/entry_points.txt
+src/jupyterhub_exec.egg-info/top_level.txt

jupyterhub_exec-0.1.0/src/jupyterhub_exec.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

jupyterhub_exec-0.1.0/src/jupyterhub_exec.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+jh-exec = jh_exec.cli:main

jupyterhub_exec-0.1.0/src/jupyterhub_exec.egg-info/top_level.txt

@@ -0,0 +1 @@
+jh_exec