notebook-llm-cli 0.1.0__py3-none-any.whl

notebook_llm/manager.py

@@ -0,0 +1,169 @@
+"""NotebookLLM: the object the CLI (and notebook users) drive."""
+import json
+import os
+from dataclasses import asdict, dataclass
+from typing import Dict, List, Optional
+
+from . import installer
+from .client import OllamaClient
+from .config import continue_config
+from .env import is_kaggle, log
+from .gpu import detect_hardware, detect_gpus
+from .library import Candidate, make_candidate
+from .server import OllamaServer
+from .tunnel import CloudflareTunnel
+
+CONFIG_PATH = os.path.expanduser("~/.notebook_llm/config.json")
+
+# Curated list for "recommended for my GPU". Coding models first (they are auto-picked first).
+CURATED = [
+    "qwen3-coder:30b", "qwen2.5-coder:32b", "qwen2.5-coder:14b", "qwen2.5-coder:7b",
+    "qwen2.5-coder:3b", "qwen2.5-coder:1.5b",
+    "gpt-oss:20b", "qwen3:30b", "qwen3:14b", "qwen3:8b", "qwen3:4b",
+    "gemma3:27b", "gemma3:12b", "gemma3:4b", "deepseek-r1:32b", "deepseek-r1:14b", "deepseek-r1:8b",
+    "phi4:14b", "llama3.1:8b", "llama3.2:3b", "mistral:7b",
+]
+
+
+@dataclass
+class Settings:
+    model: Optional[str] = None
+    context: Optional[int] = None       # None = auto from VRAM
+    keep_alive: str = "-1"
+    flash_attention: bool = True
+    kv_cache: str = "q8_0"              # f16 | q8_0 | q4_0 (needs flash attention)
+    port: int = 11434
+
+    @classmethod
+    def load(cls) -> "Settings":
+        try:
+            with open(CONFIG_PATH) as f:
+                return cls(**{k: v for k, v in json.load(f).items() if k in cls.__dataclass_fields__})
+        except (OSError, ValueError):
+            return cls()
+
+    def save(self) -> None:
+        os.makedirs(os.path.dirname(CONFIG_PATH), exist_ok=True)
+        with open(CONFIG_PATH, "w") as f:
+            json.dump(asdict(self), f, indent=2)
+
+
+class NotebookLLM:
+    def __init__(self, settings: Optional[Settings] = None):
+        self.settings = settings or Settings.load()
+        self.hw = detect_hardware()
+        self.client = OllamaClient(f"http://127.0.0.1:{self.settings.port}")
+        self.tunnel: Optional[CloudflareTunnel] = CloudflareTunnel.discover(
+            installer.cloudflared_path() or "cloudflared", f"http://127.0.0.1:{self.settings.port}")
+        self.server = self._make_server()
+
+    # ---- hardware / estimates -------------------------------------
+    def refresh_hardware(self) -> None:
+        self.hw.gpu = detect_gpus()
+
+    def candidate(self, ref: str, online: bool = False) -> Candidate:
+        return make_candidate(ref, self.hw, self.settings.context, self.settings.kv_cache, online)
+
+    def recommended(self) -> List[Candidate]:
+        return [self.candidate(r) for r in CURATED]
+
+    def best_fit(self) -> Candidate:
+        """First curated coder model that fits comfortably; else the smallest one."""
+        cands = self.recommended()
+        for c in cands[:6]:
+            if c.est.verdict == "fits":
+                return c
+        return cands[5]
+
+    # ---- server ----------------------------------------------------
+    def _make_server(self, model: Optional[str] = None) -> OllamaServer:
+        s = self.settings
+        ctx = s.context
+        ref = model or s.model
+        if ctx is None and ref:
+            ctx = self.candidate(ref).est.context
+        return OllamaServer(port=s.port, gpu_indices=self.hw.gpu.indices, keep_alive=s.keep_alive,
+                            context_length=ctx, flash_attention=s.flash_attention, kv_cache_type=s.kv_cache)
+
+    def ensure_installed(self) -> None:
+        installer.install_ollama()
+
+    def start_server(self, model: Optional[str] = None) -> None:
+        self.ensure_installed()
+        self.server = self._make_server(model)
+        self.server.start()
+
+    def restart_server(self, model: Optional[str] = None) -> None:
+        self.server.stop()
+        self.start_server(model)
+
+    def stop_server(self) -> None:
+        self.server.stop()
+
+    # ---- models ----------------------------------------------------
+    def installed(self) -> List[Dict]:
+        return self.client.list_models() if self.server.is_running() else []
+
+    def loaded(self) -> List[Dict]:
+        return self.client.running() if self.server.is_running() else []
+
+    def pull(self, ref: str) -> None:
+        self.client.pull(ref)
+
+    def load(self, ref: str) -> None:
+        """Make `ref` the active model. Restarts the server if its context should change."""
+        want = self.candidate(ref).est.context
+        if self.settings.context is None and self.server.context_length not in (None, want) and self.server.is_running():
+            log(f"Restarting server with context {want} for this model...")
+            self.restart_server(ref)
+        self.client.load(ref, keep_alive=-1 if self.settings.keep_alive == "-1" else self.settings.keep_alive)
+        self.settings.model = ref
+        self.settings.save()
+
+    def unload(self, ref: str) -> None:
+        self.client.unload(ref)
+
+    def delete(self, ref: str) -> None:
+        self.client.delete(ref)
+        if self.settings.model == ref:
+            self.settings.model = None
+            self.settings.save()
+
+    def benchmark(self, ref: Optional[str] = None) -> Dict[str, float]:
+        return self.client.benchmark(ref or self.settings.model)
+
+    def chat(self, prompt: str, system: Optional[str] = None) -> str:
+        return self.client.chat(self.settings.model, prompt, system)
+
+    # ---- tunnel ----------------------------------------------------
+    @property
+    def url(self) -> Optional[str]:
+        return self.tunnel.url if self.tunnel else None
+
+    def open_tunnel(self) -> str:
+        if self.tunnel and self.tunnel.url:
+            return self.tunnel.url
+        self.tunnel = CloudflareTunnel(installer.install_cloudflared(), self.server.url)
+        return self.tunnel.start()
+
+    def close_tunnel(self) -> None:
+        if self.tunnel:
+            self.tunnel.stop()
+        self.tunnel = None
+
+    def continue_config(self, autocomplete: Optional[str] = None) -> str:
+        return continue_config(self.url or self.server.url, self.settings.model or "MODEL", autocomplete)
+
+    # ---- one call --------------------------------------------------
+    def quickstart(self, model: str = "auto", tunnel: bool = True) -> Optional[str]:
+        """Install -> start -> pull -> load -> tunnel. Returns the public URL."""
+        self.refresh_hardware()
+        log(self.hw.summary())
+        c = self.best_fit() if model == "auto" else self.candidate(model)
+        log(f"Model: {c.ref} ({c.est.label}, ~{c.est.tok_s:.0f} tok/s est.)" if c.est.tok_s else f"Model: {c.ref}")
+        self.settings.model = c.ref
+        self.start_server(c.ref)
+        if not self.client.has_model(c.ref):
+            self.pull(c.ref)
+        self.load(c.ref)
+        return self.open_tunnel() if tunnel else None

