kiwi-array-jupyter 0.2.47__py3-none-any.whl

kiwi_array_jupyter-0.2.47.dist-info/METADATA

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: kiwi-array-jupyter
+Version: 0.2.47
+Summary: Jupyter kernel for Kiwi.
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: kiwi-array==0.2.47
+Requires-Dist: ipykernel>=6.29
+Requires-Dist: jupyter_client>=8.6
+Requires-Dist: jupyter_core>=5.7
+
+# Kiwi Jupyter Kernel
+
+`kiwi-array-jupyter` is a Jupyter kernel for Kiwi that takes the direct-bridge
+route:
+
+- Jupyter runs a small Python `ipykernel` host
+- the Python host loads the local Kiwi C ABI bridge with `ctypes`
+- the bridge owns a persistent Kiwi `Session`
+- the bridge and `Session` come from the Kiwi source checkout or the packaged wheel payload
+
+This deliberately avoids the JSON REPL transport. The kernel boundary is:
+
+```text
+Jupyter
+  -> ipykernel
+  -> ctypes
+  -> libkiwi_bridge
+  -> Kiwi Session
+  -> MLX
+```
+
+## What Is Here
+
+- `build.zig`: small Zig regression target wired against [`../../src/kiwi_bridge.zig`](../../src/kiwi_bridge.zig)
+- [`../../bridge/include/kiwi_bridge.h`](../../bridge/include/kiwi_bridge.h): shared C ABI for persistent Kiwi sessions
+- [`../runtime/src/kiwi_array/bridge.py`](../runtime/src/kiwi_array/bridge.py): main-owned Python bridge wrapper consumed by this kernel
+- `zig-src/tests.zig`: focused bridge regression tests
+- `pyproject.toml`: editable Python package for the kernel host
+- `src/kiwi_array_jupyter_kernel/binding.py`: thin re-export of the main-owned Python bridge wrapper
+- `src/kiwi_array_jupyter_kernel/execution.py`: notebook cell execution helpers
+- `src/kiwi_array_jupyter_kernel/kernel.py`: `ipykernel` integration
+- `src/kiwi_array_jupyter_kernel/install.py`: bridge build plus kernelspec install helper
+- `src/kiwi_array_jupyter_kernel/assets/kernel-logo.png`: vendored kernelspec logo source used for Jupyter icon files
+
+## Current Scope
+
+This first cut is intentionally narrow:
+
+- execution is direct and stateful
+- cells run line-by-line using the same blank-line and full-line-comment rules as script mode
+- assignments suppress output
+- echoed results surface in the notebook
+- JSON strings that carry a Vega-Lite schema also surface as Vega-Lite MIME data
+- completion and `inspect` cover the current built-in named functions
+- delimiter-only `is_complete` distinguishes incomplete from clearly invalid input
+
+It does not yet try to provide:
+
+- general structured array display beyond `text/plain`
+- parser-aware completeness checks
+- full symbol completion from live session state
+- a native Zig Jupyter wire-protocol implementation
+
+## Build And Install
+
+From the Kiwi repository root:
+
+```sh
+cd python/jupyter
+uv python install --managed-python 3.14.2
+uv sync --managed-python --python 3.14.2 --group dev
+uv run --managed-python python -m kiwi_array_jupyter_kernel.install --user
+```
+
+In a fresh public checkout, bootstrap MLX first from the Kiwi root with
+`KIWI_MLX_BACKEND=cpu scripts/bootstrap_deps.sh` unless `.deps/mlx` and
+`.deps/mlx-c` already exist.
+
+The install helper builds the official bridge in `../../zig-out/lib` if needed.
+The installed library is:
+
+- `../../zig-out/lib/libkiwi_bridge.dylib` on macOS
+- `../../zig-out/lib/libkiwi_bridge.so` on Linux
+
+The install helper writes a kernelspec that launches:
+
+```sh
+python -m kiwi_array_jupyter_kernel -f {connection_file}
+```
+
+When the bridge has already been built, the kernelspec also captures the
+absolute `KIWI_BRIDGE_LIB` path so notebook startup does not depend on
+accidentally finding the right local library at runtime.
+
+## Tests
+
+From this directory:
+
+```sh
+uv run --managed-python pytest tests/test_kiwi_jupyter_kernel.py
+zig build test
+```
+
+From the repository root, `make test-jupyter` runs the Python Jupyter kernel
+tests when that target is available.
+
+## Notes
+
+- The pinned dev interpreter is the uv-managed CPython `3.14.2` patch release tracked in [`.python-version`](.python-version).
+- The `dev` dependency group includes the Python test stack for the kernel host plus `jupyter_kernel_test` for end-to-end kernel validation work.
+- The kernelspec logo is sourced from the vendored [`src/kiwi_array_jupyter_kernel/assets/kernel-logo.png`](src/kiwi_array_jupyter_kernel/assets/kernel-logo.png), derived from the current website favicon artwork instead of depending on generated website output.
+- The loader looks for packaged wheel libraries first and then `../../zig-out/lib` in source checkouts.
+- Set `KIWI_BRIDGE_LIB` to override the bridge path.
+- `KIWI_JUPYTER_BRIDGE_LIB` is still accepted as a compatibility alias.
+- Set `KIWI_MLX_PREFIX` and `KIWI_MLX_C_INCLUDE` to override the MLX link inputs when building the bridge from Python.
+- Set `KIWI_JUPYTER_DEVICE=cpu` or `gpu` to pin the default MLX device.

