beaker-notebook 2.0.0b1__tar.gz

beaker_notebook-2.0.0b1/.gitignore

@@ -0,0 +1,74 @@
+**/__pycache__/**
+*.pyc
+.ipynb_checkpoints
+/*.ipynb
+**/.cache
+**/.ipython
+**/.notebooks/
+
+# Gradle
+.gradle/
+build/
+
+# Eclipse
+.project
+.classpath
+.settings/
+bin/
+
+# IntelliJ
+.idea/*
+*.ipr
+*.iml
+*.iws
+
+# NetBeans
+nb-configuration.xml
+
+# Visual Studio Code
+.vscode/*
+.factorypath
+
+# Nova
+.nova/*
+
+# OSX
+.DS_Store
+
+# Vim
+*.swp
+*.swo
+
+# patch
+*.orig
+*.rej
+
+# Local environment
+.env
+
+# Yarn
+**/.yarn/*
+**/!.yarn/patches
+**/!.yarn/plugins
+**/!.yarn/releases
+**/!.yarn/sdks
+**/!.yarn/versions
+**/.pnp.*
+
+# NPM
+node_modules
+dist
+build
+
+# MISC
+create.sql
+.eslintcache
+**/.venv/
+.openai.toml
+shell.nix
+**/.jekyll-cache
+
+.beaker.conf
+beaker_config.py
+beaker_*_config.py
+src/beaker_notebook/**/ui/*

beaker_notebook-2.0.0b1/LICENSE.txt

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2023-present Jataware Corp
+
+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.

beaker_notebook-2.0.0b1/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: beaker-notebook
+Version: 2.0.0b1
+Summary: Beaker Notebook is a general-purpose, computational notebook with embedded agentic AI designed . It provides a flexible context system that enables domain-specific customization for domains such as data science, research, and computational workflows through specialized AI agents, integrations with external data sources and APIs, and structured workflows.
+Project-URL: Documentation, https://github.com/jataware/beaker-kernel#readme
+Project-URL: Issues, https://github.com/jataware/beaker-kernel/issues
+Project-URL: Source, https://github.com/jataware/beaker-kernel
+Author-email: Matthew Printz <matt@jataware.com>, Brandon Rose <brandon@jataware.com>, Five Grant <five@jataware.com>
+License-Expression: MIT
+License-File: LICENSE.txt
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.10
+Requires-Dist: archytas>=2.0.0b0
+Requires-Dist: click~=8.1
+Requires-Dist: dill
+Requires-Dist: hatch
+Requires-Dist: jinja2~=3.1.2
+Requires-Dist: jupyterlab-server<3,>=2.22.1
+Requires-Dist: jupyterlab~=4.0
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: openpyxl
+Requires-Dist: pandas
+Requires-Dist: python-dotenv~=1.0
+Requires-Dist: requests<3,>=2.24
+Requires-Dist: scipy
+Requires-Dist: six
+Requires-Dist: toml
+Requires-Dist: tornado>=6.4.0
+Requires-Dist: tree-sitter-julia<0.25
+Requires-Dist: tree-sitter-python<0.25
+Requires-Dist: tree-sitter<0.25
+Requires-Dist: watchdog~=3.0
+Requires-Dist: xarray
+Description-Content-Type: text/markdown
+
+# Beaker: the AI-first coding notebook
+
+Beaker is a next-generation coding notebook built for the AI era. Beaker seamlessly integrates a Jupyter-like experience with an AI agent that can generate and run code on your behalf. The agent has access to the entire notebook environment as its context, allowing it to make smart decisions about the code it generates and runs. It can even read tracebacks and fix its own errors, and install missing libraries automatically when it needs them.
+
+Beaker also lets you swap effortlessly between a notebook-style coding interface and a chat-style interface, giving you the best of both worlds. Since everything is interoperable with Jupyter, you can always export your notebook and use it in any other Jupyter-compatible environment.
+
+Beaker is built on top of [Archytas](https://github.com/jataware/archytas), our framework for building AI agents that can interact with code. Advanced users can build their own custom agents with custom ReAct toolsets to support any number of use cases.
+
+We like to think of Beaker as a (much better!) drop-in replacement for workflows where you'd normally rely on Jupyter notebooks, and we hope you'll give it a try and let us know what you think.
+
+## Getting Started
+
+Getting Beaker up and running is easy. Install Beaker with:
+
+```bash
+pip install beaker-kernel
+```
+
+Next, run `beaker config update` to set up your configuration. This creates a `beaker.conf` configuration file (you can find its location at any time with `beaker config find`). You can leave most fields at their defaults, but you'll need to set `LLM_SERVICE_TOKEN` to your OpenAI API key — or the API key for whichever LLM provider you've selected.
+
+Once installed and configured, start a notebook with:
+
+```bash
+beaker notebook
+``` 
+
+Your notebook server will start up and Beaker will be ready to use at [`localhost:8888`](http://localhost:8888).
+
+## Quick demo
+
+Here is a quick demo of using Beaker to interact with a [free weather API](https://open-meteo.com/en/docs), fetch some data, perform some data transformations and a bit of analysis. This is really just scratching the surface of what you can do with Beaker, but it gives you a sense of the kinds of things it can do.
+
+<div align="center">
+  <a href="https://www.youtube.com/watch?v=AP9LT_cxjzY" target="_blank">
+    <img src="docs/assets/beaker-movie-3x-optimized-higherres.gif" alt="Beaker demo" width="90%">
+  </a>
+  <br/>
+  Watch original video on <a href="https://www.youtube.com/watch?v=AP9LT_cxjzY">Youtube here</a>.
+</div>
+
+## Want to know more?
+
+There is a lot more to Beaker than what we've covered here. The full [documentation](https://jataware.github.io/beaker-kernel/) covers how to customize and extend Beaker — building your own custom contexts, agents, subkernels, and integrations to make Beaker fit your specific needs. It also covers using the `beaker-ts` TypeScript library to embed Beaker into your own front-end application.

beaker_notebook-2.0.0b1/README.md

@@ -0,0 +1,43 @@
+# Beaker: the AI-first coding notebook
+
+Beaker is a next-generation coding notebook built for the AI era. Beaker seamlessly integrates a Jupyter-like experience with an AI agent that can generate and run code on your behalf. The agent has access to the entire notebook environment as its context, allowing it to make smart decisions about the code it generates and runs. It can even read tracebacks and fix its own errors, and install missing libraries automatically when it needs them.
+
+Beaker also lets you swap effortlessly between a notebook-style coding interface and a chat-style interface, giving you the best of both worlds. Since everything is interoperable with Jupyter, you can always export your notebook and use it in any other Jupyter-compatible environment.
+
+Beaker is built on top of [Archytas](https://github.com/jataware/archytas), our framework for building AI agents that can interact with code. Advanced users can build their own custom agents with custom ReAct toolsets to support any number of use cases.
+
+We like to think of Beaker as a (much better!) drop-in replacement for workflows where you'd normally rely on Jupyter notebooks, and we hope you'll give it a try and let us know what you think.
+
+## Getting Started
+
+Getting Beaker up and running is easy. Install Beaker with:
+
+```bash
+pip install beaker-kernel
+```
+
+Next, run `beaker config update` to set up your configuration. This creates a `beaker.conf` configuration file (you can find its location at any time with `beaker config find`). You can leave most fields at their defaults, but you'll need to set `LLM_SERVICE_TOKEN` to your OpenAI API key — or the API key for whichever LLM provider you've selected.
+
+Once installed and configured, start a notebook with:
+
+```bash
+beaker notebook
+``` 
+
+Your notebook server will start up and Beaker will be ready to use at [`localhost:8888`](http://localhost:8888).
+
+## Quick demo
+
+Here is a quick demo of using Beaker to interact with a [free weather API](https://open-meteo.com/en/docs), fetch some data, perform some data transformations and a bit of analysis. This is really just scratching the surface of what you can do with Beaker, but it gives you a sense of the kinds of things it can do.
+
+<div align="center">
+  <a href="https://www.youtube.com/watch?v=AP9LT_cxjzY" target="_blank">
+    <img src="docs/assets/beaker-movie-3x-optimized-higherres.gif" alt="Beaker demo" width="90%">
+  </a>
+  <br/>
+  Watch original video on <a href="https://www.youtube.com/watch?v=AP9LT_cxjzY">Youtube here</a>.
+</div>
+
+## Want to know more?
+
+There is a lot more to Beaker than what we've covered here. The full [documentation](https://jataware.github.io/beaker-kernel/) covers how to customize and extend Beaker — building your own custom contexts, agents, subkernels, and integrations to make Beaker fit your specific needs. It also covers using the `beaker-ts` TypeScript library to embed Beaker into your own front-end application.

beaker_notebook-2.0.0b1/hatch_build.py

@@ -0,0 +1,93 @@
+"""Custom hatch build hook"""
+import ast
+import importlib
+import inspect
+import json
+import os
+import shutil
+import sys
+from pathlib import Path
+from typing import Any
+from types import GenericAlias
+
+from hatchling.builders.hooks.plugin.interface import BuildHookInterface
+
+
+class CustomHook(BuildHookInterface):
+    """The IPykernel build hook."""
+
+    def initialize(self, version, build_data):
+        """Initialize the hook."""
+
+        here = os.path.dirname(__file__)
+        dest = os.path.join("build", "data_share_beaker")
+
+        # Import code into build environment
+        sys.path.insert(0, str(here))
+
+        # Recreate the destination directory, clearing any existing build artifacts
+        if os.path.exists(dest):
+           shutil.rmtree(dest)
+        os.makedirs(dest)
+
+        # Inspect context files to build a dynamic mapping of context slugs to context classes
+        context_classes = {}
+        context_src = os.path.join(here, "beaker_kernel", "contexts")
+        if os.path.exists(context_src):
+            for fpath in os.listdir(context_src):
+                if fpath.startswith("_"):
+                    continue
+                package_name = f"beaker_kernel.contexts.{fpath}.context"
+                slug = fpath
+                full_path = os.path.join(context_src, fpath, "context.py")
+                with open(full_path) as f:
+                    src = f.read()
+                symbols = ast.parse(src, full_path)
+                for symbol in symbols.body:
+                    if isinstance(symbol, ast.ClassDef) and "BaseContext" in [attr.id for attr in getattr(symbol, "bases", [])]:
+                        if slug in context_classes:
+                            raise SyntaxError("Only one context is allowed to be defined per module.")
+                        class_name = symbol.name
+                        context_classes[slug] = (package_name, class_name)
+
+
+        # Inspect subkernel files to build a dynamic map of defined subkernels
+        subkernel_classes = {}
+        subkernel_src = os.path.join(here, "beaker_kernel", "lib", "subkernels")
+        if os.path.exists(subkernel_src):
+            from beaker_kernel.lib.subkernel import BeakerSubkernel
+            for fpath in os.listdir(subkernel_src):
+                if fpath.startswith("_") or fpath.startswith("base"):
+                    continue
+                package_name = f"beaker_kernel.subkernels.{os.path.splitext(fpath)[0]}"
+                module = importlib.import_module(package_name)
+                def subkernel_criteria(member):
+                    return inspect.isclass(member) \
+                        and not member.__name__.startswith("Base") \
+                        and not isinstance(member, GenericAlias) \
+                        and issubclass(member, BeakerSubkernel)
+                subkernel_list = inspect.getmembers(module, subkernel_criteria)
+                for class_name, class_instance in subkernel_list:
+                    slug = getattr(class_instance, "SLUG")
+                    if slug in context_classes:
+                        raise SyntaxError("Only one context is allowed to be defined per module.")
+                    subkernel_classes[slug] = (package_name, class_name)
+
+
+        build_config = self.build_config.build_config
+        shared_data = build_config["targets"]["wheel"]["shared-data"]
+
+        # Map the main beaker kernel for inclusion/installation
+        kernel_json_file = os.path.join(here, "beaker_kernel", "kernel.json")
+        shared_data[kernel_json_file] = f"share/jupyter/kernels/beaker_kernel/kernel.json"
+
+        # Write out mappings for each context and subkernel to an individual json file
+        for typename, src in [("contexts", context_classes), ("subkernels", subkernel_classes)]:
+            dest_dir = os.path.join(dest, typename)
+            os.makedirs(dest_dir, exist_ok=True)
+            for slug, (package_name, class_name) in src.items():
+                dest_file = os.path.join(dest_dir, f"{slug}.json")
+                with open(dest_file, "w") as f:
+                    json.dump({"slug": slug, "package": package_name, "class_name": class_name}, f, indent=2)
+                # Add wheel.shared-data mappings for each file so it is installed to the correct location
+                shared_data[dest_file] = f"share/beaker/{typename}/{slug}.json"

beaker_notebook-2.0.0b1/pyproject.toml

@@ -0,0 +1,301 @@
+[build-system]
+requires = ["hatch", "hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "beaker-notebook"
+version = "2.0.0b1"
+description = "Beaker Notebook is a general-purpose, computational notebook with embedded agentic AI designed . It provides a flexible context system that enables domain-specific customization for domains such as data science, research, and computational workflows through specialized AI agents, integrations with external data sources and APIs, and structured workflows."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+keywords = []
+authors = [
+  { name = "Matthew Printz", email = "matt@jataware.com" },
+  { name = "Brandon Rose", email = "brandon@jataware.com" },
+  { name = "Five Grant", email = "five@jataware.com" },
+]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: Implementation :: CPython",
+  "Programming Language :: Python :: Implementation :: PyPy",
+]
+dependencies = [
+  "archytas>=2.0.0b0",
+  "jupyterlab~=4.0",
+  "jupyterlab-server>=2.22.1,<3",
+  "requests>=2.24,<3",
+  "six",
+  "tornado>=6.4.0",
+  "jinja2~=3.1.2",
+  "watchdog~=3.0",
+  "click~=8.1",
+  "python-dotenv~=1.0",
+  "hatch",
+  "toml",
+  "dill",
+  "pandas",
+  "matplotlib",
+  "xarray",
+  "numpy",
+  "scipy",
+  "openpyxl",
+  "tree-sitter<0.25",
+  "tree-sitter-python<0.25",
+  "tree-sitter-julia<0.25",
+]
+
+[project.entry-points.hatch]
+beaker = "beaker_notebook.builder.hooks"
+
+[project.scripts]
+beaker = "beaker_notebook.cli.main:cli"
+
+[tool.hatch.metadata]
+allow-direct-references = true
+
+[tool.hatch.build]
+require-runtime-dependencies = true
+artifacts = [
+  "src/beaker_notebook/app/ui",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = [
+  "src/beaker_notebook",
+  "src/beaker_kernel",
+]
+
+[tool.hatch.build.targets.sdist]
+only-include = ["src"]
+
+[tool.hatch.envs.hatch-build]
+system-packages = true
+
+# Beaker builder, loaded as a custom hook since it's not yet registered.
+[tool.hatch.build.targets.wheel.hooks.custom]
+path = "src/beaker_notebook/builder/beaker.py"
+
+[tool.hatch.build.targets.wheel.shared-data]
+"src/beaker_notebook/kernel.json" = "share/jupyter/kernels/beaker_kernel/kernel.json"
+
+
+[tool.bumpversion]
+current_version="2.0.0b1"
+parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)((?P<release>[ab])(?P<revision>\\d+))?"
+serialize = [
+  "{major}.{minor}.{patch}{release}{revision}",
+  "{major}.{minor}.{patch}"
+]
+search = "{current_version}"
+replace = "{new_version}"
+regex = false
+ignore_missing_version = false
+ignore_missing_files = false
+tag = true
+sign_tags = false
+tag_name = "v{new_version}"
+tag_message = "Bump version: {current_version} → {new_version}"
+allow_dirty = true
+commit = true
+message = "Bump version: {current_version} → {new_version}"
+commit_args = ""
+
+[tool.bumpversion.parts.release]
+values = [
+  "a",
+  "b",
+]
+
+[[tool.bumpversion.files]]
+filename = "pyproject.toml"
+search = 'version = "{current_version}"'
+replace = 'version = "{new_version}"'
+
+[[tool.bumpversion.files]]
+glob = "beaker-vue/package*.json"
+parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)-((?P<release>[ab]).(?P<revision>\\d+))?"
+serialize = [
+  "{major}.{minor}.{patch}-{release}.{revision}",
+  "{major}.{minor}.{patch}"
+]
+search = """beaker-kernel": "^{current_version}"""
+replace = """beaker-kernel": "^{new_version}"""
+
+[[tool.bumpversion.files]]
+glob = "beaker-*/package*.json"
+parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)-((?P<release>[ab]).(?P<revision>\\d+))?"
+serialize = [
+  "{major}.{minor}.{patch}-{release}.{revision}",
+  "{major}.{minor}.{patch}"
+]
+regex = true
+search = """
+([^\\n]*"[^\\n"]*beaker-(?:kernel|ts|vue)"[^\\n]*)
+([\\s]*)"version": "{current_version}"([^\\n]*)"""
+replace = """
+\\1
+\\2"version": "{new_version}"\\3"""
+
+[project.urls]
+Documentation = "https://github.com/jataware/beaker-kernel#readme"
+Issues = "https://github.com/jataware/beaker-kernel/issues"
+Source = "https://github.com/jataware/beaker-kernel"
+
+[tool.hatch.version]
+path = "src/beaker_notebook/__about__.py"
+
+[tool.hatch.envs.default]
+dependencies = [
+  "bump-my-version",
+  "coverage[toml]>=6.5",
+  "pytest",
+  "pytest-asyncio",
+]
+[tool.hatch.envs.default.scripts]
+test = "pytest {args:tests}"
+test-cov = "coverage run -m pytest {args:tests}"
+cov-report = [
+  "- coverage combine",
+  "coverage report",
+]
+cov = [
+  "test-cov",
+  "cov-report",
+]
+bump = [
+  "bump-my-version bump {args:--help}"
+]
+
+[[tool.hatch.envs.all.matrix]]
+python = ["3.10", "3.11"]
+
+[tool.hatch.envs.lint]
+detached = true
+dependencies = [
+  "black>=23.1.0",
+  "mypy>=1.0.0",
+  "ruff>=0.0.243",
+]
+[tool.hatch.envs.lint.scripts]
+typing = "mypy --install-types --non-interactive {args:beaker_notebook tests}"
+style = [
+  "ruff {args:.}",
+  "black --check --diff {args:.}",
+]
+fmt = [
+  "black {args:.}",
+  "ruff --fix {args:.}",
+  "style",
+]
+all = [
+  "style",
+  "typing",
+]
+
+[tool.black]
+target-version = ["py310"]
+line-length = 120
+skip-string-normalization = true
+
+[tool.ruff]
+target-version = "py310"
+line-length = 120
+select = [
+  "A",
+  "ARG",
+  "B",
+  "C",
+  "DTZ",
+  "E",
+  "EM",
+  "F",
+  "FBT",
+  "I",
+  "ICN",
+  "ISC",
+  "N",
+  "PLC",
+  "PLE",
+  "PLR",
+  "PLW",
+  "Q",
+  "RUF",
+  "S",
+  "T",
+  "TID",
+  "UP",
+  "W",
+  "YTT",
+]
+ignore = [
+  # Allow non-abstract empty methods in abstract base classes
+  "B027",
+  # Allow boolean positional values in function calls, like `dict.get(... True)`
+  "FBT003",
+  # Ignore checks for possible passwords
+  "S105", "S106", "S107",
+  # Ignore complexity
+  "C901", "PLR0911", "PLR0912", "PLR0913", "PLR0915",
+]
+unfixable = [
+  # Don't touch unused imports
+  "F401",
+]
+
+[tool.ruff.isort]
+known-first-party = ["beaker_notebook"]
+
+[tool.ruff.flake8-tidy-imports]
+ban-relative-imports = "all"
+
+[tool.ruff.per-file-ignores]
+# Tests can use magic values, assertions, and relative imports
+"tests/**/*" = ["PLR2004", "S101", "TID252"]
+
+[tool.coverage.run]
+source_pkgs = ["beaker_notebook", "tests"]
+branch = true
+parallel = true
+omit = [
+  "src/beaker_notebook/__about__.py",
+]
+
+[tool.coverage.paths]
+beaker_notebook = ["beaker_notebook"]
+tests = ["tests"]
+
+[tool.coverage.report]
+exclude_lines = [
+  "no cov",
+  "if __name__ == .__main__.:",
+  "if TYPE_CHECKING:",
+]
+
+
+
+
+
+[tool.hatch.envs.hatch-test]
+extra-dependencies = [
+  "pytest",
+  "pytest-asyncio",
+  "rich",
+]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+
+[project.entry-points."nbconvert.exporters"]
+streamline = "beaker_notebook.lib.exporters.streamline:StreamlineExporter"
+full_context_notebook = "beaker_notebook.lib.exporters.full_context_notebook:FullContextNotebookExporter"
+chat = "beaker_notebook.lib.exporters.chat:ChatExporter"
+
+[project.entry-points."jupyter_client.kernel_provisioners"]
+beaker-local-provisioner = "beaker_notebook.services.kernel.provisioner:BeakerLocalProvisioner"