notebook_llm/server.py

@@ -0,0 +1,101 @@
+"""Manage the background `ollama serve` process."""
+import os
+import signal
+import subprocess
+import time
+from typing import Dict, List, Optional
+
+import requests
+
+LOG_PATH = "/tmp/ollama.log"
+
+
+class OllamaServer:
+    def __init__(self, port: int = 11434, gpu_indices: Optional[List[int]] = None,
+                 keep_alive: str = "-1", context_length: Optional[int] = None,
+                 flash_attention: bool = True, kv_cache_type: Optional[str] = "q8_0",
+                 extra_env: Optional[Dict[str, str]] = None, host: str = "127.0.0.1"):
+        self.host, self.port = host, port
+        self.gpu_indices = gpu_indices or []
+        self.keep_alive = keep_alive
+        self.context_length = context_length
+        self.flash_attention = flash_attention
+        self.kv_cache_type = kv_cache_type
+        self.extra_env = extra_env or {}
+        self.process: Optional[subprocess.Popen] = None
+
+    @property
+    def url(self) -> str:
+        return f"http://{self.host}:{self.port}"
+
+    def is_running(self) -> bool:
+        try:
+            return requests.get(f"{self.url}/api/tags", timeout=2).ok
+        except requests.RequestException:
+            return False
+
+    def _env(self) -> Dict[str, str]:
+        env = os.environ.copy()
+        env["OLLAMA_HOST"] = f"{self.host}:{self.port}"
+        env["OLLAMA_KEEP_ALIVE"] = self.keep_alive
+        if self.gpu_indices:
+            env["CUDA_VISIBLE_DEVICES"] = ",".join(map(str, self.gpu_indices))
+            if len(self.gpu_indices) > 1:
+                env["OLLAMA_SCHED_SPREAD"] = "1"
+        if self.context_length:
+            env["OLLAMA_CONTEXT_LENGTH"] = str(self.context_length)
+        if self.flash_attention:
+            env["OLLAMA_FLASH_ATTENTION"] = "1"
+            if self.kv_cache_type and self.kv_cache_type != "f16":
+                env["OLLAMA_KV_CACHE_TYPE"] = self.kv_cache_type
+        env.update(self.extra_env)
+        return env
+
+    def start(self, timeout: int = 90) -> None:
+        if self.is_running():
+            return
+        with open(LOG_PATH, "w") as lf:
+            self.process = subprocess.Popen(
+                ["ollama", "serve"], env=self._env(), stdout=lf, stderr=subprocess.STDOUT,
+                stdin=subprocess.DEVNULL, start_new_session=True)
+        deadline = time.time() + timeout
+        while time.time() < deadline:
+            if self.is_running():
+                return
+            if self.process.poll() is not None:
+                raise RuntimeError(f"ollama exited early:\n{self.log_tail()}")
+            time.sleep(1)
+        raise TimeoutError(f"Ollama not ready after {timeout}s:\n{self.log_tail()}")
+
+    def stop(self) -> None:
+        if self.process and self.process.poll() is None:
+            try:
+                os.killpg(os.getpgid(self.process.pid), signal.SIGTERM)
+            except ProcessLookupError:
+                pass
+        else:  # started by an earlier CLI session
+            subprocess.run(["pkill", "-f", "ollama serve"], check=False)
+        self.process = None
+        for _ in range(15):
+            if not self.is_running():
+                break
+            time.sleep(1)
+
+    def restart(self) -> None:
+        self.stop()
+        self.start()
+
+    def log_tail(self, n: int = 30) -> str:
+        try:
+            with open(LOG_PATH) as f:
+                return "".join(f.readlines()[-n:])
+        except FileNotFoundError:
+            return ""
+
+    def gpu_report(self) -> str:
+        try:
+            with open(LOG_PATH) as f:
+                lines = [l.strip() for l in f if any(k in l.lower() for k in ("inference compute", "library=", "cuda"))]
+        except FileNotFoundError:
+            return ""
+        return "\n".join(lines[-6:])