kiwi_array_jupyter-0.2.47.dist-info/RECORD

@@ -0,0 +1,12 @@
+kiwi_array_jupyter_kernel/__init__.py,sha256=fiqyqv19NWBX0LOG-WYLhi4tB_eP3gfbiIfuFVJcx_0,86
+kiwi_array_jupyter_kernel/__main__.py,sha256=Rexv_oz2WINXaK8I6hFLbVUvDRd43XrZHT-Pms__X2Y,231
+kiwi_array_jupyter_kernel/binding.py,sha256=LQ9jwQLjcjhky03znbtOTmSf4gALNZbcH3f-REqvVbs,1678
+kiwi_array_jupyter_kernel/execution.py,sha256=uS6qIb6dunKXU2KKghyG-Uhh408G1ejCJDQfkMCy0yw,2488
+kiwi_array_jupyter_kernel/install.py,sha256=_kD76sjfZlSaHx_V5WcQrNFuKHgioAKfj-MDQj8Ltx4,5788
+kiwi_array_jupyter_kernel/kernel.py,sha256=1EMOAerSPnqFtwp0rOcbLUK9FDoQ6pELV_-CblvKH3k,5695
+kiwi_array_jupyter_kernel/assets/kernel-logo.png,sha256=xLMso0FjTO4slnlqWoMOsKdTzZ0KC8J7ktaSpk5maIM,37182
+kiwi_array_jupyter-0.2.47.dist-info/METADATA,sha256=l7EmsJJ5W3NiomorkCL2qxGtMGvEG6yQWg49HsECA0Y,4676
+kiwi_array_jupyter-0.2.47.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+kiwi_array_jupyter-0.2.47.dist-info/entry_points.txt,sha256=9iaCDCXiOxpbm_pcRZvzgMrq28wRiCeZ3Zu_eTO65rA,230
+kiwi_array_jupyter-0.2.47.dist-info/top_level.txt,sha256=nbewsgAcmb3-Fcw3cptPjUhL237w2giyMn0R5BHYxDo,26
+kiwi_array_jupyter-0.2.47.dist-info/RECORD,,

kiwi_array_jupyter-0.2.47.dist-info/WHEEL

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

kiwi_array_jupyter-0.2.47.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+kiwi-array-jupyter-install = kiwi_array_jupyter_kernel.install:main
+kiwi-array-jupyter-kernel-install = kiwi_array_jupyter_kernel.install:main
+kiwi-jupyter-kernel-install = kiwi_array_jupyter_kernel.install:main

kiwi_array_jupyter-0.2.47.dist-info/top_level.txt

@@ -0,0 +1 @@
+kiwi_array_jupyter_kernel

kiwi_array_jupyter_kernel/__init__.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+__version__ = "0.2.47"
+
+__all__ = ["__version__"]