beaker_notebook-2.0.0b1/src/beaker_kernel/__init__.py

@@ -0,0 +1,37 @@
+"""
+Compatibility shim: redirects any `beaker_kernel[.X]` import to `beaker_notebook[.X]`.
+"""
+import importlib
+import sys
+from importlib.abc import MetaPathFinder, Loader
+from importlib.machinery import ModuleSpec
+
+_OLD = "beaker_kernel"
+_NEW = "beaker_notebook"
+
+
+class _RenameLoader(Loader):
+    def create_module(self, spec):
+        target = _NEW + spec.name[len(_OLD):]
+        module = importlib.import_module(target)
+        sys.modules[spec.name] = module
+        return module
+
+    def exec_module(self, module):
+        pass
+
+
+class _RenameFinder(MetaPathFinder):
+    def find_spec(self, fullname, path=None, target=None):
+        if fullname == _OLD or fullname.startswith(_OLD + "."):
+            return ModuleSpec(fullname, _RenameLoader(), is_package=True)
+        return None
+
+
+# Install once.
+if not any(isinstance(f, _RenameFinder) for f in sys.meta_path):
+    sys.meta_path.insert(0, _RenameFinder())
+
+# Make `beaker_kernel` itself be `beaker_notebook`.
+import beaker_notebook as _bn
+sys.modules[__name__] = _bn