notebook_llm/tunnel.py

@@ -0,0 +1,63 @@
+"""Cloudflare quick tunnel (no account needed)."""
+import os
+import re
+import signal
+import subprocess
+import time
+from typing import Optional
+
+LOG_PATH = "/tmp/cloudflared.log"
+_URL_RE = re.compile(r"https://[a-z0-9-]+\.trycloudflare\.com")
+
+
+class CloudflareTunnel:
+    def __init__(self, binary: str, target: str = "http://127.0.0.1:11434"):
+        self.binary, self.target = binary, target
+        self.process: Optional[subprocess.Popen] = None
+        self.url: Optional[str] = None
+
+    @classmethod
+    def discover(cls, binary: str = "cloudflared", target: str = "http://127.0.0.1:11434"):
+        """Re-attach to a tunnel started by an earlier session."""
+        r = subprocess.run(["pgrep", "-f", "cloudflared.*tunnel"], capture_output=True, text=True)
+        if r.returncode != 0:
+            return None
+        try:
+            m = _URL_RE.search(open(LOG_PATH).read())
+        except FileNotFoundError:
+            return None
+        if not m:
+            return None
+        t = cls(binary, target)
+        t.url = m.group(0)
+        return t
+
+    def start(self, timeout: int = 45) -> str:
+        host = self.target.split("://", 1)[-1]
+        with open(LOG_PATH, "w") as lf:
+            self.process = subprocess.Popen(
+                [self.binary, "tunnel", "--no-autoupdate", "--url", self.target, "--http-host-header", host],
+                stdout=lf, stderr=subprocess.STDOUT, stdin=subprocess.DEVNULL, start_new_session=True)
+        deadline = time.time() + timeout
+        while time.time() < deadline:
+            time.sleep(1)
+            try:
+                m = _URL_RE.search(open(LOG_PATH).read())
+            except FileNotFoundError:
+                m = None
+            if m:
+                self.url = m.group(0)
+                return self.url
+            if self.process.poll() is not None:
+                break
+        raise RuntimeError("Could not get a tunnel URL. Internet enabled? Log:\n" + open(LOG_PATH).read()[-1500:])
+
+    def stop(self) -> None:
+        if self.process and self.process.poll() is None:
+            try:
+                os.killpg(os.getpgid(self.process.pid), signal.SIGTERM)
+            except ProcessLookupError:
+                pass
+        else:
+            subprocess.run(["pkill", "-f", "cloudflared.*tunnel"], check=False)
+        self.process, self.url = None, None