kiwi_array_jupyter_kernel/__main__.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from ipykernel.kernelapp import IPKernelApp
+
+from .kernel import KiwiKernel
+
+
+def main() -> None:
+    IPKernelApp.launch_instance(kernel_class=KiwiKernel)
+
+
+if __name__ == "__main__":
+    main()

kiwi_array_jupyter_kernel/binding.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+DEVICE_ENV_VAR = "KIWI_JUPYTER_DEVICE"
+
+
+def jupyter_root() -> Path:
+    return Path(__file__).resolve().parents[2]
+
+
+def python_root() -> Path:
+    return jupyter_root().parent
+
+
+def kiwi_root() -> Path:
+    return python_root().parent
+
+
+def experiment_root() -> Path:
+    return jupyter_root()
+
+
+try:
+    import kiwi_array.bridge  # noqa: F401
+except ImportError:
+    _KIWI_BRIDGE_PYTHON_SRC = python_root() / "runtime" / "src"
+    if str(_KIWI_BRIDGE_PYTHON_SRC) not in sys.path:
+        sys.path.insert(0, str(_KIWI_BRIDGE_PYTHON_SRC))
+
+from kiwi_array.bridge import (  # noqa: E402
+    AUTOGRAD_PATH_NAMES,
+    LEGACY_LIB_ENV_VAR,
+    LIB_ENV_VAR,
+    RUNTIME_ENV_VAR,
+    STATUS_NAMES,
+    KiwiBridgeError,
+    KiwiEvalResult,
+    KiwiSession,
+    active_runtime_descriptor,
+    build_bridge,
+    default_library_candidates,
+    discover_runtime_descriptors,
+    find_library_path,
+    implementation_root,
+    load_library,
+    platform_library_name,
+    runtime_library_env_var,
+    runtime_library_search_dir,
+)
+
+__all__ = [
+    "AUTOGRAD_PATH_NAMES",
+    "DEVICE_ENV_VAR",
+    "LEGACY_LIB_ENV_VAR",
+    "LIB_ENV_VAR",
+    "RUNTIME_ENV_VAR",
+    "STATUS_NAMES",
+    "KiwiBridgeError",
+    "KiwiEvalResult",
+    "KiwiSession",
+    "active_runtime_descriptor",
+    "build_bridge",
+    "default_library_candidates",
+    "discover_runtime_descriptors",
+    "experiment_root",
+    "find_library_path",
+    "implementation_root",
+    "jupyter_root",
+    "kiwi_root",
+    "load_library",
+    "platform_library_name",
+    "python_root",
+    "runtime_library_env_var",
+    "runtime_library_search_dir",
+]

kiwi_array_jupyter_kernel/execution.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Iterator, Protocol
+
+from .binding import KiwiEvalResult
+
+
+class SessionProtocol(Protocol):
+    def eval(self, source: str) -> KiwiEvalResult:
+        ...
+
+
+@dataclass(frozen=True)
+class CellOutput:
+    line_no: int
+    text: str
+    autograd_path: str
+    display_mime: str | None = None
+    display_data: str | None = None
+
+
+class CellExecutionError(RuntimeError):
+    def __init__(self, line_no: int, status: str) -> None:
+        self.line_no = line_no
+        self.status = status
+        super().__init__(f"line {line_no}: !{status}")
+
+
+def iter_executable_lines(code: str) -> Iterator[tuple[int, str]]:
+    for line_no, raw_line in enumerate(code.splitlines(), start=1):
+        line = raw_line.rstrip("\r")
+        trimmed = line.strip(" \t")
+        if not trimmed or trimmed.startswith("/"):
+            continue
+        yield line_no, line
+
+
+def execute_cell(session: SessionProtocol, code: str) -> list[CellOutput]:
+    outputs: list[CellOutput] = []
+    for line_no, line in iter_executable_lines(code):
+        result = session.eval(line)
+        if result.status != "ok":
+            raise CellExecutionError(line_no, result.status)
+        if result.echoed and result.text is not None:
+            outputs.append(
+                CellOutput(
+                    line_no=line_no,
+                    text=result.text,
+                    autograd_path=result.autograd_path,
+                    display_mime=result.display_mime,
+                    display_data=result.display_data,
+                )
+            )
+    return outputs
+
+
+def simple_is_complete(code: str) -> str:
+    stack: list[str] = []
+    in_string = False
+    pairs = {
+        "(": ")",
+        "[": "]",
+        "{": "}",
+    }
+
+    for raw_line in code.splitlines():
+        stripped = raw_line.lstrip(" \t")
+        if stripped.startswith("/"):
+            continue
+
+        for ch in raw_line:
+            if ch == '"':
+                in_string = not in_string
+                continue
+            if in_string:
+                continue
+            if ch in "([{":
+                stack.append(ch)
+                continue
+            if ch in ")]}":
+                if not stack:
+                    return "invalid"
+                opener = stack.pop()
+                if pairs[opener] != ch:
+                    return "invalid"
+
+    if in_string or stack:
+        return "incomplete"
+    return "complete"

