From 65a7401e236bf8feba69897e775294b74e2c1dc4 Mon Sep 17 00:00:00 2001 From: Alan Fleming <> Date: Sat, 9 May 2026 09:47:31 +1000 Subject: [PATCH] Rename kernel_name to name --- docs/notebooks/custom_kernel.ipynb | 2 +- docs/usage/commands.md | 4 ++-- src/async_kernel/asyncshell.py | 4 ++-- src/async_kernel/command.py | 4 ++-- src/async_kernel/interface/zmq.py | 2 +- src/async_kernel/kernel.py | 12 ++++++------ src/async_kernel/kernelspec.py | 26 +++++++++++++------------- tests/conftest.py | 8 ++++---- tests/test_command.py | 28 ++++++++++++++-------------- tests/test_enter_kernel.py | 2 +- tests/test_kernel.py | 4 ++-- tests/test_kernelspec.py | 8 ++++---- tests/test_message_spec.py | 2 +- 13 files changed, 53 insertions(+), 53 deletions(-) diff --git a/docs/notebooks/custom_kernel.ipynb b/docs/notebooks/custom_kernel.ipynb index dcdc0642..289bf029 100644 --- a/docs/notebooks/custom_kernel.ipynb +++ b/docs/notebooks/custom_kernel.ipynb @@ -58,7 +58,7 @@ "assert uv_path.exists()\n", "\n", "write_kernel_spec(\n", - " kernel_name=\"async_3.15\",\n", + " name=\"async_3.15\",\n", " display_name=\"Python 3.15 (async)\",\n", " env={\"UV_PROJECT_ENVIRONMENT\": str(uv_path)},\n", " executable=(\"uv\", \"run\", \"--no-sync\", \"python\", \"-m\", \"async_kernel\"),\n", diff --git a/docs/usage/commands.md b/docs/usage/commands.md index 8b3cb20d..e708dc22 100644 --- a/docs/usage/commands.md +++ b/docs/usage/commands.md @@ -29,7 +29,7 @@ The kernel spec looks like this: "-f", "{connection_file}", "--start_interface=async_kernel.interface.start_kernel_zmq_interface", - "--kernel_name=async", + "--name=async", "--backend=trio", "--host=tk" ], @@ -258,7 +258,7 @@ async-kernel -f . Additional settings can be passed as arguments. ```bash -async-kernel -f . --kernel_name=async-trio-custom --display_name='My custom kernel' --quiet=False +async-kernel -f . --name=async-trio-custom --display_name='My custom kernel' --quiet=False ``` The call above will start a new kernel with a 'trio' backend. The quiet setting is diff --git a/src/async_kernel/asyncshell.py b/src/async_kernel/asyncshell.py index 2eeea0c2..a6b6cc20 100644 --- a/src/async_kernel/asyncshell.py +++ b/src/async_kernel/asyncshell.py @@ -221,7 +221,7 @@ class AsyncInteractiveShell(InteractiveShell): @override def __repr__(self) -> str: - return f"<{self.__class__.__name__} kernel_name: {self.kernel.kernel_name!r} subshell_id: {self.subshell_id}>" + return f"<{self.__class__.__name__} name: {self.kernel.name!r} subshell_id: {self.subshell_id}>" def __new__(cls) -> Self: if issubclass(cls, AsyncInteractiveSubshell): @@ -718,7 +718,7 @@ def __init_subclass__(cls) -> None: @override def __repr__(self) -> str: - return f"<{self.__class__.__name__} kernel_name: {self.kernel.kernel_name!r} subshell_id: {self.subshell_id}{' stopped' if self.stopped else ''}>" + return f"<{self.__class__.__name__} name: {self.kernel.name!r} subshell_id: {self.subshell_id}{' stopped' if self.stopped else ''}>" @property @override diff --git a/src/async_kernel/command.py b/src/async_kernel/command.py index 5321df2b..3be4d8f8 100644 --- a/src/async_kernel/command.py +++ b/src/async_kernel/command.py @@ -97,8 +97,8 @@ def command_line() -> None: # Add kernel spec if args.add: - if not hasattr(args, "kernel_name"): - args.kernel_name = args.add + if not hasattr(args, "name"): + args.name = args.add for name in cl_names: delattr(args, name) path = write_kernel_spec(**vars(args)) diff --git a/src/async_kernel/interface/zmq.py b/src/async_kernel/interface/zmq.py index f4bddcb9..e40c5061 100644 --- a/src/async_kernel/interface/zmq.py +++ b/src/async_kernel/interface/zmq.py @@ -335,7 +335,7 @@ def _write_connection_file( ip=self.ip, key=self.session.key, signature_scheme=self.session.signature_scheme, - kernel_name=self.kernel.kernel_name, + kernel_name=self.kernel.name, **{f"{channel}_port": self.ports[channel] for channel in Channel}, ) ip_files: list[pathlib.Path] = [] diff --git a/src/async_kernel/kernel.py b/src/async_kernel/kernel.py index 606e374f..f4e9f12b 100644 --- a/src/async_kernel/kernel.py +++ b/src/async_kernel/kernel.py @@ -107,7 +107,7 @@ class Kernel(traitlets.HasTraits): of the current profile, but can be specified by absolute path. """ - kernel_name = traitlets.CUnicode() + name = traitlets.CUnicode() "The kernels name - if it contains 'trio' a trio backend will be used instead of an asyncio backend." help_links = traitlets.List(trait=traitlets.Dict()) @@ -162,8 +162,8 @@ def __repr__(self) -> str: def _default_log(self) -> LoggerAdapter[Logger]: return logging.LoggerAdapter(logging.getLogger(self.__class__.__name__)) - @traitlets.default("kernel_name") - def _default_kernel_name(self) -> Literal["async-trio", "async"]: + @traitlets.default("name") + def _default_name(self) -> Literal["async-trio", "async"]: return "async-trio" if current_async_library(failsafe=True) == "trio" else "async" @traitlets.default("interface") @@ -234,14 +234,14 @@ def kernel_info(self) -> dict[str, Any]: "banner": self.banner, "help_links": self.help_links, "debugger": bool(self.interface.debugger), - "kernel_name": self.kernel_name, + "name": self.name, "supported_features": self.supported_features, } @property def settings(self) -> dict[str, Any]: "Settings that have been set to customise the behaviour of the kernel." - return {k: getattr(self, k) for k in ("kernel_name", "connection_file")} | self._settings + return {k: getattr(self, k) for k in ("name", "connection_file")} | self._settings @property def shell(self) -> AsyncInteractiveShell | AsyncInteractiveSubshell: @@ -272,7 +272,7 @@ def load_settings(self, settings: dict[str, Any]) -> None: if self.event_started: msg = "It is too late to load settings!" raise RuntimeError(msg) - settings_ = self._settings or {"kernel_name": self.kernel_name} + settings_ = self._settings or {"name": self.name} for k, v in settings.items(): settings_ |= utils.setattr_nested(self, k, v) self._settings.update(settings_) diff --git a/src/async_kernel/kernelspec.py b/src/async_kernel/kernelspec.py index 0bff5b7c..2bcf3e11 100644 --- a/src/async_kernel/kernelspec.py +++ b/src/async_kernel/kernelspec.py @@ -29,7 +29,7 @@ def make_argv( *, connection_file: str = "{connection_file}", - kernel_name: str = "async", + name: str = "async", start_interface: str | InterfaceStartType = DEFAULT_START_INTERFACE, executable: tuple[str, ...] = DEFAULT_EXECUTABLE, **kwargs: dict[str, Any], @@ -43,7 +43,7 @@ def make_argv( connection_file: The path to the connection file. start_interface: Either the kernel factory object itself, or the string import path to a callable that returns a non-started kernel. - kernel_name: The name of the kernel to use. + name: The name to use for the kernel. executable: The command line executable to call. **kwargs: Additional settings to pass when creating the kernel passed to `start_interface`. @@ -51,7 +51,7 @@ def make_argv( list: A list of command-line arguments to launch the kernel module. """ argv = [*executable, "-f", connection_file] - for k, v in ({"start_interface": start_interface, "kernel_name": kernel_name} | kwargs).items(): + for k, v in ({"start_interface": start_interface, "name": name} | kwargs).items(): argv.append(f"--{k}={v}") return argv @@ -59,7 +59,7 @@ def make_argv( def write_kernel_spec( path: Path | str | None = None, *, - kernel_name: str = "async", + name: str = "async", display_name: str = "", executable: tuple[str, ...] = DEFAULT_EXECUTABLE, prefix: str = "", @@ -77,8 +77,8 @@ def write_kernel_spec( Args: path: The path where to write the spec. - kernel_name: The name of the kernel to use. - display_name: The display name for Jupyter to use for the kernel. The default is `"Python ({kernel_name})"`. + name: The name of the kernel to use. + display_name: The display name for Jupyter to use for the kernel. The default is `"Python ({name})"`. executable: The first part of 'argv' to use. prefix: given, the kernelspec will be installed to PREFIX/share/jupyter/kernels/KERNEL_NAME. This can be sys.prefix for installation inside virtual or conda envs. @@ -114,7 +114,7 @@ async def execute_request(self, job): async_kernel.kernelspec.write_kernel_spec( - kernel_name="async-print-job", start_interface=start_interface + name="async-print-job", start_interface=start_interface ) ``` @@ -122,8 +122,8 @@ async def execute_request(self, job): Moving the spec folder will break the import which is stored as an absolute path. """ - assert re.match(re.compile(r"^[a-z0-9._\-]+$", re.IGNORECASE), kernel_name) - path = Path(path).expanduser() if path else (get_kernel_dir(folder=folder, prefix=prefix) / kernel_name) + assert re.match(re.compile(r"^[a-z0-9._\-]+$", re.IGNORECASE), name) + path = Path(path).expanduser() if path else (get_kernel_dir(folder=folder, prefix=prefix) / name) # stage resources try: path.mkdir(parents=True, exist_ok=True) @@ -138,14 +138,14 @@ async def execute_request(self, job): argv = make_argv( start_interface=start_interface, connection_file=connection_file, - kernel_name=kernel_name, + name=name, executable=executable, **kwargs, ) spec: dict[str, list[Any] | Any | dict[Any, Any] | str | dict[str, bool]] = { "argv": argv, "env": env or {}, - "display_name": display_name or f"Python {sys.version_info.major}.{sys.version_info.minor} ({kernel_name})", + "display_name": display_name or f"Python {sys.version_info.major}.{sys.version_info.minor} ({name})", "language": language, "interrupt_mode": "message", "metadata": metadata if metadata is not None else {"debugger": True, "concurrent": True}, @@ -160,9 +160,9 @@ async def execute_request(self, job): return path -def remove_kernel_spec(kernel_name: str, *, folder: str = "", prefix: str = "") -> bool: +def remove_kernel_spec(name: str, *, folder: str = "", prefix: str = "") -> bool: "Remove a kernelspec returning True if it was removed." - if (path := get_kernel_dir(folder=folder, prefix=prefix).joinpath(kernel_name)).exists(): + if (path := get_kernel_dir(folder=folder, prefix=prefix).joinpath(name)).exists(): shutil.rmtree(path, ignore_errors=True) return True return False diff --git a/tests/conftest.py b/tests/conftest.py index 86ce9979..90da3e71 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -111,20 +111,20 @@ async def client(kernel: Kernel) -> AsyncGenerator[AsyncKernelClient, Any]: @pytest.fixture(scope="module", params=["async", "async-trio"]) -def kernel_name(request): +def name(request): return request.param @pytest.fixture(scope="module") -async def subprocess_kernels_client(anyio_backend, tmp_path_factory, kernel_name, transport: str): +async def subprocess_kernels_client(anyio_backend, tmp_path_factory, name, transport: str): """ Starts a kernel in a subprocess and returns an AsyncKernelCient that is connected to it. """ assert anyio_backend[0] == "asyncio", "Asyncio is required for the client" connection_file = tmp_path_factory.mktemp("async_kernel") / "temp_connection.json" - backend = Backend.trio if "trio" in kernel_name else Backend.asyncio + backend = Backend.trio if "trio" in name else Backend.asyncio kwgs = {"interface.transport": transport, "interface.backend": backend} - command = make_argv(connection_file=connection_file, kernel_name=kernel_name, **kwgs) # pyright: ignore[reportArgumentType] + command = make_argv(connection_file=connection_file, name=name, **kwgs) # pyright: ignore[reportArgumentType] process = await anyio.open_process([*command, "--no-print_kernel_messages"]) async with process: while not connection_file.exists() or not connection_file.stat().st_size: diff --git a/tests/test_command.py b/tests/test_command.py index da10ef9f..408f53d6 100644 --- a/tests/test_command.py +++ b/tests/test_command.py @@ -69,7 +69,7 @@ def test_add_kernel(monkeypatch, fake_kernel_dir: pathlib.Path, capsys): "-f", "{connection_file}", "--start_interface=async_kernel.kernel.Kernel", - "--kernel_name=async-trio", + "--name=async-trio", ], "env": {}, "display_name": "my kernel", @@ -82,23 +82,23 @@ def test_add_kernel(monkeypatch, fake_kernel_dir: pathlib.Path, capsys): @pytest.mark.parametrize("mode", ["folder", "prefix", "default"]) def test_remove_existing_kernel(monkeypatch, fake_kernel_dir, capsys, mode: Literal["folder", "prefix", "default"]): - kernel_name = "asyncio" - (fake_kernel_dir / kernel_name).mkdir() + name = "asyncio" + (fake_kernel_dir / name).mkdir() if mode == "folder": - monkeypatch.setattr(sys, "argv", ["prog", "-r", kernel_name, f"--folder={fake_kernel_dir}"]) + monkeypatch.setattr(sys, "argv", ["prog", "-r", name, f"--folder={fake_kernel_dir}"]) elif mode == "prefix": - monkeypatch.setattr(sys, "argv", ["prog", "-r", kernel_name, f"--prefix={sys.prefix}"]) + monkeypatch.setattr(sys, "argv", ["prog", "-r", name, f"--prefix={sys.prefix}"]) else: - monkeypatch.setattr(sys, "argv", ["prog", "-r", kernel_name]) + monkeypatch.setattr(sys, "argv", ["prog", "-r", name]) command_line() out = capsys.readouterr().out assert "removed" in out - assert not (fake_kernel_dir / kernel_name).exists() + assert not (fake_kernel_dir / name).exists() def test_remove_nonexistent_kernel(monkeypatch, fake_kernel_dir, capsys): - kernel_name = "not a kernel" - monkeypatch.setattr(sys, "argv", ["prog", "-r", kernel_name]) + name = "not a kernel" + monkeypatch.setattr(sys, "argv", ["prog", "-r", name]) command_line() out = capsys.readouterr().out assert "not found!" in out @@ -142,7 +142,7 @@ def test_command_start_kernel_enable_matplotlib(monkeypatch, backend, host): "prog", "-f", ".", - f"--kernel_name=async-{host}", + f"--name=async-{host}", f"--interface.host={host}", f"--interface.backend={backend}", "--no-print_kernel_messages", @@ -159,20 +159,20 @@ def test_command_start_kernel_enable_matplotlib(monkeypatch, backend, host): async_kernel.Kernel._instance = None # pyright: ignore[reportPrivateUsage] -async def test_subprocess_kernels_client(subprocess_kernels_client: AsyncKernelClient, kernel_name, transport): +async def test_subprocess_kernels_client(subprocess_kernels_client: AsyncKernelClient, name, transport): # Start & Stop a kernel - backend = Backend.trio if "trio" in kernel_name.lower() else Backend.asyncio + backend = Backend.trio if "trio" in name.lower() else Backend.asyncio _, reply = await utils.execute( subprocess_kernels_client, "kernel = get_ipython().kernel", user_expressions={ - "kernel_name": "kernel.kernel_name", + "name": "kernel.name", "host": "kernel.interface.host", "backend": "kernel.interface.backend", "transport": "kernel.interface.transport", }, ) - assert kernel_name in reply["user_expressions"]["kernel_name"]["data"]["text/plain"] + assert name in reply["user_expressions"]["name"]["data"]["text/plain"] assert backend in reply["user_expressions"]["backend"]["data"]["text/plain"] assert transport in reply["user_expressions"]["transport"]["data"]["text/plain"] diff --git a/tests/test_enter_kernel.py b/tests/test_enter_kernel.py index d1b55594..5ba0655e 100644 --- a/tests/test_enter_kernel.py +++ b/tests/test_enter_kernel.py @@ -8,7 +8,7 @@ @pytest.mark.parametrize("anyio_backend", argvalues=["asyncio", "trio"]) async def test_start_kernel_in_context(anyio_backend): async with Kernel({"print_kernel_messages": False}).interface as kernel: - assert kernel.kernel_name == {"asyncio": "async", "trio": "async-trio"}[anyio_backend] + assert kernel.name == {"asyncio": "async", "trio": "async-trio"}[anyio_backend] connection_file = kernel.connection_file # Test prohibit nested async context. with pytest.raises(RuntimeError, match="has already been entered"): diff --git a/tests/test_kernel.py b/tests/test_kernel.py index 30142e28..bc3039eb 100644 --- a/tests/test_kernel.py +++ b/tests/test_kernel.py @@ -575,8 +575,8 @@ async def test_subshell(client: AsyncKernelClient, kernel: Kernel): subshell_id = kernel.subshell_manager.create_subshell(protected=True).subshell_id subshell = kernel.subshell_manager.subshells[subshell_id] - assert repr(kernel.main_shell) == "" - assert repr(subshell) == f"" + assert repr(kernel.main_shell) == "" + assert repr(subshell) == f"" assert kernel.main_shell.user_ns is kernel.main_shell.user_global_ns assert subshell.user_ns is not kernel.main_shell.user_ns diff --git a/tests/test_kernelspec.py b/tests/test_kernelspec.py index 6d6bf7fb..ae1463d1 100644 --- a/tests/test_kernelspec.py +++ b/tests/test_kernelspec.py @@ -11,13 +11,13 @@ @pytest.mark.parametrize( - ("kernel_name", "start_interface"), + ("name", "start_interface"), [ ("trio", DEFAULT_START_INTERFACE), ("function_factory", "custom"), ], ) -def test_write_kernel_spec(kernel_name, start_interface, tmp_path, monkeypatch): +def test_write_kernel_spec(name, start_interface, tmp_path, monkeypatch): if start_interface == "custom": def my_start_interface(settings: dict | None): @@ -25,7 +25,7 @@ def my_start_interface(settings: dict | None): start_interface = my_start_interface - path = write_kernel_spec(tmp_path, kernel_name=kernel_name, start_interface=start_interface) + path = write_kernel_spec(tmp_path, name=name, start_interface=start_interface) kernel_json = path.joinpath("kernel.json") assert kernel_json.exists() data = json.loads(kernel_json.read_bytes()) @@ -45,4 +45,4 @@ def my_start_interface(settings: dict | None): def test_write_kernel_spec_fails(): with pytest.raises(ValueError, match="not enough values to unpack"): - write_kernel_spec(kernel_name="never-works", start_interface="not a factory") + write_kernel_spec(name="never-works", start_interface="not a factory") diff --git a/tests/test_message_spec.py b/tests/test_message_spec.py index 374c2101..b6517f62 100644 --- a/tests/test_message_spec.py +++ b/tests/test_message_spec.py @@ -217,7 +217,7 @@ async def test_kernel_info_request(client: AsyncKernelClient): "banner", "help_links", "debugger", - "kernel_name", + "name", "supported_features", "status", ]