notebook_llm/ui.py

@@ -0,0 +1,71 @@
+"""Tiny terminal UI helpers (no dependencies). Works in Kaggle/Jupyter cells too."""
+import os
+import re
+import sys
+
+_ANSI = re.compile(r"\x1b\[[0-9;]*m")
+CODES = {"red": "31", "green": "32", "yellow": "33", "blue": "34", "magenta": "35",
+         "cyan": "36", "gray": "37", "bold": "1", "dim": "2"}
+
+
+def color_on() -> bool:
+    if os.environ.get("NO_COLOR"):
+        return False
+    return sys.stdout.isatty() or "ipykernel" in sys.modules
+
+
+def c(text, *styles) -> str:
+    if not color_on() or not styles:
+        return str(text)
+    return "".join(f"\x1b[{CODES[s]}m" for s in styles) + str(text) + "\x1b[0m"
+
+
+def vlen(s: str) -> int:
+    return len(_ANSI.sub("", s))
+
+
+def pad(s: str, w: int, right: bool = False) -> str:
+    gap = " " * max(0, w - vlen(s))
+    return gap + s if right else s + gap
+
+
+def table(headers, rows, right_cols=()):
+    widths = [max(vlen(str(x)) for x in col) for col in zip(headers, *rows)] if rows else [len(h) for h in headers]
+    line = "  ".join(pad(c(h, "bold"), widths[i], i in right_cols) for i, h in enumerate(headers))
+    print("  " + line)
+    for r in rows:
+        print("  " + "  ".join(pad(str(x), widths[i], i in right_cols) for i, x in enumerate(r)))
+
+
+def title(text: str) -> None:
+    print("\n" + c(f"== {text} ==", "bold", "cyan"))
+
+
+def info(msg): print(c(msg, "gray"))
+def ok(msg): print(c("OK  ", "green") + msg)
+def warn(msg): print(c("!   ", "yellow") + msg)
+def err(msg): print(c("ERR ", "red") + msg)
+
+
+def ask(prompt: str, default: str = "") -> str:
+    try:
+        v = input(f"> {prompt}{f' [{default}]' if default else ''}: ").strip()
+    except EOFError:
+        return "q"
+    return v or default
+
+
+def confirm(prompt: str, default: bool = True) -> bool:
+    v = ask(f"{prompt} ({'Y/n' if default else 'y/N'})").lower()
+    return default if not v else v.startswith("y")
+
+
+def pick(prompt: str, n: int):
+    """Returns 0-based index, or None for blank/back."""
+    v = ask(f"{prompt} (1-{n}, Enter = back)")
+    if v.isdigit() and 1 <= int(v) <= n:
+        return int(v) - 1
+    return None
+
+
+VERDICT_STYLE = {"fits": "green", "tight": "yellow", "offload": "yellow", "no": "red", "cpu": "yellow"}