kiwi_array_jupyter_kernel/install.py

@@ -0,0 +1,172 @@
+from __future__ import annotations
+
+import argparse
+from importlib import resources
+import json
+import os
+import shutil
+import sys
+import tempfile
+from pathlib import Path
+from typing import Any, Optional, Sequence
+
+from .binding import (
+    DEVICE_ENV_VAR,
+    LIB_ENV_VAR,
+    build_bridge,
+    experiment_root,
+    find_library_path,
+    runtime_library_env_var,
+    runtime_library_search_dir,
+)
+
+DEFAULT_KERNEL_NAME = "kiwi"
+DEFAULT_DISPLAY_NAME = "Kiwi"
+
+
+def default_logo_candidates() -> list[Path]:
+    return [
+        Path(__file__).resolve().parent / "assets" / "kernel-logo.png",
+    ]
+
+
+def find_logo_path(path: Optional[str | Path] = None) -> Optional[Path]:
+    if path is not None:
+        candidate = Path(path).expanduser()
+        if candidate.exists():
+            return candidate
+        raise FileNotFoundError(f"Kiwi kernel logo not found at {candidate}")
+
+    for candidate in default_logo_candidates():
+        if candidate.exists():
+            return candidate
+    return None
+
+
+def write_kernel_logos(dst_dir: Path, logo_path: Optional[str | Path] = None) -> None:
+    source = find_logo_path(logo_path)
+    if source is not None:
+        for name in ("logo-32x32.png", "logo-64x64.png"):
+            shutil.copy2(source, dst_dir / name)
+        return
+
+    resource = resources.files("kiwi_array_jupyter_kernel") / "assets" / "kernel-logo.png"
+    with resources.as_file(resource) as resource_path:
+        for name in ("logo-32x32.png", "logo-64x64.png"):
+            shutil.copy2(resource_path, dst_dir / name)
+
+
+def source_python_paths() -> list[Path]:
+    candidates = [
+        experiment_root() / "src",
+        experiment_root().parent / "runtime" / "src",
+    ]
+    return [path for path in candidates if path.exists()]
+
+
+def build_kernel_spec(
+    display_name: str = DEFAULT_DISPLAY_NAME,
+    device: str = "auto",
+    python_executable: Optional[str] = None,
+    library_path: Optional[str] = None,
+    python_path: Optional[Sequence[str | Path]] = None,
+) -> dict[str, Any]:
+    python_cmd = python_executable or sys.executable
+    env = {
+        DEVICE_ENV_VAR: device,
+    }
+    if python_path:
+        paths = [str(Path(path)) for path in python_path]
+        existing_python_path = os.environ.get("PYTHONPATH")
+        env["PYTHONPATH"] = (
+            os.pathsep.join([*paths, existing_python_path])
+            if existing_python_path
+            else os.pathsep.join(paths)
+        )
+    runtime_env_var = runtime_library_env_var()
+    if runtime_env_var is not None:
+        runtime_dir = runtime_library_search_dir()
+        existing = os.environ.get(runtime_env_var)
+        env[runtime_env_var] = (
+            os.pathsep.join([str(runtime_dir), existing]) if existing else str(runtime_dir)
+        )
+    if library_path is not None:
+        env[LIB_ENV_VAR] = library_path
+    return {
+        "argv": [python_cmd, "-m", "kiwi_array_jupyter_kernel", "-f", "{connection_file}"],
+        "display_name": display_name,
+        "language": "kiwi",
+        "env": env,
+    }
+
+
+def install_kernel(
+    name: str = DEFAULT_KERNEL_NAME,
+    display_name: str = DEFAULT_DISPLAY_NAME,
+    device: str = "auto",
+    user: bool = True,
+    prefix: Optional[str] = None,
+    skip_build: bool = False,
+    optimize: str = "ReleaseFast",
+) -> str:
+    if not skip_build:
+        build_bridge(optimize=optimize)
+
+    from jupyter_client.kernelspec import KernelSpecManager
+
+    try:
+        library_path = str(find_library_path())
+    except FileNotFoundError:
+        library_path = None
+
+    spec = build_kernel_spec(
+        display_name=display_name,
+        device=device,
+        library_path=library_path,
+        python_path=source_python_paths(),
+    )
+    with tempfile.TemporaryDirectory() as tmpdir:
+        tmp_path = Path(tmpdir)
+        (tmp_path / "kernel.json").write_text(json.dumps(spec, indent=2) + "\n")
+        write_kernel_logos(tmp_path)
+        return KernelSpecManager().install_kernel_spec(tmpdir, kernel_name=name, user=user, prefix=prefix)
+
+
+def parse_args(argv: Optional[list[str]] = None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Install the Kiwi Jupyter kernel.")
+    parser.add_argument("--name", default=DEFAULT_KERNEL_NAME, help="Kernel name used by Jupyter.")
+    parser.add_argument("--display-name", default=DEFAULT_DISPLAY_NAME, help="Kernel display name shown in Jupyter.")
+    parser.add_argument("--device", choices=("auto", "cpu", "gpu"), default="auto", help="Default Kiwi device for the kernel.")
+    parser.add_argument("--optimize", choices=("Debug", "ReleaseFast", "ReleaseSafe", "ReleaseSmall"), default="ReleaseFast", help="Zig optimize mode used when building the bridge.")
+    parser.add_argument("--skip-build", action="store_true", help="Skip `zig build` before installing the kernelspec.")
+    parser.add_argument("--prefix", help="Install the kernelspec under the given prefix.")
+    parser.add_argument("--sys-prefix", action="store_true", help="Install the kernelspec into the current Python environment prefix.")
+    parser.add_argument("--user", action="store_true", help="Install the kernelspec into the user Jupyter data dir (default).")
+    return parser.parse_args(argv)
+
+
+def main(argv: Optional[list[str]] = None) -> int:
+    args = parse_args(argv)
+    prefix = args.prefix
+    user = True
+    if args.sys_prefix:
+        prefix = sys.prefix
+        user = False
+    elif args.prefix is not None:
+        user = False
+
+    location = install_kernel(
+        name=args.name,
+        display_name=args.display_name,
+        device=args.device,
+        user=user,
+        prefix=prefix,
+        skip_build=args.skip_build,
+        optimize=args.optimize,
+    )
+    print(location)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

kiwi_array_jupyter_kernel/kernel.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+
+import json
+import os
+import re
+from typing import Any
+
+from ipykernel.kernelbase import Kernel
+
+from . import __version__
+from .binding import DEVICE_ENV_VAR, LIB_ENV_VAR, KiwiSession
+from .execution import CellExecutionError, CellOutput, execute_cell, simple_is_complete
+
+SYMBOL_DOCS = {
+    "exp": "exp[x] applies the elementwise exponential.",
+    "grad": (
+        "grad[f] returns a function that differentiates scalar-returning f "
+        "with respect to its first argument."
+    ),
+    "log": "log[x] applies the elementwise natural logarithm.",
+    "sigmoid": "sigmoid[x] applies the elementwise logistic sigmoid.",
+    "tanh": "tanh[x] applies the elementwise hyperbolic tangent.",
+    "valuegrad": (
+        "valuegrad[f] returns a function that yields both the scalar result "
+        "of f and its gradient."
+    ),
+}
+COMPLETION_WORDS = tuple(SYMBOL_DOCS)
+
+
+class KiwiKernel(Kernel):
+    implementation = "kiwi-array-jupyter"
+    implementation_version = __version__
+    language = "kiwi"
+    language_version = "0.2"
+    banner = "Kiwi 0.2 kernel"
+    language_info = {
+        "name": "kiwi",
+        "mimetype": "text/x-kiwi",
+        "file_extension": ".k",
+        "pygments_lexer": "text",
+    }
+
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        device = os.environ.get(DEVICE_ENV_VAR, "auto")
+        library_path = os.environ.get(LIB_ENV_VAR)
+        self._session = KiwiSession(device=device, library_path=library_path)
+
+    def do_execute(
+        self,
+        code: str,
+        silent: bool,
+        store_history: bool = True,
+        user_expressions: Any = None,
+        allow_stdin: bool = False,
+    ) -> dict[str, Any]:
+        del store_history, allow_stdin
+        try:
+            outputs = execute_cell(self._session, code)
+        except CellExecutionError as exc:
+            if not silent:
+                self.send_response(
+                    self.iopub_socket,
+                    "error",
+                    {
+                        "ename": "KiwiError",
+                        "evalue": str(exc),
+                        "traceback": [],
+                    },
+                )
+            return {
+                "status": "error",
+                "ename": "KiwiError",
+                "evalue": str(exc),
+                "traceback": [],
+            }
+
+        if not silent:
+            for output in outputs[:-1]:
+                self.send_response(
+                    self.iopub_socket,
+                    "stream",
+                    {
+                        "name": "stdout",
+                        "text": output.text + "\n",
+                    },
+                )
+
+            if outputs:
+                last = outputs[-1]
+                self.send_response(
+                    self.iopub_socket,
+                    "execute_result",
+                    {
+                        "execution_count": self.execution_count,
+                        "data": _display_data_for_output(last),
+                        "metadata": {"kiwi_autograd_path": last.autograd_path},
+                    },
+                )
+
+        return {
+            "status": "ok",
+            "execution_count": self.execution_count,
+            "payload": [],
+            "user_expressions": {},
+        }
+
+    def do_complete(self, code: str, cursor_pos: int) -> dict[str, Any]:
+        prefix = _completion_prefix(code[:cursor_pos])
+        matches = [word for word in COMPLETION_WORDS if prefix and word.startswith(prefix)]
+        return {
+            "matches": matches,
+            "cursor_start": cursor_pos - len(prefix),
+            "cursor_end": cursor_pos,
+            "metadata": {},
+            "status": "ok",
+        }
+
+    def do_inspect(
+        self,
+        code: str,
+        cursor_pos: int,
+        detail_level: int = 0,
+        omit_sections: Any = (),
+    ) -> dict[str, Any]:
+        del detail_level, omit_sections
+        symbol = _symbol_at_cursor(code, cursor_pos)
+        if symbol is None:
+            return {
+                "status": "ok",
+                "found": False,
+                "data": {},
+                "metadata": {},
+            }
+        doc = SYMBOL_DOCS.get(symbol)
+        if doc is None:
+            return {
+                "status": "ok",
+                "found": False,
+                "data": {},
+                "metadata": {},
+            }
+        return {
+            "status": "ok",
+            "found": True,
+            "data": {"text/plain": doc},
+            "metadata": {},
+        }
+
+    def do_is_complete(self, code: str) -> dict[str, Any]:
+        status = simple_is_complete(code)
+        reply = {"status": status}
+        if status == "incomplete":
+            reply["indent"] = " "
+        return reply
+
+    def do_shutdown(self, restart: bool) -> dict[str, Any]:
+        self._session.close()
+        return {"status": "ok", "restart": restart}
+
+
+def _completion_prefix(code: str) -> str:
+    match = re.search(r"[A-Za-z_][A-Za-z0-9_]*$", code)
+    if match is None:
+        return ""
+    return match.group(0)
+
+
+def _symbol_at_cursor(code: str, cursor_pos: int) -> str | None:
+    for match in re.finditer(r"[A-Za-z_][A-Za-z0-9_]*", code):
+        if match.start() <= cursor_pos <= match.end():
+            return match.group(0)
+    return None
+
+
+def _display_data_for_output(output: CellOutput) -> dict[str, Any]:
+    data: dict[str, Any] = {"text/plain": output.text}
+    if output.display_mime is None or output.display_data is None:
+        return data
+    try:
+        data[output.display_mime] = json.loads(output.display_data)
+    except json.JSONDecodeError:
+        pass
+    return data