notebook_llm_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: notebook-llm-cli
+Version: 0.1.0
+Summary: Interactive CLI to run Ollama LLMs on Kaggle/Colab GPUs: GPU detection, fit and tokens/sec estimates, library search, public tunnel.
+Author-email: Shashan Lumbhani <lumbhanishashan1510@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/soni-shashan/notebook-llm
+Project-URL: Issues, https://github.com/soni-shashan/notebook-llm/issues
+Keywords: ollama,llm,kaggle,colab,gpu,cloudflare-tunnel,cli
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25
+Dynamic: license-file
+
+# notebook_llm
+
+One interactive CLI to run LLMs on a Kaggle/Colab GPU with Ollama: detect GPUs, check whether a model fits, estimate tokens/sec, search the Ollama library, pull, load, benchmark, and open a public tunnel link.
+
+## Install (Kaggle notebook: Internet ON, Accelerator = GPU)
+
+```python
+!pip install -q notebook-llm
+```
+
+From a local folder (copy it to a writable place first, /kaggle/input is read-only):
+
+```python
+!pip install -q ./notebook_llm     # or: pip install notebook_llm
+import notebook_llm
+notebook_llm.run()                 # opens the interactive menu (input boxes appear in the cell)
+```
+
+In a real terminal just run `notebook-llm`.
+Note: `!notebook-llm` cannot take keyboard input in Kaggle, so use `notebook_llm.run()` there.
+
+## Menu
+1. Quick start - installs everything, picks the best model that fits, loads it, opens the tunnel
+2. Search Ollama library - live search of ollama.com/search (paged with `m`, filters like `/tools /vision /thinking /embedding /newest`, or paste `model:tag` / a library URL). Cloud-only models are hidden because they don't run on your GPU (`/cloud` shows them). Pick a model to see FIT verdict and ~tok/s for every size, then pull/load
+3. Recommended models for my GPU
+4. Installed models - load / unload / benchmark (real tok/s) / delete
+5. Tunnel - open, show link, Continue config, close, new link
+6. Server - start / stop / restart / logs / GPU report
+7. Settings - context length, KV cache type, flash attention, keep-alive (saved)
+8. Benchmark the active model
+
+## Non-interactive
+```
+notebook-llm gpus                    # hardware + recommended table
+notebook-llm search coder
+notebook-llm check llama3.1:70b --ctx 8192
+notebook-llm quickstart --model auto
+notebook-llm status | stop
+```
+
+## Python API
+```python
+from notebook_llm import NotebookLLM
+llm = NotebookLLM()
+url = llm.quickstart()               # install -> serve -> pull -> load -> tunnel
+llm.chat("hello"); llm.benchmark(); llm.close_tunnel(); llm.stop_server()
+```
+
+## How the estimates work
+- **Needs** = weights (exact size from registry.ollama.ai, else params x bytes/param) + KV cache (scales with context and KV type) + ~0.7 GB per GPU.
+- **FIT**: FITS (<=92% of total VRAM), TIGHT (<=100%), SLOW (spills to RAM), TOO BIG.
+- **tok/s** = memory bandwidth / bytes read per token, using a built-in GPU bandwidth table (T4, P100, V100, A100, L4, RTX...). MoE models only read their active experts (e.g. qwen3-coder:30b ~3.3B active) so they are much faster than dense models of the same size. Multi-GPU is layer-split, so it adds capacity, not speed.
+- Estimates are +-30%. Use Benchmark for the real number.
+
+## Notes
+- The tunnel link has no authentication; anyone with it can use your GPU.
+- NVIDIA GPUs only. Library search scrapes ollama.com; if it is unreachable a built-in list is used.

notebook_llm_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+notebook_llm/__init__.py,sha256=KbK3VgAduO-E0kbCD703YO3ioCaqLl6vJEijKi69hXM,622
+notebook_llm/__main__.py,sha256=bYt9eEaoRQWdejEHFD8REx9jxVEdZptECFsV7F49Ink,30
+notebook_llm/cli.py,sha256=C8r7uIY6aaEseoKFZ6hxHH4b2MojcsRaoY-QsGf0_mE,16297
+notebook_llm/client.py,sha256=IbFhh5LfSkdGWyq37tjdm1g4j_b-hURsQBIKXW31crk,3811
+notebook_llm/config.py,sha256=kahnWiZEJYG6kkFO_c5ZBI3MPnRV6wxs0cxH34vhc0I,716
+notebook_llm/env.py,sha256=uwPTr9yx08V1ii9y9gvdbMzH9fuHzr7JrdHBAyePu5U,199
+notebook_llm/estimate.py,sha256=Pobt0BpjaWfCYMk5nXjPFf6TLmsqOIDlqZa64PiqyuI,4731
+notebook_llm/estimate_data.py,sha256=Cj-k7xOPFXwGqrcW37oEzbB1EzHWmpXmn8IuwhpnoPE,1689
+notebook_llm/gpu.py,sha256=iL3b6TJdkhssN3MAHMwT1fwMMtR4b5oOqYOFzhzRDf4,3477
+notebook_llm/installer.py,sha256=W-rYf6algJXiL_1gQAZ0rivMIpnXzAa6JRQecZcg2HY,2233
+notebook_llm/library.py,sha256=bIe8SIvRwYyyf6uONkU2kraOYV18W6aqvCbspE3dNg0,8700
+notebook_llm/manager.py,sha256=QAukry6f2L9Rm4mpVBOQjteIjbW0T9OFKeAReQ-_W9I,6777
+notebook_llm/server.py,sha256=SMcLD4glFTnVpewi6tEVwoeVnTg3v9E7BHFmbyNKwFE,3715
+notebook_llm/tunnel.py,sha256=EcNc48Fuyzq1SBDXdpGjZIJ5tywJAeMNwYQ061mHqAU,2345
+notebook_llm/ui.py,sha256=v9T_MJDG6kqqTS4Roqv-1aiOKWLVqgmD6FnDddb-Nsg,2170
+notebook_llm_cli-0.1.0.dist-info/licenses/LICENSE,sha256=X2BYxFa5xVFrpM5_P2bdUjsQWaJQ3cwsAxI8QbTzQjc,1073
+notebook_llm_cli-0.1.0.dist-info/METADATA,sha256=UWrYctFLqc9HXen0MIKO3vZ7MSZt9xxzSfCYJuoVaO8,3788
+notebook_llm_cli-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+notebook_llm_cli-0.1.0.dist-info/entry_points.txt,sha256=YQ3lVVfGIlLaO8Tu0oKpmLYJAieGZjz0KxYNO2Jiys0,92
+notebook_llm_cli-0.1.0.dist-info/top_level.txt,sha256=XGp57YPO1z_LAIcu660qjYFHMaw_LEsfaQM9xmdNPbs,13
+notebook_llm_cli-0.1.0.dist-info/RECORD,,

notebook_llm_cli-0.1.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
+

notebook_llm_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+notebook-llm = notebook_llm.cli:main
+notebook_llm = notebook_llm.cli:main

notebook_llm_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shashan Lumbhani
+
+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.

notebook_llm_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+notebook_llm