├── settings ├── commands.jupyterlab-settings ├── themes.jupyterlab-settings ├── jupyterlab-lsp.json └── jupyter_server_config.py ├── .gitpod.yml ├── scripts ├── sys │ ├── list_jupyter.py │ ├── launch.sh │ └── launch_jlab.sh ├── etc_pre │ └── 030-jupyterlab.sh └── list_jupyter.py ├── Dockerfile ├── tests └── test_jupyterlab.py ├── LICENSE ├── .github └── workflows │ └── create_pull_request.yml └── readme.md /settings/commands.jupyterlab-settings: -------------------------------------------------------------------------------- 1 | { 2 | "theme": "mbo" 3 | } 4 | -------------------------------------------------------------------------------- /.gitpod.yml: -------------------------------------------------------------------------------- 1 | image: dclong/gitpod 2 | tasks: 3 | - command: . /scripts/gitpod.sh 4 | -------------------------------------------------------------------------------- /scripts/sys/list_jupyter.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | import json 3 | from jupyter_server import serverapp 4 | 5 | servers = list(serverapp.list_running_servers()) 6 | print(json.dumps(servers, indent=4)) 7 | -------------------------------------------------------------------------------- /scripts/sys/launch.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | #su -m $DOCKER_USER -c "jupyter lab --allow-root --ip='0.0.0.0' --port=8888 --no-browser --collaborative --notebook-dir=/workdir" 4 | jupyter lab --allow-root --ip='0.0.0.0' --port=8888 --no-browser --notebook-dir=/workdir 5 | -------------------------------------------------------------------------------- /settings/themes.jupyterlab-settings: -------------------------------------------------------------------------------- 1 | { 2 | // Theme 3 | // @jupyterlab/apputils-extension:themes 4 | // Theme manager settings. 5 | // ************************************* 6 | 7 | // Selected Theme 8 | // Application-level visual styling theme 9 | "theme": "JupyterLab Dark" 10 | } -------------------------------------------------------------------------------- /settings/jupyterlab-lsp.json: -------------------------------------------------------------------------------- 1 | { 2 | "language_servers": { 3 | "pylsp": { 4 | "serverSettings": { 5 | "pylsp.plugins.pylint.enabled": true, 6 | "pylsp.plugins.pytype.enabled": true, 7 | "pylsp.plugins.yapf.enabled": true, 8 | "pylsp.plugins.pydocstyle.enabled": false, 9 | "pylsp.plugins.pycodestyle.enabled": false, 10 | "pylsp.plugins.pyflakes.enabled": false, 11 | "pylsp.plugins.flake8.enabled": false 12 | } 13 | } 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /scripts/etc_pre/030-jupyterlab.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | # codemirror configuration 4 | codemirror_dir=$HOME/.jupyter/lab/user-settings/@jupyterlab/codemirror-extension 5 | mkdir -p $codemirror_dir 6 | cp /settings/commands.jupyterlab-settings $codemirror_dir 7 | 8 | # apputils-extension configuration 9 | apputils_dir=$HOME/.jupyter/lab/user-settings/@jupyterlab/apputils-extension/ 10 | mkdir -p $apputils_dir 11 | cp /settings/themes.jupyterlab-settings $apputils_dir 12 | 13 | # jupyterlab-lsp 14 | lsp_dir=$HOME/.jupyter/lab/user-settings/@krassowski/jupyterlab-lsp 15 | mkdir -p $lsp_dir 16 | cp /settings/jupyterlab-lsp.json $lsp_dir/plugin.jupyterlab-settings 17 | 18 | chown -R $DOCKER_USER:$DOCKER_GROUP $HOME/.jupyter 19 | -------------------------------------------------------------------------------- /scripts/list_jupyter.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | import getpass 3 | import subprocess as sp 4 | 5 | 6 | def get_jupyter_user() -> bytes: 7 | cmd = "ps aux | grep -i -E 'python3 .*jupyter(-lab)?'" 8 | proc = sp.run(cmd, shell=True, stdout=sp.PIPE) 9 | for line in proc.stdout.strip().split(b"\n"): 10 | if b"/usr/bin/python3 /usr/local/bin/jupyter" in line: 11 | return line.strip().split()[0] 12 | raise ProcessLookupError("No process named jupyter or jupyter-lab.") 13 | 14 | 15 | def main(): 16 | cmd = ["/scripts/sys/list_jupyter.py"] 17 | if getpass.getuser() == "root": 18 | cmd = ["su", get_jupyter_user(), "-c"] + cmd 19 | sp.run(cmd, check=True) 20 | 21 | 22 | if __name__ == '__main__': 23 | main() 24 | -------------------------------------------------------------------------------- /Dockerfile: -------------------------------------------------------------------------------- 1 | # NAME: dclong/jupyterlab 2 | FROM dclong/python-nodejs 3 | # GIT: https://github.com/legendu-net/docker-python-nodejs.git 4 | 5 | RUN icon fish -i 6 | RUN pip3 install --break-system-packages \ 7 | nbdime jinja2 nbconvert "jupyterlab>=2.1.0,<4.5.0" \ 8 | jupyterlab_widgets ipywidgets jupyterlab_myst \ 9 | jupyterlab-lsp python-lsp-server[all] \ 10 | jupyterlab-code-formatter \ 11 | jupyterlab_vim \ 12 | jupyter-resource-usage \ 13 | jupyter_ai \ 14 | && jupyter labextension disable @axlair/jupyterlab_vim \ 15 | && /scripts/sys/purge_cache.sh \ 16 | && npm cache clean --force 17 | 18 | COPY scripts /scripts 19 | #COPY settings/themes.jupyterlab-settings /etc/jupyter/lab/user-settings/@jupyterlab/apputils-extension/themes.jupyterlab-settings 20 | COPY settings/*jupyterlab-* /settings/ 21 | COPY settings/jupyter_server_config.py /etc/jupyter/ 22 | 23 | -------------------------------------------------------------------------------- /scripts/sys/launch_jlab.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | # This script is for launching a JupyterLab service 3 | # in situations where launch.sh in dclong/jupyterlab is overwritten (e.g., in dclong/vscode-server). 4 | # There are 2 popular use cases. 5 | # 1. Pass the CMD "/scripts/sys/init.sh /scripts/sys/launch_jlab.sh" to the docker command when launching a Docker container. 6 | # 2. Run "/scripts/sys/launch_jlab.sh" in an already launched Docker container. 7 | 8 | #@TODO: add --collaborative when it's stable 9 | 10 | case "$(id -un)" in 11 | root ) 12 | su -m $DOCKER_USER -c "jupyter lab --allow-root --ip='0.0.0.0' --port=8888 --no-browser --notebook-dir=/workdir" 13 | ;; 14 | gitpod ) 15 | jupyter lab --allow-root --ip='0.0.0.0' --port=8888 --no-browser --notebook-dir=/workspace 16 | ;; 17 | *) 18 | jupyter lab --allow-root --ip='0.0.0.0' --port=8888 --no-browser --notebook-dir=/workdir 19 | esac 20 | -------------------------------------------------------------------------------- /tests/test_jupyterlab.py: -------------------------------------------------------------------------------- 1 | import subprocess as sp 2 | import time 3 | 4 | 5 | def test_launch(): 6 | proc = sp.run(""" 7 | docker run -d --init \ 8 | --hostname jupyterlab \ 9 | --log-opt max-size=50m \ 10 | -p 8888:8888 \ 11 | -e DOCKER_USER=$(id -un) \ 12 | -e DOCKER_USER_ID=$(id -u) \ 13 | -e DOCKER_PASSWORD=$(id -un) \ 14 | -e DOCKER_GROUP_ID=$(id -g) \ 15 | -v "$(pwd)":/workdir \ 16 | -v "$(dirname $HOME)":/home_host \ 17 | dclong/jupyterlab:next /scripts/sys/init.sh 18 | """, shell=True, check=True, capture_output=True) 19 | cid = proc.stdout.strip().decode() 20 | time.sleep(60) 21 | cids = sp.run("docker ps -q --no-trunc", shell=True, check=True, capture_output=True).stdout.strip().decode().split() 22 | assert cid in cids 23 | sp.run(f"docker stop {cid}", shell=True, check=True) 24 | sp.run(f"docker rm {cid}", shell=True, check=True) 25 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) [2019-present] [Chuanlong Du] 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /.github/workflows/create_pull_request.yml: -------------------------------------------------------------------------------- 1 | name: Create Pull Request 2 | on: 3 | push: 4 | branches: 5 | - dev 6 | jobs: 7 | pr_to_main: 8 | runs-on: ubuntu-latest 9 | steps: 10 | - uses: actions/checkout@v3 11 | with: 12 | ref: main 13 | - name: Reset main branch with dev changes 14 | run: | 15 | git fetch origin dev:dev 16 | git reset --hard dev 17 | - name: Create pull request from dev to main 18 | uses: peter-evans/create-pull-request@v4 19 | with: 20 | token: ${{ secrets.GITHUBACTIONS }} 21 | title: Merge dev into main 22 | branch: dev 23 | author: dclong 24 | assignees: dclong 25 | pr_to_blog: 26 | runs-on: ubuntu-latest 27 | steps: 28 | - uses: actions/checkout@v3 29 | with: 30 | ref: blog 31 | - name: Reset debian branch with dev changes 32 | run: | 33 | git fetch origin dev:dev 34 | git reset --hard dev 35 | - name: Create pull request from dev to blog 36 | uses: peter-evans/create-pull-request@v4 37 | with: 38 | token: ${{ secrets.GITHUBACTIONS }} 39 | title: Merge dev into blog 40 | branch: dev 41 | assignees: dclong 42 | -------------------------------------------------------------------------------- /readme.md: -------------------------------------------------------------------------------- 1 | # dclong/jupyterlab [@DockerHub](https://hub.docker.com/r/dclong/jupyterlab/) | [@GitHub](https://github.com/dclong/docker-jupyterlab) 2 | 3 | JupyterLab in Docker. 4 | **It is recommended that you use the image 5 | [dclong/jupyterhub-ds](https://hub.docker.com/r/dclong/jupyterhub-ds/) 6 | for data science related work 7 | and [dclong/jupyterhub-pytorch](https://hub.docker.com/r/dclong/jupyterhub-pytorch/) for deep learning leveraging GPU.** 8 | Note: Python packages are managed using pip instead of conda. 9 | 10 | ## [Recommended Docker Images](http://www.legendu.net/en/blog/my-docker-images/#recommended-docker-images) 11 | 12 | ## Prerequisite 13 | You need to [install Docker](http://www.legendu.net/en/blog/docker-installation/) before you use this Docker image. 14 | 15 | ## Usage in Linux/Unix 16 | 17 | Please refer to the section 18 | [Usage](http://www.legendu.net/en/blog/my-docker-images/#usage) 19 | of the post [My Docker Images](http://www.legendu.net/en/blog/my-docker-images/) 20 | for detailed instruction on how to use the Docker image. 21 | 22 | The following command starts a container 23 | and mounts the current working directory and `/home` on the host machine 24 | to `/workdir` and `/home_host` in the container respectively. 25 | ``` 26 | docker run -d --init \ 27 | --hostname jupyterlab \ 28 | --log-opt max-size=50m \ 29 | -p 8888:8888 \ 30 | -e DOCKER_USER=$(id -un) \ 31 | -e DOCKER_USER_ID=$(id -u) \ 32 | -e DOCKER_PASSWORD=$(id -un) \ 33 | -e DOCKER_GROUP_ID=$(id -g) \ 34 | -v "$(pwd)":/workdir \ 35 | -v "$(dirname $HOME)":/home_host \ 36 | dclong/jupyterlab /scripts/sys/init.sh --switch-user 37 | ``` 38 | Use the image with the `next` tag (which is the testing/next version of dclong/jupyterhub-ds). 39 | ``` 40 | docker run -d --init \ 41 | --hostname jupyterlab \ 42 | --log-opt max-size=50m \ 43 | -p 8888:8888 \ 44 | -e DOCKER_USER=$(id -un) \ 45 | -e DOCKER_USER_ID=$(id -u) \ 46 | -e DOCKER_PASSWORD=$(id -un) \ 47 | -e DOCKER_GROUP_ID=$(id -g) \ 48 | -v "$(pwd)":/workdir \ 49 | -v "$(dirname $HOME)":/home_host \ 50 | dclong/jupyterlab:next /scripts/sys/init.sh --switch-user 51 | ``` 52 | The following command (only works on Linux) does the same as the above one 53 | except that it limits the use of CPU and memory. 54 | ``` 55 | docker run -d --init \ 56 | --hostname jupyterlab \ 57 | --log-opt max-size=50m \ 58 | --memory=$(($(head -n 1 /proc/meminfo | awk '{print $2}') * 4 / 5))k \ 59 | --cpus=$(($(nproc) - 1)) \ 60 | -p 8888:8888 \ 61 | -e DOCKER_USER=$(id -un) \ 62 | -e DOCKER_USER_ID=$(id -u) \ 63 | -e DOCKER_PASSWORD=$(id -un) \ 64 | -e DOCKER_GROUP_ID=$(id -g) \ 65 | -v "$(pwd)":/workdir \ 66 | -v "$(dirname $HOME)":/home_host \ 67 | dclong/jupyterlab /scripts/sys/init.sh --switch-user 68 | ``` 69 | Use the image with the `next` tag (which is the testing/next version of dclong/jupyterhub-ds). 70 | ``` 71 | docker run -d --init \ 72 | --hostname jupyterlab \ 73 | --log-opt max-size=50m \ 74 | --memory=$(($(head -n 1 /proc/meminfo | awk '{print $2}') * 4 / 5))k \ 75 | --cpus=$(($(nproc) - 1)) \ 76 | -p 8888:8888 \ 77 | -e DOCKER_USER=$(id -un) \ 78 | -e DOCKER_USER_ID=$(id -u) \ 79 | -e DOCKER_PASSWORD=$(id -un) \ 80 | -e DOCKER_GROUP_ID=$(id -g) \ 81 | -v "$(pwd)":/workdir \ 82 | -v "$(dirname $HOME)":/home_host \ 83 | dclong/jupyterlab:next /scripts/sys/init.sh --switch-user 84 | ``` 85 | ## [Get the Token for Login](http://www.legendu.net/en/blog/my-docker-images/#get-information-of-running-jupyterlab-servers) 86 | 87 | ## [Log Information](http://www.legendu.net/en/blog/my-docker-images/#docker-container-logs) 88 | 89 | ## [Detailed Information](http://www.legendu.net/en/blog/my-docker-images/#list-of-images-and-detailed-information) 90 | 91 | ## [Known Issues](http://www.legendu.net/en/blog/my-docker-images/#known-issues) 92 | 93 | ## [About the Author](http://www.legendu.net/pages/about) 94 | -------------------------------------------------------------------------------- /settings/jupyter_server_config.py: -------------------------------------------------------------------------------- 1 | # Configuration file for jupyter-server. 2 | import os 3 | 4 | c = get_config() #noqa 5 | #------------------------------------------------------------------------------ 6 | # permission 775 for new dirs (for easy sharing) 7 | os.umask(0o002) 8 | #------------------------------------------------------------------------------ 9 | #c.ServerApp.ResourceUseDisplay.track_cpu_percent = True 10 | #------------------------------------------------------------------------------ 11 | # Application(SingletonConfigurable) configuration 12 | #------------------------------------------------------------------------------ 13 | ## This is an application. 14 | 15 | ## The date format used by logging formatters for %(asctime)s 16 | # Default: '%Y-%m-%d %H:%M:%S' 17 | # c.Application.log_datefmt = '%Y-%m-%d %H:%M:%S' 18 | 19 | ## The Logging format template 20 | # Default: '[%(name)s]%(highlevel)s %(message)s' 21 | # c.Application.log_format = '[%(name)s]%(highlevel)s %(message)s' 22 | 23 | ## Set the log level by value or name. 24 | # Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL'] 25 | # Default: 30 26 | # c.Application.log_level = 30 27 | 28 | ## Configure additional log handlers. 29 | # 30 | # The default stderr logs handler is configured by the log_level, log_datefmt 31 | # and log_format settings. 32 | # 33 | # This configuration can be used to configure additional handlers (e.g. to 34 | # output the log to a file) or for finer control over the default handlers. 35 | # 36 | # If provided this should be a logging configuration dictionary, for more 37 | # information see: 38 | # https://docs.python.org/3/library/logging.config.html#logging-config- 39 | # dictschema 40 | # 41 | # This dictionary is merged with the base logging configuration which defines 42 | # the following: 43 | # 44 | # * A logging formatter intended for interactive use called 45 | # ``console``. 46 | # * A logging handler that writes to stderr called 47 | # ``console`` which uses the formatter ``console``. 48 | # * A logger with the name of this application set to ``DEBUG`` 49 | # level. 50 | # 51 | # This example adds a new handler that writes to a file: 52 | # 53 | # .. code-block:: python 54 | # 55 | # c.Application.logging_config = { 56 | # "handlers": { 57 | # "file": { 58 | # "class": "logging.FileHandler", 59 | # "level": "DEBUG", 60 | # "filename": "", 61 | # } 62 | # }, 63 | # "loggers": { 64 | # "": { 65 | # "level": "DEBUG", 66 | # # NOTE: if you don't list the default "console" 67 | # # handler here then it will be disabled 68 | # "handlers": ["console", "file"], 69 | # }, 70 | # }, 71 | # } 72 | # Default: {} 73 | # c.Application.logging_config = {} 74 | 75 | ## Instead of starting the Application, dump configuration to stdout 76 | # Default: False 77 | # c.Application.show_config = False 78 | 79 | ## Instead of starting the Application, dump configuration to stdout (as JSON) 80 | # Default: False 81 | # c.Application.show_config_json = False 82 | 83 | #------------------------------------------------------------------------------ 84 | # JupyterApp(Application) configuration 85 | #------------------------------------------------------------------------------ 86 | ## Base class for Jupyter applications 87 | 88 | ## Answer yes to any prompts. 89 | # Default: False 90 | # c.JupyterApp.answer_yes = False 91 | 92 | ## Full path of a config file. 93 | # Default: '' 94 | # c.JupyterApp.config_file = '' 95 | 96 | ## Specify a config file to load. 97 | # Default: '' 98 | # c.JupyterApp.config_file_name = '' 99 | 100 | ## Generate default config file. 101 | # Default: False 102 | # c.JupyterApp.generate_config = False 103 | 104 | ## The date format used by logging formatters for %(asctime)s 105 | # See also: Application.log_datefmt 106 | # c.JupyterApp.log_datefmt = '%Y-%m-%d %H:%M:%S' 107 | 108 | ## The Logging format template 109 | # See also: Application.log_format 110 | # c.JupyterApp.log_format = '[%(name)s]%(highlevel)s %(message)s' 111 | 112 | ## Set the log level by value or name. 113 | # See also: Application.log_level 114 | # c.JupyterApp.log_level = 30 115 | 116 | ## 117 | # See also: Application.logging_config 118 | # c.JupyterApp.logging_config = {} 119 | 120 | ## Instead of starting the Application, dump configuration to stdout 121 | # See also: Application.show_config 122 | # c.JupyterApp.show_config = False 123 | 124 | ## Instead of starting the Application, dump configuration to stdout (as JSON) 125 | # See also: Application.show_config_json 126 | # c.JupyterApp.show_config_json = False 127 | 128 | #------------------------------------------------------------------------------ 129 | # ServerApp(JupyterApp) configuration 130 | #------------------------------------------------------------------------------ 131 | ## The Jupyter Server application class. 132 | 133 | ## Set the Access-Control-Allow-Credentials: true header 134 | # Default: False 135 | # c.ServerApp.allow_credentials = False 136 | 137 | ## Whether or not to allow external kernels, whose connection files are placed in 138 | # external_connection_dir. 139 | # Default: False 140 | # c.ServerApp.allow_external_kernels = False 141 | 142 | ## Set the Access-Control-Allow-Origin header 143 | # 144 | # Use '*' to allow any origin to access your server. 145 | # 146 | # Takes precedence over allow_origin_pat. 147 | # Default: '' 148 | # c.ServerApp.allow_origin = '' 149 | 150 | ## Use a regular expression for the Access-Control-Allow-Origin header 151 | # 152 | # Requests from an origin matching the expression will get replies with: 153 | # 154 | # Access-Control-Allow-Origin: origin 155 | # 156 | # where `origin` is the origin of the request. 157 | # 158 | # Ignored if allow_origin is set. 159 | # Default: '' 160 | # c.ServerApp.allow_origin_pat = '' 161 | 162 | ## DEPRECATED in 2.0. Use PasswordIdentityProvider.allow_password_change 163 | # Default: True 164 | # c.ServerApp.allow_password_change = True 165 | 166 | ## Allow requests where the Host header doesn't point to a local server 167 | # 168 | # By default, requests get a 403 forbidden response if the 'Host' header 169 | # shows that the browser thinks it's on a non-local domain. 170 | # Setting this option to True disables this check. 171 | # 172 | # This protects against 'DNS rebinding' attacks, where a remote web server 173 | # serves you a page and then changes its DNS to send later requests to a 174 | # local IP, bypassing same-origin checks. 175 | # 176 | # Local IP addresses (such as 127.0.0.1 and ::1) are allowed as local, 177 | # along with hostnames configured in local_hostnames. 178 | # Default: False 179 | # c.ServerApp.allow_remote_access = False 180 | 181 | ## Whether to allow the user to run the server as root. 182 | # Default: False 183 | # c.ServerApp.allow_root = False 184 | 185 | ## Allow unauthenticated access to endpoints without authentication rule. 186 | # 187 | # When set to `True` (default in jupyter-server 2.0, subject to change 188 | # in the future), any request to an endpoint without an authentication rule 189 | # (either `@tornado.web.authenticated`, or `@allow_unauthenticated`) 190 | # will be permitted, regardless of whether user has logged in or not. 191 | # 192 | # When set to `False`, logging in will be required for access to each endpoint, 193 | # excluding the endpoints marked with `@allow_unauthenticated` decorator. 194 | # 195 | # This option can be configured using `JUPYTER_SERVER_ALLOW_UNAUTHENTICATED_ACCESS` 196 | # environment variable: any non-empty value other than "true" and "yes" will 197 | # prevent unauthenticated access to endpoints without `@allow_unauthenticated`. 198 | # Default: True 199 | # c.ServerApp.allow_unauthenticated_access = True 200 | 201 | ## Answer yes to any prompts. 202 | # See also: JupyterApp.answer_yes 203 | # c.ServerApp.answer_yes = False 204 | 205 | ## " 206 | # Require authentication to access prometheus metrics. 207 | # Default: True 208 | # c.ServerApp.authenticate_prometheus = True 209 | 210 | ## The authorizer class to use. 211 | # Default: 'jupyter_server.auth.authorizer.AllowAllAuthorizer' 212 | # c.ServerApp.authorizer_class = 'jupyter_server.auth.authorizer.AllowAllAuthorizer' 213 | 214 | ## Reload the webapp when changes are made to any Python src files. 215 | # Default: False 216 | # c.ServerApp.autoreload = False 217 | 218 | ## The base URL for the Jupyter server. 219 | # 220 | # Leading and trailing slashes can be omitted, 221 | # and will automatically be added. 222 | # Default: '/' 223 | # c.ServerApp.base_url = '/' 224 | 225 | ## Specify what command to use to invoke a web 226 | # browser when starting the server. If not specified, the 227 | # default browser will be determined by the `webbrowser` 228 | # standard library module, which allows setting of the 229 | # BROWSER environment variable to override it. 230 | # Default: '' 231 | # c.ServerApp.browser = '' 232 | 233 | ## The full path to an SSL/TLS certificate file. 234 | # Default: '' 235 | # c.ServerApp.certfile = '' 236 | 237 | ## The full path to a certificate authority certificate for SSL/TLS client 238 | # authentication. 239 | # Default: '' 240 | # c.ServerApp.client_ca = '' 241 | 242 | ## Full path of a config file. 243 | # See also: JupyterApp.config_file 244 | # c.ServerApp.config_file = '' 245 | 246 | ## Specify a config file to load. 247 | # See also: JupyterApp.config_file_name 248 | # c.ServerApp.config_file_name = '' 249 | 250 | ## The config manager class to use 251 | # Default: 'jupyter_server.services.config.manager.ConfigManager' 252 | # c.ServerApp.config_manager_class = 'jupyter_server.services.config.manager.ConfigManager' 253 | 254 | ## The content manager class to use. 255 | # Default: 'jupyter_server.services.contents.largefilemanager.AsyncLargeFileManager' 256 | # c.ServerApp.contents_manager_class = 'jupyter_server.services.contents.largefilemanager.AsyncLargeFileManager' 257 | 258 | ## DEPRECATED. Use IdentityProvider.cookie_options 259 | # Default: {} 260 | # c.ServerApp.cookie_options = {} 261 | 262 | ## The random bytes used to secure cookies. 263 | # By default this is generated on first start of the server and persisted across server 264 | # sessions by writing the cookie secret into the `cookie_secret_file` file. 265 | # When using an executable config file you can override this to be random at each server restart. 266 | # 267 | # Note: Cookie secrets should be kept private, do not share config files with 268 | # cookie_secret stored in plaintext (you can read the value from a file). 269 | # Default: b'' 270 | # c.ServerApp.cookie_secret = b'' 271 | 272 | ## The file where the cookie secret is stored. 273 | # Default: '' 274 | # c.ServerApp.cookie_secret_file = '' 275 | 276 | ## Override URL shown to users. 277 | # 278 | # Replace actual URL, including protocol, address, port and base URL, 279 | # with the given value when displaying URL to the users. Do not change 280 | # the actual connection URL. If authentication token is enabled, the 281 | # token is added to the custom URL automatically. 282 | # 283 | # This option is intended to be used when the URL to display to the user 284 | # cannot be determined reliably by the Jupyter server (proxified 285 | # or containerized setups for example). 286 | # Default: '' 287 | # c.ServerApp.custom_display_url = '' 288 | 289 | ## The default URL to redirect to from `/` 290 | # Default: '/' 291 | # c.ServerApp.default_url = '/' 292 | 293 | ## Disable cross-site-request-forgery protection 294 | # 295 | # Jupyter server includes protection from cross-site request forgeries, 296 | # requiring API requests to either: 297 | # 298 | # - originate from pages served by this server (validated with XSRF cookie and token), or 299 | # - authenticate with a token 300 | # 301 | # Some anonymous compute resources still desire the ability to run code, 302 | # completely without authentication. 303 | # These services can disable all authentication and security checks, 304 | # with the full knowledge of what that implies. 305 | # Default: False 306 | # c.ServerApp.disable_check_xsrf = False 307 | 308 | ## The directory to look at for external kernel connection files, if 309 | # allow_external_kernels is True. Defaults to Jupyter 310 | # runtime_dir/external_kernels. Make sure that this directory is not filled with 311 | # left-over connection files, that could result in unnecessary kernel manager 312 | # creations. 313 | # Default: None 314 | # c.ServerApp.external_connection_dir = None 315 | 316 | ## Additional URL parameter keys to scrub from logs. 317 | # 318 | # These will be added to the default list of scrubbed parameter keys. Any URL 319 | # parameter whose key contains one of these substrings will have its value 320 | # replaced with '[secret]' in the logs. This is to prevent sensitive information 321 | # like authentication tokens from being leaked in log files. 322 | # 323 | # Default scrubbed keys: ["token", "auth", "key", "code", "state", "xsrf"] 324 | # Default: [] 325 | # c.ServerApp.extra_log_scrub_param_keys = [] 326 | 327 | ## handlers that should be loaded at higher priority than the default services 328 | # Default: [] 329 | # c.ServerApp.extra_services = [] 330 | 331 | ## Extra paths to search for serving static files. 332 | # 333 | # This allows adding javascript/css to be available from the Jupyter server machine, 334 | # or overriding individual files in the IPython 335 | # Default: [] 336 | # c.ServerApp.extra_static_paths = [] 337 | 338 | ## Extra paths to search for serving jinja templates. 339 | # 340 | # Can be used to override templates from jupyter_server.templates. 341 | # Default: [] 342 | # c.ServerApp.extra_template_paths = [] 343 | 344 | ## Open the named file when the application is launched. 345 | # Default: '' 346 | # c.ServerApp.file_to_run = '' 347 | 348 | ## The URL prefix where files are opened directly. 349 | # Default: 'notebooks' 350 | # c.ServerApp.file_url_prefix = 'notebooks' 351 | 352 | ## Generate default config file. 353 | # See also: JupyterApp.generate_config 354 | # c.ServerApp.generate_config = False 355 | 356 | ## DEPRECATED. Use IdentityProvider.get_secure_cookie_kwargs 357 | # Default: {} 358 | # c.ServerApp.get_secure_cookie_kwargs = {} 359 | 360 | ## The identity provider class to use. 361 | # Default: 'jupyter_server.auth.identity.PasswordIdentityProvider' 362 | # c.ServerApp.identity_provider_class = 'jupyter_server.auth.identity.PasswordIdentityProvider' 363 | 364 | ## DEPRECATED. Use ZMQChannelsWebsocketConnection.iopub_data_rate_limit 365 | # Default: 0.0 366 | # c.ServerApp.iopub_data_rate_limit = 0.0 367 | 368 | ## DEPRECATED. Use ZMQChannelsWebsocketConnection.iopub_msg_rate_limit 369 | # Default: 0.0 370 | # c.ServerApp.iopub_msg_rate_limit = 0.0 371 | 372 | ## The IP address the Jupyter server will listen on. 373 | # Default: 'localhost' 374 | # c.ServerApp.ip = 'localhost' 375 | 376 | ## Supply extra arguments that will be passed to Jinja environment. 377 | # Default: {} 378 | # c.ServerApp.jinja_environment_options = {} 379 | 380 | ## Extra variables to supply to jinja templates when rendering. 381 | # Default: {} 382 | # c.ServerApp.jinja_template_vars = {} 383 | 384 | ## Dict of Python modules to load as Jupyter server extensions.Entry values can 385 | # be used to enable and disable the loading ofthe extensions. The extensions 386 | # will be loaded in alphabetical order. 387 | # Default: {} 388 | # c.ServerApp.jpserver_extensions = {} 389 | 390 | ## The kernel manager class to use. 391 | # Default: 'jupyter_server.services.kernels.kernelmanager.MappingKernelManager' 392 | # c.ServerApp.kernel_manager_class = 'jupyter_server.services.kernels.kernelmanager.MappingKernelManager' 393 | 394 | ## The kernel spec manager class to use. Should be a subclass of 395 | # `jupyter_client.kernelspec.KernelSpecManager`. 396 | # 397 | # The Api of KernelSpecManager is provisional and might change without warning 398 | # between this version of Jupyter and the next stable one. 399 | # Default: 'builtins.object' 400 | # c.ServerApp.kernel_spec_manager_class = 'builtins.object' 401 | 402 | ## The kernel websocket connection class to use. 403 | # Default: 'jupyter_server.services.kernels.connection.base.BaseKernelWebsocketConnection' 404 | # c.ServerApp.kernel_websocket_connection_class = 'jupyter_server.services.kernels.connection.base.BaseKernelWebsocketConnection' 405 | 406 | ## DEPRECATED. Use ZMQChannelsWebsocketConnection.kernel_ws_protocol 407 | # Default: '' 408 | # c.ServerApp.kernel_ws_protocol = '' 409 | 410 | ## The full path to a private key file for usage with SSL/TLS. 411 | # Default: '' 412 | # c.ServerApp.keyfile = '' 413 | 414 | ## DEPRECATED. Use ZMQChannelsWebsocketConnection.limit_rate 415 | # Default: False 416 | # c.ServerApp.limit_rate = False 417 | 418 | ## Hostnames to allow as local when allow_remote_access is False. 419 | # 420 | # Local IP addresses (such as 127.0.0.1 and ::1) are automatically accepted 421 | # as local as well. 422 | # Default: ['localhost'] 423 | # c.ServerApp.local_hostnames = ['localhost'] 424 | 425 | ## The date format used by logging formatters for %(asctime)s 426 | # See also: Application.log_datefmt 427 | # c.ServerApp.log_datefmt = '%Y-%m-%d %H:%M:%S' 428 | 429 | ## The Logging format template 430 | # See also: Application.log_format 431 | # c.ServerApp.log_format = '[%(name)s]%(highlevel)s %(message)s' 432 | 433 | ## Set the log level by value or name. 434 | # See also: Application.log_level 435 | # c.ServerApp.log_level = 30 436 | 437 | ## 438 | # See also: Application.logging_config 439 | # c.ServerApp.logging_config = {} 440 | 441 | ## The login handler class to use. 442 | # Default: 'jupyter_server.auth.login.LegacyLoginHandler' 443 | # c.ServerApp.login_handler_class = 'jupyter_server.auth.login.LegacyLoginHandler' 444 | 445 | ## The logout handler class to use. 446 | # Default: 'jupyter_server.auth.logout.LogoutHandler' 447 | # c.ServerApp.logout_handler_class = 'jupyter_server.auth.logout.LogoutHandler' 448 | 449 | ## Sets the maximum allowed size of the client request body, specified in the 450 | # Content-Length request header field. If the size in a request exceeds the 451 | # configured value, a malformed HTTP message is returned to the client. 452 | # 453 | # Note: max_body_size is applied even in streaming mode. 454 | # Default: 536870912 455 | # c.ServerApp.max_body_size = 536870912 456 | 457 | ## Gets or sets the maximum amount of memory, in bytes, that is allocated for use 458 | # by the buffer manager. 459 | # Default: 536870912 460 | # c.ServerApp.max_buffer_size = 536870912 461 | 462 | ## Gets or sets a lower bound on the open file handles process resource limit. 463 | # This may need to be increased if you run into an OSError: [Errno 24] Too many 464 | # open files. This is not applicable when running on Windows. 465 | # Default: 0 466 | # c.ServerApp.min_open_files_limit = 0 467 | 468 | ## DEPRECATED, use root_dir. 469 | # Default: '' 470 | # c.ServerApp.notebook_dir = '' 471 | 472 | ## Whether to open in a browser after starting. 473 | # The specific browser used is platform dependent and 474 | # determined by the python standard library `webbrowser` 475 | # module, unless it is overridden using the --browser 476 | # (ServerApp.browser) configuration option. 477 | # Default: False 478 | # c.ServerApp.open_browser = False 479 | 480 | ## DEPRECATED in 2.0. Use PasswordIdentityProvider.hashed_password 481 | # Default: '' 482 | # c.ServerApp.password = '' 483 | 484 | ## DEPRECATED in 2.0. Use PasswordIdentityProvider.password_required 485 | # Default: False 486 | # c.ServerApp.password_required = False 487 | 488 | ## The port the server will listen on (env: JUPYTER_PORT). 489 | # Default: 0 490 | # c.ServerApp.port = 0 491 | 492 | ## The number of additional ports to try if the specified port is not available 493 | # (env: JUPYTER_PORT_RETRIES). 494 | # Default: 50 495 | # c.ServerApp.port_retries = 50 496 | 497 | ## Preferred starting directory to use for notebooks and kernels. 498 | # ServerApp.preferred_dir is deprecated in jupyter-server 2.0. Use 499 | # FileContentsManager.preferred_dir instead 500 | # Default: '' 501 | # c.ServerApp.preferred_dir = '' 502 | 503 | ## DISABLED: use %pylab or %matplotlib in the notebook to enable matplotlib. 504 | # Default: 'disabled' 505 | # c.ServerApp.pylab = 'disabled' 506 | 507 | ## If True, display controls to shut down the Jupyter server, such as menu items 508 | # or buttons. 509 | # Default: True 510 | # c.ServerApp.quit_button = True 511 | 512 | ## DEPRECATED. Use ZMQChannelsWebsocketConnection.rate_limit_window 513 | # Default: 0.0 514 | # c.ServerApp.rate_limit_window = 0.0 515 | 516 | ## Reraise exceptions encountered loading server extensions? 517 | # Default: False 518 | # c.ServerApp.reraise_server_extension_failures = False 519 | 520 | ## The directory to use for notebooks and kernels. 521 | # Default: '' 522 | # c.ServerApp.root_dir = '' 523 | 524 | ## The session manager class to use. 525 | # Default: 'builtins.object' 526 | # c.ServerApp.session_manager_class = 'builtins.object' 527 | 528 | ## Instead of starting the Application, dump configuration to stdout 529 | # See also: Application.show_config 530 | # c.ServerApp.show_config = False 531 | 532 | ## Instead of starting the Application, dump configuration to stdout (as JSON) 533 | # See also: Application.show_config_json 534 | # c.ServerApp.show_config_json = False 535 | 536 | ## Shut down the server after N seconds with no kernelsrunning and no activity. 537 | # This can be used together with culling idle kernels 538 | # (MappingKernelManager.cull_idle_timeout) to shutdown the Jupyter server when 539 | # it's not in use. This is not precisely timed: it may shut down up to a minute 540 | # later. 0 (the default) disables this automatic shutdown. 541 | # Default: 0 542 | # c.ServerApp.shutdown_no_activity_timeout = 0 543 | 544 | ## The UNIX socket the Jupyter server will listen on. 545 | # Default: '' 546 | # c.ServerApp.sock = '' 547 | 548 | ## The permissions mode for UNIX socket creation (default: 0600). 549 | # Default: '0600' 550 | # c.ServerApp.sock_mode = '0600' 551 | 552 | ## Supply SSL options for the tornado HTTPServer. 553 | # See the tornado docs for details. 554 | # Default: {} 555 | # c.ServerApp.ssl_options = {} 556 | 557 | ## Paths to set up static files as immutable. 558 | # 559 | # This allow setting up the cache control of static files as immutable. It 560 | # should be used for static file named with a hash for instance. 561 | # Default: [] 562 | # c.ServerApp.static_immutable_cache = [] 563 | 564 | ## Supply overrides for terminado. Currently only supports "shell_command". 565 | # Default: {} 566 | c.ServerApp.terminado_settings = { 567 | "shell_command": "/usr/bin/fish", 568 | } 569 | 570 | ## Set to False to disable terminals. 571 | # 572 | # This does *not* make the server more secure by itself. 573 | # Anything the user can in a terminal, they can also do in a notebook. 574 | # 575 | # Terminals may also be automatically disabled if the terminado package 576 | # is not available. 577 | # Default: False 578 | # c.ServerApp.terminals_enabled = False 579 | 580 | ## DEPRECATED. Use IdentityProvider.token 581 | # Default: '' 582 | # c.ServerApp.token = '' 583 | 584 | ## Supply overrides for the tornado.web.Application that the Jupyter server uses. 585 | # Default: {} 586 | # c.ServerApp.tornado_settings = {} 587 | 588 | ## Whether to trust or not X-Scheme/X-Forwarded-Proto and X-Real-Ip/X-Forwarded- 589 | # For headerssent by the upstream reverse proxy. Necessary if the proxy handles 590 | # SSL 591 | # Default: False 592 | # c.ServerApp.trust_xheaders = False 593 | 594 | ## Disable launching browser by redirect file 595 | # For versions of notebook > 5.7.2, a security feature measure was added that 596 | # prevented the authentication token used to launch the browser from being visible. 597 | # This feature makes it difficult for other users on a multi-user system from 598 | # running code in your Jupyter session as you. 599 | # However, some environments (like Windows Subsystem for Linux (WSL) and Chromebooks), 600 | # launching a browser using a redirect file can lead the browser failing to load. 601 | # This is because of the difference in file structures/paths between the runtime and 602 | # the browser. 603 | # 604 | # Disabling this setting to False will disable this behavior, allowing the browser 605 | # to launch by using a URL and visible token (as before). 606 | # Default: True 607 | # c.ServerApp.use_redirect_file = True 608 | 609 | ## Specify where to open the server on startup. This is the 610 | # `new` argument passed to the standard library method `webbrowser.open`. 611 | # The behaviour is not guaranteed, but depends on browser support. Valid 612 | # values are: 613 | # 614 | # - 2 opens a new tab, 615 | # - 1 opens a new window, 616 | # - 0 opens in an existing window. 617 | # 618 | # See the `webbrowser.open` documentation for details. 619 | # Default: 2 620 | # c.ServerApp.webbrowser_open_new = 2 621 | 622 | ## Set the tornado compression options for websocket connections. 623 | # 624 | # This value will be returned from 625 | # :meth:`WebSocketHandler.get_compression_options`. None (default) will disable 626 | # compression. A dict (even an empty one) will enable compression. 627 | # 628 | # See the tornado docs for WebSocketHandler.get_compression_options for details. 629 | # Default: None 630 | # c.ServerApp.websocket_compression_options = None 631 | 632 | ## Configure the websocket ping interval in seconds. 633 | # 634 | # Websockets are long-lived connections that are used by some Jupyter Server 635 | # extensions. 636 | # 637 | # Periodic pings help to detect disconnected clients and keep the connection 638 | # active. If this is set to None, then no pings will be performed. 639 | # 640 | # When a ping is sent, the client has ``websocket_ping_timeout`` seconds to 641 | # respond. If no response is received within this period, the connection will be 642 | # closed from the server side. 643 | # Default: 0 644 | # c.ServerApp.websocket_ping_interval = 0 645 | 646 | ## Configure the websocket ping timeout in seconds. 647 | # 648 | # See ``websocket_ping_interval`` for details. 649 | # Default: 0 650 | # c.ServerApp.websocket_ping_timeout = 0 651 | 652 | ## The base URL for websockets, 653 | # if it differs from the HTTP server (hint: it almost certainly doesn't). 654 | # 655 | # Should be in the form of an HTTP origin: ws[s]://hostname[:port] 656 | # Default: '' 657 | # c.ServerApp.websocket_url = '' 658 | 659 | #------------------------------------------------------------------------------ 660 | # ConnectionFileMixin(LoggingConfigurable) configuration 661 | #------------------------------------------------------------------------------ 662 | ## Mixin for configurable classes that work with connection files 663 | 664 | ## JSON file in which to store connection info [default: kernel-.json] 665 | # 666 | # This file will contain the IP, ports, and authentication key needed to connect 667 | # clients to this kernel. By default, this file will be created in the security dir 668 | # of the current profile, but can be specified by absolute path. 669 | # Default: '' 670 | # c.ConnectionFileMixin.connection_file = '' 671 | 672 | ## set the control (ROUTER) port [default: random] 673 | # Default: 0 674 | # c.ConnectionFileMixin.control_port = 0 675 | 676 | ## set the heartbeat port [default: random] 677 | # Default: 0 678 | # c.ConnectionFileMixin.hb_port = 0 679 | 680 | ## set the iopub (PUB) port [default: random] 681 | # Default: 0 682 | # c.ConnectionFileMixin.iopub_port = 0 683 | 684 | ## Set the kernel's IP address [default localhost]. 685 | # If the IP address is something other than localhost, then 686 | # Consoles on other machines will be able to connect 687 | # to the Kernel, so be careful! 688 | # Default: '' 689 | # c.ConnectionFileMixin.ip = '' 690 | 691 | ## set the shell (ROUTER) port [default: random] 692 | # Default: 0 693 | # c.ConnectionFileMixin.shell_port = 0 694 | 695 | ## set the stdin (ROUTER) port [default: random] 696 | # Default: 0 697 | # c.ConnectionFileMixin.stdin_port = 0 698 | 699 | # Choices: any of ['tcp', 'ipc'] (case-insensitive) 700 | # Default: 'tcp' 701 | # c.ConnectionFileMixin.transport = 'tcp' 702 | 703 | #------------------------------------------------------------------------------ 704 | # KernelManager(ConnectionFileMixin) configuration 705 | #------------------------------------------------------------------------------ 706 | ## Manages a single kernel in a subprocess on this host. 707 | # 708 | # This version starts kernels with Popen. 709 | 710 | ## Should we autorestart the kernel if it dies. 711 | # Default: True 712 | # c.KernelManager.autorestart = True 713 | 714 | ## True if the MultiKernelManager should cache ports for this KernelManager 715 | # instance 716 | # Default: False 717 | # c.KernelManager.cache_ports = False 718 | 719 | ## JSON file in which to store connection info [default: kernel-.json] 720 | # See also: ConnectionFileMixin.connection_file 721 | # c.KernelManager.connection_file = '' 722 | 723 | ## set the control (ROUTER) port [default: random] 724 | # See also: ConnectionFileMixin.control_port 725 | # c.KernelManager.control_port = 0 726 | 727 | ## set the heartbeat port [default: random] 728 | # See also: ConnectionFileMixin.hb_port 729 | # c.KernelManager.hb_port = 0 730 | 731 | ## set the iopub (PUB) port [default: random] 732 | # See also: ConnectionFileMixin.iopub_port 733 | # c.KernelManager.iopub_port = 0 734 | 735 | ## Set the kernel's IP address [default localhost]. 736 | # See also: ConnectionFileMixin.ip 737 | # c.KernelManager.ip = '' 738 | 739 | ## set the shell (ROUTER) port [default: random] 740 | # See also: ConnectionFileMixin.shell_port 741 | # c.KernelManager.shell_port = 0 742 | 743 | ## Time to wait for a kernel to terminate before killing it, in seconds. When a 744 | # shutdown request is initiated, the kernel will be immediately sent an 745 | # interrupt (SIGINT), followedby a shutdown_request message, after 1/2 of 746 | # `shutdown_wait_time`it will be sent a terminate (SIGTERM) request, and finally 747 | # at the end of `shutdown_wait_time` will be killed (SIGKILL). terminate and 748 | # kill may be equivalent on windows. Note that this value can beoverridden by 749 | # the in-use kernel provisioner since shutdown times mayvary by provisioned 750 | # environment. 751 | # Default: 5.0 752 | # c.KernelManager.shutdown_wait_time = 5.0 753 | 754 | ## set the stdin (ROUTER) port [default: random] 755 | # See also: ConnectionFileMixin.stdin_port 756 | # c.KernelManager.stdin_port = 0 757 | 758 | # See also: ConnectionFileMixin.transport 759 | # c.KernelManager.transport = 'tcp' 760 | 761 | #------------------------------------------------------------------------------ 762 | # Session(Configurable) configuration 763 | #------------------------------------------------------------------------------ 764 | ## Object for handling serialization and sending of messages. 765 | # 766 | # The Session object handles building messages and sending them 767 | # with ZMQ sockets or ZMQStream objects. Objects can communicate with each 768 | # other over the network via Session objects, and only need to work with the 769 | # dict-based IPython message spec. The Session will handle 770 | # serialization/deserialization, security, and metadata. 771 | # 772 | # Sessions support configurable serialization via packer/unpacker traits, 773 | # and signing with HMAC digests via the key/keyfile traits. 774 | # 775 | # Parameters 776 | # ---------- 777 | # 778 | # debug : bool 779 | # whether to trigger extra debugging statements 780 | # packer/unpacker : str : 'json', 'pickle' or import_string 781 | # importstrings for methods to serialize message parts. If just 782 | # 'json' or 'pickle', predefined JSON and pickle packers will be used. 783 | # Otherwise, the entire importstring must be used. 784 | # 785 | # The functions must accept at least valid JSON input, and output 786 | # *bytes*. 787 | # 788 | # For example, to use msgpack: 789 | # packer = 'msgpack.packb', unpacker='msgpack.unpackb' 790 | # pack/unpack : callables 791 | # You can also set the pack/unpack callables for serialization directly. 792 | # session : bytes 793 | # the ID of this Session object. The default is to generate a new UUID. 794 | # username : unicode 795 | # username added to message headers. The default is to ask the OS. 796 | # key : bytes 797 | # The key used to initialize an HMAC signature. If unset, messages 798 | # will not be signed or checked. 799 | # keyfile : filepath 800 | # The file containing a key. If this is set, `key` will be initialized 801 | # to the contents of the file. 802 | 803 | ## Threshold (in bytes) beyond which an object's buffer should be extracted to 804 | # avoid pickling. 805 | # Default: 1024 806 | # c.Session.buffer_threshold = 1024 807 | 808 | ## Whether to check PID to protect against calls after fork. 809 | # 810 | # This check can be disabled if fork-safety is handled elsewhere. 811 | # Default: True 812 | # c.Session.check_pid = True 813 | 814 | ## Threshold (in bytes) beyond which a buffer should be sent without copying. 815 | # Default: 65536 816 | # c.Session.copy_threshold = 65536 817 | 818 | ## Debug output in the Session 819 | # Default: False 820 | # c.Session.debug = False 821 | 822 | ## The maximum number of digests to remember. 823 | # 824 | # The digest history will be culled when it exceeds this value. 825 | # Default: 65536 826 | # c.Session.digest_history_size = 65536 827 | 828 | ## The maximum number of items for a container to be introspected for custom serialization. 829 | # Containers larger than this are pickled outright. 830 | # Default: 64 831 | # c.Session.item_threshold = 64 832 | 833 | ## execution key, for signing messages. 834 | # Default: b'' 835 | # c.Session.key = b'' 836 | 837 | ## path to file containing execution key. 838 | # Default: '' 839 | # c.Session.keyfile = '' 840 | 841 | ## Metadata dictionary, which serves as the default top-level metadata dict for 842 | # each message. 843 | # Default: {} 844 | # c.Session.metadata = {} 845 | 846 | ## The name of the packer for serializing messages. 847 | # Should be one of 'json', 'pickle', or an import name 848 | # for a custom callable serializer. 849 | # Default: 'json' 850 | # c.Session.packer = 'json' 851 | 852 | ## The UUID identifying this session. 853 | # Default: '' 854 | # c.Session.session = '' 855 | 856 | ## The digest scheme used to construct the message signatures. 857 | # Must have the form 'hmac-HASH'. 858 | # Default: 'hmac-sha256' 859 | # c.Session.signature_scheme = 'hmac-sha256' 860 | 861 | ## The name of the unpacker for unserializing messages. 862 | # Only used with custom functions for `packer`. 863 | # Default: 'json' 864 | # c.Session.unpacker = 'json' 865 | 866 | ## Username for the Session. Default is your system username. 867 | # Default: 'dclong' 868 | # c.Session.username = 'dclong' 869 | 870 | #------------------------------------------------------------------------------ 871 | # MultiKernelManager(LoggingConfigurable) configuration 872 | #------------------------------------------------------------------------------ 873 | ## A class for managing multiple kernels. 874 | 875 | ## The name of the default kernel to start 876 | # Default: 'python3' 877 | # c.MultiKernelManager.default_kernel_name = 'python3' 878 | 879 | ## The kernel manager class. This is configurable to allow 880 | # subclassing of the KernelManager for customized behavior. 881 | # Default: 'jupyter_client.ioloop.IOLoopKernelManager' 882 | # c.MultiKernelManager.kernel_manager_class = 'jupyter_client.ioloop.IOLoopKernelManager' 883 | 884 | ## Share a single zmq.Context to talk to all my kernels 885 | # Default: True 886 | # c.MultiKernelManager.shared_context = True 887 | 888 | #------------------------------------------------------------------------------ 889 | # MappingKernelManager(MultiKernelManager) configuration 890 | #------------------------------------------------------------------------------ 891 | ## A KernelManager that handles 892 | # - File mapping 893 | # - HTTP error handling 894 | # - Kernel message filtering 895 | 896 | ## Whether to send tracebacks to clients on exceptions. 897 | # Default: True 898 | # c.MappingKernelManager.allow_tracebacks = True 899 | 900 | ## White list of allowed kernel message types. 901 | # When the list is empty, all message types are allowed. 902 | # Default: [] 903 | # c.MappingKernelManager.allowed_message_types = [] 904 | 905 | ## Whether messages from kernels whose frontends have disconnected should be 906 | # buffered in-memory. 907 | # 908 | # When True (default), messages are buffered and replayed on reconnect, 909 | # avoiding lost messages due to interrupted connectivity. 910 | # 911 | # Disable if long-running kernels will produce too much output while 912 | # no frontends are connected. 913 | # Default: True 914 | # c.MappingKernelManager.buffer_offline_messages = True 915 | 916 | ## Whether to consider culling kernels which are busy. 917 | # Only effective if cull_idle_timeout > 0. 918 | # Default: False 919 | # c.MappingKernelManager.cull_busy = False 920 | 921 | ## Whether to consider culling kernels which have one or more connections. 922 | # Only effective if cull_idle_timeout > 0. 923 | # Default: False 924 | # c.MappingKernelManager.cull_connected = False 925 | 926 | ## Timeout (in seconds) after which a kernel is considered idle and ready to be culled. 927 | # Values of 0 or lower disable culling. Very short timeouts may result in kernels being culled 928 | # for users with poor network connections. 929 | # Default: 0 930 | # c.MappingKernelManager.cull_idle_timeout = 0 931 | 932 | ## The interval (in seconds) on which to check for idle kernels exceeding the 933 | # cull timeout value. 934 | # Default: 300 935 | # c.MappingKernelManager.cull_interval = 300 936 | 937 | ## The name of the default kernel to start 938 | # See also: MultiKernelManager.default_kernel_name 939 | # c.MappingKernelManager.default_kernel_name = 'python3' 940 | 941 | ## Timeout for giving up on a kernel (in seconds). 942 | # 943 | # On starting and restarting kernels, we check whether the 944 | # kernel is running and responsive by sending kernel_info_requests. 945 | # This sets the timeout in seconds for how long the kernel can take 946 | # before being presumed dead. 947 | # This affects the MappingKernelManager (which handles kernel restarts) 948 | # and the ZMQChannelsHandler (which handles the startup). 949 | # Default: 60 950 | # c.MappingKernelManager.kernel_info_timeout = 60 951 | 952 | ## The kernel manager class. This is configurable to allow 953 | # See also: MultiKernelManager.kernel_manager_class 954 | # c.MappingKernelManager.kernel_manager_class = 'jupyter_client.ioloop.IOLoopKernelManager' 955 | 956 | # Default: '' 957 | # c.MappingKernelManager.root_dir = '' 958 | 959 | ## Share a single zmq.Context to talk to all my kernels 960 | # See also: MultiKernelManager.shared_context 961 | # c.MappingKernelManager.shared_context = True 962 | 963 | ## Message to print when allow_tracebacks is False, and an exception occurs 964 | # Default: 'An exception occurred at runtime, which is not shown due to security reasons.' 965 | # c.MappingKernelManager.traceback_replacement_message = 'An exception occurred at runtime, which is not shown due to security reasons.' 966 | 967 | ## List of kernel message types excluded from user activity tracking. 968 | # 969 | # This should be a superset of the message types sent on any channel other 970 | # than the shell channel. 971 | # Default: ['comm_info_request', 'comm_info_reply', 'kernel_info_request', 'kernel_info_reply', 'shutdown_request', 'shutdown_reply', 'interrupt_request', 'interrupt_reply', 'debug_request', 'debug_reply', 'stream', 'display_data', 'update_display_data', 'execute_input', 'execute_result', 'error', 'status', 'clear_output', 'debug_event', 'input_request', 'input_reply'] 972 | # c.MappingKernelManager.untracked_message_types = ['comm_info_request', 'comm_info_reply', 'kernel_info_request', 'kernel_info_reply', 'shutdown_request', 'shutdown_reply', 'interrupt_request', 'interrupt_reply', 'debug_request', 'debug_reply', 'stream', 'display_data', 'update_display_data', 'execute_input', 'execute_result', 'error', 'status', 'clear_output', 'debug_event', 'input_request', 'input_reply'] 973 | 974 | #------------------------------------------------------------------------------ 975 | # KernelSpecManager(LoggingConfigurable) configuration 976 | #------------------------------------------------------------------------------ 977 | ## A manager for kernel specs. 978 | 979 | ## List of allowed kernel names. 980 | # 981 | # By default, all installed kernels are allowed. 982 | # Default: set() 983 | # c.KernelSpecManager.allowed_kernelspecs = set() 984 | 985 | ## If there is no Python kernelspec registered and the IPython 986 | # kernel is available, ensure it is added to the spec list. 987 | # Default: True 988 | # c.KernelSpecManager.ensure_native_kernel = True 989 | 990 | ## The kernel spec class. This is configurable to allow 991 | # subclassing of the KernelSpecManager for customized behavior. 992 | # Default: 'jupyter_client.kernelspec.KernelSpec' 993 | # c.KernelSpecManager.kernel_spec_class = 'jupyter_client.kernelspec.KernelSpec' 994 | 995 | ## Deprecated, use `KernelSpecManager.allowed_kernelspecs` 996 | # Default: set() 997 | # c.KernelSpecManager.whitelist = set() 998 | 999 | #------------------------------------------------------------------------------ 1000 | # AsyncMultiKernelManager(MultiKernelManager) configuration 1001 | #------------------------------------------------------------------------------ 1002 | ## The name of the default kernel to start 1003 | # See also: MultiKernelManager.default_kernel_name 1004 | # c.AsyncMultiKernelManager.default_kernel_name = 'python3' 1005 | 1006 | ## The kernel manager class. This is configurable to allow 1007 | # subclassing of the AsyncKernelManager for customized behavior. 1008 | # Default: 'jupyter_client.ioloop.AsyncIOLoopKernelManager' 1009 | # c.AsyncMultiKernelManager.kernel_manager_class = 'jupyter_client.ioloop.AsyncIOLoopKernelManager' 1010 | 1011 | ## Share a single zmq.Context to talk to all my kernels 1012 | # See also: MultiKernelManager.shared_context 1013 | # c.AsyncMultiKernelManager.shared_context = True 1014 | 1015 | ## Whether to make kernels available before the process has started. The 1016 | # kernel has a `.ready` future which can be awaited before connecting 1017 | # Default: False 1018 | # c.AsyncMultiKernelManager.use_pending_kernels = False 1019 | 1020 | #------------------------------------------------------------------------------ 1021 | # AsyncMappingKernelManager(MappingKernelManager, AsyncMultiKernelManager) configuration 1022 | #------------------------------------------------------------------------------ 1023 | ## An asynchronous mapping kernel manager. 1024 | 1025 | ## Whether to send tracebacks to clients on exceptions. 1026 | # See also: MappingKernelManager.allow_tracebacks 1027 | # c.AsyncMappingKernelManager.allow_tracebacks = True 1028 | 1029 | ## White list of allowed kernel message types. 1030 | # See also: MappingKernelManager.allowed_message_types 1031 | # c.AsyncMappingKernelManager.allowed_message_types = [] 1032 | 1033 | ## Whether messages from kernels whose frontends have disconnected should be 1034 | # buffered in-memory. 1035 | # See also: MappingKernelManager.buffer_offline_messages 1036 | # c.AsyncMappingKernelManager.buffer_offline_messages = True 1037 | 1038 | ## Whether to consider culling kernels which are busy. 1039 | # See also: MappingKernelManager.cull_busy 1040 | # c.AsyncMappingKernelManager.cull_busy = False 1041 | 1042 | ## Whether to consider culling kernels which have one or more connections. 1043 | # See also: MappingKernelManager.cull_connected 1044 | # c.AsyncMappingKernelManager.cull_connected = False 1045 | 1046 | ## Timeout (in seconds) after which a kernel is considered idle and ready to be 1047 | # culled. 1048 | # See also: MappingKernelManager.cull_idle_timeout 1049 | # c.AsyncMappingKernelManager.cull_idle_timeout = 0 1050 | 1051 | ## The interval (in seconds) on which to check for idle kernels exceeding the 1052 | # cull timeout value. 1053 | # See also: MappingKernelManager.cull_interval 1054 | # c.AsyncMappingKernelManager.cull_interval = 300 1055 | 1056 | ## The name of the default kernel to start 1057 | # See also: MultiKernelManager.default_kernel_name 1058 | # c.AsyncMappingKernelManager.default_kernel_name = 'python3' 1059 | 1060 | ## Timeout for giving up on a kernel (in seconds). 1061 | # See also: MappingKernelManager.kernel_info_timeout 1062 | # c.AsyncMappingKernelManager.kernel_info_timeout = 60 1063 | 1064 | ## The kernel manager class. This is configurable to allow 1065 | # See also: AsyncMultiKernelManager.kernel_manager_class 1066 | # c.AsyncMappingKernelManager.kernel_manager_class = 'jupyter_client.ioloop.AsyncIOLoopKernelManager' 1067 | 1068 | # See also: MappingKernelManager.root_dir 1069 | # c.AsyncMappingKernelManager.root_dir = '' 1070 | 1071 | ## Share a single zmq.Context to talk to all my kernels 1072 | # See also: MultiKernelManager.shared_context 1073 | # c.AsyncMappingKernelManager.shared_context = True 1074 | 1075 | ## Message to print when allow_tracebacks is False, and an exception occurs 1076 | # See also: MappingKernelManager.traceback_replacement_message 1077 | # c.AsyncMappingKernelManager.traceback_replacement_message = 'An exception occurred at runtime, which is not shown due to security reasons.' 1078 | 1079 | ## List of kernel message types excluded from user activity tracking. 1080 | # See also: MappingKernelManager.untracked_message_types 1081 | # c.AsyncMappingKernelManager.untracked_message_types = ['comm_info_request', 'comm_info_reply', 'kernel_info_request', 'kernel_info_reply', 'shutdown_request', 'shutdown_reply', 'interrupt_request', 'interrupt_reply', 'debug_request', 'debug_reply', 'stream', 'display_data', 'update_display_data', 'execute_input', 'execute_result', 'error', 'status', 'clear_output', 'debug_event', 'input_request', 'input_reply'] 1082 | 1083 | ## Whether to make kernels available before the process has started. The 1084 | # See also: AsyncMultiKernelManager.use_pending_kernels 1085 | # c.AsyncMappingKernelManager.use_pending_kernels = False 1086 | 1087 | #------------------------------------------------------------------------------ 1088 | # ContentsManager(LoggingConfigurable) configuration 1089 | #------------------------------------------------------------------------------ 1090 | ## Base class for serving files and directories. 1091 | # 1092 | # This serves any text or binary file, 1093 | # as well as directories, 1094 | # with special handling for JSON notebook documents. 1095 | # 1096 | # Most APIs take a path argument, 1097 | # which is always an API-style unicode path, 1098 | # and always refers to a directory. 1099 | # 1100 | # - unicode, not url-escaped 1101 | # - '/'-separated 1102 | # - leading and trailing '/' will be stripped 1103 | # - if unspecified, path defaults to '', 1104 | # indicating the root path. 1105 | 1106 | ## Allow access to hidden files 1107 | # Default: False 1108 | # c.ContentsManager.allow_hidden = False 1109 | 1110 | # Default: None 1111 | # c.ContentsManager.checkpoints = None 1112 | 1113 | # Default: 'jupyter_server.services.contents.checkpoints.Checkpoints' 1114 | # c.ContentsManager.checkpoints_class = 'jupyter_server.services.contents.checkpoints.Checkpoints' 1115 | 1116 | # Default: {} 1117 | # c.ContentsManager.checkpoints_kwargs = {} 1118 | 1119 | # Default: None 1120 | # c.ContentsManager.event_logger = None 1121 | 1122 | ## handler class to use when serving raw file requests. 1123 | # 1124 | # Default is a fallback that talks to the ContentsManager API, 1125 | # which may be inefficient, especially for large files. 1126 | # 1127 | # Local files-based ContentsManagers can use a StaticFileHandler subclass, 1128 | # which will be much more efficient. 1129 | # 1130 | # Access to these files should be Authenticated. 1131 | # Default: 'jupyter_server.files.handlers.FilesHandler' 1132 | # c.ContentsManager.files_handler_class = 'jupyter_server.files.handlers.FilesHandler' 1133 | 1134 | ## Extra parameters to pass to files_handler_class. 1135 | # 1136 | # For example, StaticFileHandlers generally expect a `path` argument 1137 | # specifying the root directory from which to serve files. 1138 | # Default: {} 1139 | # c.ContentsManager.files_handler_params = {} 1140 | 1141 | ## Glob patterns to hide in file and directory listings. 1142 | # Default: ['__pycache__', '*.pyc', '*.pyo', '.DS_Store', '*~'] 1143 | # c.ContentsManager.hide_globs = ['__pycache__', '*.pyc', '*.pyo', '.DS_Store', '*~'] 1144 | 1145 | ## Python callable or importstring thereof 1146 | # 1147 | # to be called on the path of a file just saved. 1148 | # 1149 | # This can be used to process the file on disk, 1150 | # such as converting the notebook to a script or HTML via nbconvert. 1151 | # 1152 | # It will be called as (all arguments passed by keyword):: 1153 | # 1154 | # hook(os_path=os_path, model=model, contents_manager=instance) 1155 | # 1156 | # - path: the filesystem path to the file just written 1157 | # - model: the model representing the file 1158 | # - contents_manager: this ContentsManager instance 1159 | # Default: None 1160 | # c.ContentsManager.post_save_hook = None 1161 | 1162 | ## Python callable or importstring thereof 1163 | # 1164 | # To be called on a contents model prior to save. 1165 | # 1166 | # This can be used to process the structure, 1167 | # such as removing notebook outputs or other side effects that 1168 | # should not be saved. 1169 | # 1170 | # It will be called as (all arguments passed by keyword):: 1171 | # 1172 | # hook(path=path, model=model, contents_manager=self) 1173 | # 1174 | # - model: the model to be saved. Includes file contents. 1175 | # Modifying this dict will affect the file that is stored. 1176 | # - path: the API path of the save destination 1177 | # - contents_manager: this ContentsManager instance 1178 | # Default: None 1179 | # c.ContentsManager.pre_save_hook = None 1180 | 1181 | ## Preferred starting directory to use for notebooks. This is an API path (`/` 1182 | # separated, relative to root dir) 1183 | # Default: '' 1184 | # c.ContentsManager.preferred_dir = '' 1185 | 1186 | # Default: '/' 1187 | # c.ContentsManager.root_dir = '/' 1188 | 1189 | ## The base name used when creating untitled directories. 1190 | # Default: 'Untitled Folder' 1191 | # c.ContentsManager.untitled_directory = 'Untitled Folder' 1192 | 1193 | ## The base name used when creating untitled files. 1194 | # Default: 'untitled' 1195 | # c.ContentsManager.untitled_file = 'untitled' 1196 | 1197 | ## The base name used when creating untitled notebooks. 1198 | # Default: 'Untitled' 1199 | # c.ContentsManager.untitled_notebook = 'Untitled' 1200 | 1201 | #------------------------------------------------------------------------------ 1202 | # FileManagerMixin(LoggingConfigurable, Configurable) configuration 1203 | #------------------------------------------------------------------------------ 1204 | ## Mixin for ContentsAPI classes that interact with the filesystem. 1205 | # 1206 | # Provides facilities for reading, writing, and copying files. 1207 | # 1208 | # Shared by FileContentsManager and FileCheckpoints. 1209 | # 1210 | # Note ---- Classes using this mixin must provide the following attributes: 1211 | # 1212 | # root_dir : unicode 1213 | # A directory against against which API-style paths are to be resolved. 1214 | # 1215 | # log : logging.Logger 1216 | 1217 | ## Hash algorithm to use for file content, support by hashlib 1218 | # Choices: any of ['sha512_224', 'sha384', 'sha224', 'sha512_256', 'shake_256', 'sha3_384', 'blake2s', 'md5', 'md5-sha1', 'ripemd160', 'sha256', 'sha3_224', 'sha512', 'shake_128', 'sm3', 'sha3_256', 'blake2b', 'sha3_512', 'sha1'] 1219 | # Default: 'sha256' 1220 | # c.FileManagerMixin.hash_algorithm = 'sha256' 1221 | 1222 | ## By default notebooks are saved on disk on a temporary file and then if successfully written, it replaces the old ones. 1223 | # This procedure, namely 'atomic_writing', causes some bugs on file system without operation order enforcement (like some networked fs). 1224 | # If set to False, the new notebook is written directly on the old one which could fail (eg: full filesystem or quota ) 1225 | # Default: True 1226 | # c.FileManagerMixin.use_atomic_writing = True 1227 | 1228 | #------------------------------------------------------------------------------ 1229 | # FileContentsManager(FileManagerMixin, ContentsManager) configuration 1230 | #------------------------------------------------------------------------------ 1231 | ## A file contents manager. 1232 | 1233 | ## Allow access to hidden files 1234 | # See also: ContentsManager.allow_hidden 1235 | # c.FileContentsManager.allow_hidden = False 1236 | 1237 | ## If True, deleting a non-empty directory will always be allowed. 1238 | # WARNING this may result in files being permanently removed; e.g. on Windows, 1239 | # if the data size is too big for the trash/recycle bin the directory will be permanently 1240 | # deleted. If False (default), the non-empty directory will be sent to the trash only 1241 | # if safe. And if ``delete_to_trash`` is True, the directory won't be deleted. 1242 | # Default: False 1243 | # c.FileContentsManager.always_delete_dir = False 1244 | 1245 | # See also: ContentsManager.checkpoints 1246 | # c.FileContentsManager.checkpoints = None 1247 | 1248 | # See also: ContentsManager.checkpoints_class 1249 | # c.FileContentsManager.checkpoints_class = 'jupyter_server.services.contents.checkpoints.Checkpoints' 1250 | 1251 | # See also: ContentsManager.checkpoints_kwargs 1252 | # c.FileContentsManager.checkpoints_kwargs = {} 1253 | 1254 | ## If True (default), deleting files will send them to the 1255 | # platform's trash/recycle bin, where they can be recovered. If False, 1256 | # deleting files really deletes them. 1257 | # Default: True 1258 | # c.FileContentsManager.delete_to_trash = True 1259 | 1260 | # See also: ContentsManager.event_logger 1261 | # c.FileContentsManager.event_logger = None 1262 | 1263 | ## handler class to use when serving raw file requests. 1264 | # See also: ContentsManager.files_handler_class 1265 | # c.FileContentsManager.files_handler_class = 'jupyter_server.files.handlers.FilesHandler' 1266 | 1267 | ## Extra parameters to pass to files_handler_class. 1268 | # See also: ContentsManager.files_handler_params 1269 | # c.FileContentsManager.files_handler_params = {} 1270 | 1271 | ## Hash algorithm to use for file content, support by hashlib 1272 | # See also: FileManagerMixin.hash_algorithm 1273 | # c.FileContentsManager.hash_algorithm = 'sha256' 1274 | 1275 | ## 1276 | # See also: ContentsManager.hide_globs 1277 | # c.FileContentsManager.hide_globs = ['__pycache__', '*.pyc', '*.pyo', '.DS_Store', '*~'] 1278 | 1279 | ## The max folder size that can be copied 1280 | # Default: 500 1281 | # c.FileContentsManager.max_copy_folder_size_mb = 500 1282 | 1283 | ## Python callable or importstring thereof 1284 | # See also: ContentsManager.post_save_hook 1285 | # c.FileContentsManager.post_save_hook = None 1286 | 1287 | ## Python callable or importstring thereof 1288 | # See also: ContentsManager.pre_save_hook 1289 | # c.FileContentsManager.pre_save_hook = None 1290 | 1291 | ## Preferred starting directory to use for notebooks. This is an API path (`/` 1292 | # separated, relative to root dir) 1293 | # See also: ContentsManager.preferred_dir 1294 | # c.FileContentsManager.preferred_dir = '' 1295 | 1296 | # Default: '' 1297 | # c.FileContentsManager.root_dir = '' 1298 | 1299 | ## The base name used when creating untitled directories. 1300 | # See also: ContentsManager.untitled_directory 1301 | # c.FileContentsManager.untitled_directory = 'Untitled Folder' 1302 | 1303 | ## The base name used when creating untitled files. 1304 | # See also: ContentsManager.untitled_file 1305 | # c.FileContentsManager.untitled_file = 'untitled' 1306 | 1307 | ## The base name used when creating untitled notebooks. 1308 | # See also: ContentsManager.untitled_notebook 1309 | # c.FileContentsManager.untitled_notebook = 'Untitled' 1310 | 1311 | ## By default notebooks are saved on disk on a temporary file and then if 1312 | # successfully written, it replaces the old ones. 1313 | # See also: FileManagerMixin.use_atomic_writing 1314 | # c.FileContentsManager.use_atomic_writing = True 1315 | 1316 | #------------------------------------------------------------------------------ 1317 | # AsyncContentsManager(ContentsManager) configuration 1318 | #------------------------------------------------------------------------------ 1319 | ## Base class for serving files and directories asynchronously. 1320 | 1321 | ## Allow access to hidden files 1322 | # See also: ContentsManager.allow_hidden 1323 | # c.AsyncContentsManager.allow_hidden = False 1324 | 1325 | # Default: None 1326 | # c.AsyncContentsManager.checkpoints = None 1327 | 1328 | # Default: 'jupyter_server.services.contents.checkpoints.AsyncCheckpoints' 1329 | # c.AsyncContentsManager.checkpoints_class = 'jupyter_server.services.contents.checkpoints.AsyncCheckpoints' 1330 | 1331 | # Default: {} 1332 | # c.AsyncContentsManager.checkpoints_kwargs = {} 1333 | 1334 | # See also: ContentsManager.event_logger 1335 | # c.AsyncContentsManager.event_logger = None 1336 | 1337 | ## handler class to use when serving raw file requests. 1338 | # See also: ContentsManager.files_handler_class 1339 | # c.AsyncContentsManager.files_handler_class = 'jupyter_server.files.handlers.FilesHandler' 1340 | 1341 | ## Extra parameters to pass to files_handler_class. 1342 | # See also: ContentsManager.files_handler_params 1343 | # c.AsyncContentsManager.files_handler_params = {} 1344 | 1345 | ## 1346 | # See also: ContentsManager.hide_globs 1347 | # c.AsyncContentsManager.hide_globs = ['__pycache__', '*.pyc', '*.pyo', '.DS_Store', '*~'] 1348 | 1349 | ## Python callable or importstring thereof 1350 | # See also: ContentsManager.post_save_hook 1351 | # c.AsyncContentsManager.post_save_hook = None 1352 | 1353 | ## Python callable or importstring thereof 1354 | # See also: ContentsManager.pre_save_hook 1355 | # c.AsyncContentsManager.pre_save_hook = None 1356 | 1357 | ## Preferred starting directory to use for notebooks. This is an API path (`/` 1358 | # separated, relative to root dir) 1359 | # See also: ContentsManager.preferred_dir 1360 | # c.AsyncContentsManager.preferred_dir = '' 1361 | 1362 | # See also: ContentsManager.root_dir 1363 | # c.AsyncContentsManager.root_dir = '/' 1364 | 1365 | ## The base name used when creating untitled directories. 1366 | # See also: ContentsManager.untitled_directory 1367 | # c.AsyncContentsManager.untitled_directory = 'Untitled Folder' 1368 | 1369 | ## The base name used when creating untitled files. 1370 | # See also: ContentsManager.untitled_file 1371 | # c.AsyncContentsManager.untitled_file = 'untitled' 1372 | 1373 | ## The base name used when creating untitled notebooks. 1374 | # See also: ContentsManager.untitled_notebook 1375 | # c.AsyncContentsManager.untitled_notebook = 'Untitled' 1376 | 1377 | #------------------------------------------------------------------------------ 1378 | # AsyncFileManagerMixin(FileManagerMixin) configuration 1379 | #------------------------------------------------------------------------------ 1380 | ## Mixin for ContentsAPI classes that interact with the filesystem 1381 | # asynchronously. 1382 | 1383 | ## Hash algorithm to use for file content, support by hashlib 1384 | # See also: FileManagerMixin.hash_algorithm 1385 | # c.AsyncFileManagerMixin.hash_algorithm = 'sha256' 1386 | 1387 | ## By default notebooks are saved on disk on a temporary file and then if 1388 | # successfully written, it replaces the old ones. 1389 | # See also: FileManagerMixin.use_atomic_writing 1390 | # c.AsyncFileManagerMixin.use_atomic_writing = True 1391 | 1392 | #------------------------------------------------------------------------------ 1393 | # AsyncFileContentsManager(FileContentsManager, AsyncFileManagerMixin, AsyncContentsManager) configuration 1394 | #------------------------------------------------------------------------------ 1395 | ## An async file contents manager. 1396 | 1397 | ## Allow access to hidden files 1398 | # See also: ContentsManager.allow_hidden 1399 | # c.AsyncFileContentsManager.allow_hidden = False 1400 | 1401 | ## If True, deleting a non-empty directory will always be allowed. 1402 | # See also: FileContentsManager.always_delete_dir 1403 | # c.AsyncFileContentsManager.always_delete_dir = False 1404 | 1405 | # See also: AsyncContentsManager.checkpoints 1406 | # c.AsyncFileContentsManager.checkpoints = None 1407 | 1408 | # See also: AsyncContentsManager.checkpoints_class 1409 | # c.AsyncFileContentsManager.checkpoints_class = 'jupyter_server.services.contents.checkpoints.AsyncCheckpoints' 1410 | 1411 | # See also: AsyncContentsManager.checkpoints_kwargs 1412 | # c.AsyncFileContentsManager.checkpoints_kwargs = {} 1413 | 1414 | ## If True (default), deleting files will send them to the 1415 | # See also: FileContentsManager.delete_to_trash 1416 | # c.AsyncFileContentsManager.delete_to_trash = True 1417 | 1418 | # See also: ContentsManager.event_logger 1419 | # c.AsyncFileContentsManager.event_logger = None 1420 | 1421 | ## handler class to use when serving raw file requests. 1422 | # See also: ContentsManager.files_handler_class 1423 | # c.AsyncFileContentsManager.files_handler_class = 'jupyter_server.files.handlers.FilesHandler' 1424 | 1425 | ## Extra parameters to pass to files_handler_class. 1426 | # See also: ContentsManager.files_handler_params 1427 | # c.AsyncFileContentsManager.files_handler_params = {} 1428 | 1429 | ## Hash algorithm to use for file content, support by hashlib 1430 | # See also: FileManagerMixin.hash_algorithm 1431 | # c.AsyncFileContentsManager.hash_algorithm = 'sha256' 1432 | 1433 | ## 1434 | # See also: ContentsManager.hide_globs 1435 | # c.AsyncFileContentsManager.hide_globs = ['__pycache__', '*.pyc', '*.pyo', '.DS_Store', '*~'] 1436 | 1437 | ## The max folder size that can be copied 1438 | # See also: FileContentsManager.max_copy_folder_size_mb 1439 | # c.AsyncFileContentsManager.max_copy_folder_size_mb = 500 1440 | 1441 | ## Python callable or importstring thereof 1442 | # See also: ContentsManager.post_save_hook 1443 | # c.AsyncFileContentsManager.post_save_hook = None 1444 | 1445 | ## Python callable or importstring thereof 1446 | # See also: ContentsManager.pre_save_hook 1447 | # c.AsyncFileContentsManager.pre_save_hook = None 1448 | 1449 | ## Preferred starting directory to use for notebooks. This is an API path (`/` 1450 | # separated, relative to root dir) 1451 | # See also: ContentsManager.preferred_dir 1452 | # c.AsyncFileContentsManager.preferred_dir = '' 1453 | 1454 | # See also: FileContentsManager.root_dir 1455 | # c.AsyncFileContentsManager.root_dir = '' 1456 | 1457 | ## The base name used when creating untitled directories. 1458 | # See also: ContentsManager.untitled_directory 1459 | # c.AsyncFileContentsManager.untitled_directory = 'Untitled Folder' 1460 | 1461 | ## The base name used when creating untitled files. 1462 | # See also: ContentsManager.untitled_file 1463 | # c.AsyncFileContentsManager.untitled_file = 'untitled' 1464 | 1465 | ## The base name used when creating untitled notebooks. 1466 | # See also: ContentsManager.untitled_notebook 1467 | # c.AsyncFileContentsManager.untitled_notebook = 'Untitled' 1468 | 1469 | ## By default notebooks are saved on disk on a temporary file and then if 1470 | # successfully written, it replaces the old ones. 1471 | # See also: FileManagerMixin.use_atomic_writing 1472 | # c.AsyncFileContentsManager.use_atomic_writing = True 1473 | 1474 | #------------------------------------------------------------------------------ 1475 | # NotebookNotary(LoggingConfigurable) configuration 1476 | #------------------------------------------------------------------------------ 1477 | ## A class for computing and verifying notebook signatures. 1478 | 1479 | ## The hashing algorithm used to sign notebooks. 1480 | # Choices: any of ['sha512', 'sha384', 'sha3_256', 'sha3_384', 'blake2b', 'blake2s', 'sha3_512', 'md5', 'sha256', 'sha1', 'sha224', 'sha3_224'] 1481 | # Default: 'sha256' 1482 | # c.NotebookNotary.algorithm = 'sha256' 1483 | 1484 | ## The storage directory for notary secret and database. 1485 | # Default: '' 1486 | # c.NotebookNotary.data_dir = '' 1487 | 1488 | ## The sqlite file in which to store notebook signatures. 1489 | # By default, this will be in your Jupyter data directory. 1490 | # You can set it to ':memory:' to disable sqlite writing to the filesystem. 1491 | # Default: '' 1492 | # c.NotebookNotary.db_file = '' 1493 | 1494 | ## The secret key with which notebooks are signed. 1495 | # Default: b'' 1496 | # c.NotebookNotary.secret = b'' 1497 | 1498 | ## The file where the secret key is stored. 1499 | # Default: '' 1500 | # c.NotebookNotary.secret_file = '' 1501 | 1502 | ## A callable returning the storage backend for notebook signatures. 1503 | # The default uses an SQLite database. 1504 | # Default: traitlets.Undefined 1505 | # c.NotebookNotary.store_factory = traitlets.Undefined 1506 | 1507 | #------------------------------------------------------------------------------ 1508 | # GatewayMappingKernelManager(AsyncMappingKernelManager) configuration 1509 | #------------------------------------------------------------------------------ 1510 | ## Kernel manager that supports remote kernels hosted by Jupyter Kernel or 1511 | # Enterprise Gateway. 1512 | 1513 | ## Whether to send tracebacks to clients on exceptions. 1514 | # See also: MappingKernelManager.allow_tracebacks 1515 | # c.GatewayMappingKernelManager.allow_tracebacks = True 1516 | 1517 | ## White list of allowed kernel message types. 1518 | # See also: MappingKernelManager.allowed_message_types 1519 | # c.GatewayMappingKernelManager.allowed_message_types = [] 1520 | 1521 | ## Whether messages from kernels whose frontends have disconnected should be 1522 | # buffered in-memory. 1523 | # See also: MappingKernelManager.buffer_offline_messages 1524 | # c.GatewayMappingKernelManager.buffer_offline_messages = True 1525 | 1526 | ## Whether to consider culling kernels which are busy. 1527 | # See also: MappingKernelManager.cull_busy 1528 | # c.GatewayMappingKernelManager.cull_busy = False 1529 | 1530 | ## Whether to consider culling kernels which have one or more connections. 1531 | # See also: MappingKernelManager.cull_connected 1532 | # c.GatewayMappingKernelManager.cull_connected = False 1533 | 1534 | ## Timeout (in seconds) after which a kernel is considered idle and ready to be 1535 | # culled. 1536 | # See also: MappingKernelManager.cull_idle_timeout 1537 | # c.GatewayMappingKernelManager.cull_idle_timeout = 0 1538 | 1539 | ## The interval (in seconds) on which to check for idle kernels exceeding the 1540 | # cull timeout value. 1541 | # See also: MappingKernelManager.cull_interval 1542 | # c.GatewayMappingKernelManager.cull_interval = 300 1543 | 1544 | ## The name of the default kernel to start 1545 | # See also: MultiKernelManager.default_kernel_name 1546 | # c.GatewayMappingKernelManager.default_kernel_name = 'python3' 1547 | 1548 | ## Timeout for giving up on a kernel (in seconds). 1549 | # See also: MappingKernelManager.kernel_info_timeout 1550 | # c.GatewayMappingKernelManager.kernel_info_timeout = 60 1551 | 1552 | ## The kernel manager class. This is configurable to allow 1553 | # See also: AsyncMultiKernelManager.kernel_manager_class 1554 | # c.GatewayMappingKernelManager.kernel_manager_class = 'jupyter_client.ioloop.AsyncIOLoopKernelManager' 1555 | 1556 | # See also: MappingKernelManager.root_dir 1557 | # c.GatewayMappingKernelManager.root_dir = '' 1558 | 1559 | ## Share a single zmq.Context to talk to all my kernels 1560 | # See also: MultiKernelManager.shared_context 1561 | # c.GatewayMappingKernelManager.shared_context = True 1562 | 1563 | ## Message to print when allow_tracebacks is False, and an exception occurs 1564 | # See also: MappingKernelManager.traceback_replacement_message 1565 | # c.GatewayMappingKernelManager.traceback_replacement_message = 'An exception occurred at runtime, which is not shown due to security reasons.' 1566 | 1567 | ## List of kernel message types excluded from user activity tracking. 1568 | # See also: MappingKernelManager.untracked_message_types 1569 | # c.GatewayMappingKernelManager.untracked_message_types = ['comm_info_request', 'comm_info_reply', 'kernel_info_request', 'kernel_info_reply', 'shutdown_request', 'shutdown_reply', 'interrupt_request', 'interrupt_reply', 'debug_request', 'debug_reply', 'stream', 'display_data', 'update_display_data', 'execute_input', 'execute_result', 'error', 'status', 'clear_output', 'debug_event', 'input_request', 'input_reply'] 1570 | 1571 | ## Whether to make kernels available before the process has started. The 1572 | # See also: AsyncMultiKernelManager.use_pending_kernels 1573 | # c.GatewayMappingKernelManager.use_pending_kernels = False 1574 | 1575 | #------------------------------------------------------------------------------ 1576 | # GatewayKernelSpecManager(KernelSpecManager) configuration 1577 | #------------------------------------------------------------------------------ 1578 | ## A gateway kernel spec manager. 1579 | 1580 | ## List of allowed kernel names. 1581 | # See also: KernelSpecManager.allowed_kernelspecs 1582 | # c.GatewayKernelSpecManager.allowed_kernelspecs = set() 1583 | 1584 | ## If there is no Python kernelspec registered and the IPython 1585 | # See also: KernelSpecManager.ensure_native_kernel 1586 | # c.GatewayKernelSpecManager.ensure_native_kernel = True 1587 | 1588 | ## The kernel spec class. This is configurable to allow 1589 | # See also: KernelSpecManager.kernel_spec_class 1590 | # c.GatewayKernelSpecManager.kernel_spec_class = 'jupyter_client.kernelspec.KernelSpec' 1591 | 1592 | ## Deprecated, use `KernelSpecManager.allowed_kernelspecs` 1593 | # See also: KernelSpecManager.whitelist 1594 | # c.GatewayKernelSpecManager.whitelist = set() 1595 | 1596 | #------------------------------------------------------------------------------ 1597 | # SessionManager(LoggingConfigurable) configuration 1598 | #------------------------------------------------------------------------------ 1599 | ## A session manager. 1600 | 1601 | ## The filesystem path to SQLite Database file (e.g. 1602 | # /path/to/session_database.db). By default, the session database is stored in- 1603 | # memory (i.e. `:memory:` setting from sqlite3) and does not persist when the 1604 | # current Jupyter Server shuts down. 1605 | # Default: ':memory:' 1606 | # c.SessionManager.database_filepath = ':memory:' 1607 | 1608 | #------------------------------------------------------------------------------ 1609 | # GatewaySessionManager(SessionManager) configuration 1610 | #------------------------------------------------------------------------------ 1611 | ## A gateway session manager. 1612 | 1613 | ## The filesystem path to SQLite Database file (e.g. 1614 | # /path/to/session_database.db). By default, the session database is stored in- 1615 | # memory (i.e. `:memory:` setting from sqlite3) and does not persist when the 1616 | # current Jupyter Server shuts down. 1617 | # See also: SessionManager.database_filepath 1618 | # c.GatewaySessionManager.database_filepath = ':memory:' 1619 | 1620 | #------------------------------------------------------------------------------ 1621 | # BaseKernelWebsocketConnection(LoggingConfigurable) configuration 1622 | #------------------------------------------------------------------------------ 1623 | ## A configurable base class for connecting Kernel WebSockets to ZMQ sockets. 1624 | 1625 | ## Preferred kernel message protocol over websocket to use (default: None). If an 1626 | # empty string is passed, select the legacy protocol. If None, the selected 1627 | # protocol will depend on what the front-end supports (usually the most recent 1628 | # protocol supported by the back-end and the front-end). 1629 | # Default: None 1630 | # c.BaseKernelWebsocketConnection.kernel_ws_protocol = None 1631 | 1632 | # Default: None 1633 | # c.BaseKernelWebsocketConnection.session = None 1634 | 1635 | #------------------------------------------------------------------------------ 1636 | # GatewayWebSocketConnection(BaseKernelWebsocketConnection) configuration 1637 | #------------------------------------------------------------------------------ 1638 | ## Web socket connection that proxies to a kernel/enterprise gateway. 1639 | 1640 | # Default: '' 1641 | # c.GatewayWebSocketConnection.kernel_ws_protocol = '' 1642 | 1643 | # See also: BaseKernelWebsocketConnection.session 1644 | # c.GatewayWebSocketConnection.session = None 1645 | 1646 | #------------------------------------------------------------------------------ 1647 | # GatewayClient(SingletonConfigurable) configuration 1648 | #------------------------------------------------------------------------------ 1649 | ## This class manages the configuration. It's its own singleton class so 1650 | # that we can share these values across all objects. It also contains some 1651 | # options. 1652 | # helper methods to build request arguments out of the various config 1653 | 1654 | ## Accept and manage cookies sent by the service side. This is often useful 1655 | # for load balancers to decide which backend node to use. 1656 | # (JUPYTER_GATEWAY_ACCEPT_COOKIES env var) 1657 | # Default: False 1658 | # c.GatewayClient.accept_cookies = False 1659 | 1660 | ## A comma-separated list of environment variable names that will be included, 1661 | # along with their values, in the kernel startup request. The corresponding 1662 | # `client_envs` configuration value must also be set on the Gateway server - 1663 | # since that configuration value indicates which environmental values to make 1664 | # available to the kernel. (JUPYTER_GATEWAY_ALLOWED_ENVS env var) 1665 | # Default: '' 1666 | # c.GatewayClient.allowed_envs = '' 1667 | 1668 | ## The authorization header's key name (typically 'Authorization') used in the 1669 | # HTTP headers. The header will be formatted as:: 1670 | # 1671 | # {'{auth_header_key}': '{auth_scheme} {auth_token}'} 1672 | # 1673 | # If the authorization header key takes a single value, `auth_scheme` should be 1674 | # set to None and 'auth_token' should be configured to use the appropriate 1675 | # value. 1676 | # 1677 | # (JUPYTER_GATEWAY_AUTH_HEADER_KEY env var) 1678 | # Default: '' 1679 | # c.GatewayClient.auth_header_key = '' 1680 | 1681 | ## The auth scheme, added as a prefix to the authorization token used in the HTTP 1682 | # headers. (JUPYTER_GATEWAY_AUTH_SCHEME env var) 1683 | # Default: '' 1684 | # c.GatewayClient.auth_scheme = '' 1685 | 1686 | ## The authorization token used in the HTTP headers. The header will be formatted 1687 | # as:: 1688 | # 1689 | # {'{auth_header_key}': '{auth_scheme} {auth_token}'} 1690 | # 1691 | # (JUPYTER_GATEWAY_AUTH_TOKEN env var) 1692 | # Default: None 1693 | # c.GatewayClient.auth_token = None 1694 | 1695 | ## The filename of CA certificates or None to use defaults. 1696 | # (JUPYTER_GATEWAY_CA_CERTS env var) 1697 | # Default: None 1698 | # c.GatewayClient.ca_certs = None 1699 | 1700 | ## The filename for client SSL certificate, if any. (JUPYTER_GATEWAY_CLIENT_CERT 1701 | # env var) 1702 | # Default: None 1703 | # c.GatewayClient.client_cert = None 1704 | 1705 | ## The filename for client SSL key, if any. (JUPYTER_GATEWAY_CLIENT_KEY env var) 1706 | # Default: None 1707 | # c.GatewayClient.client_key = None 1708 | 1709 | ## The time allowed for HTTP connection establishment with the Gateway server. 1710 | # (JUPYTER_GATEWAY_CONNECT_TIMEOUT env var) 1711 | # Default: 40.0 1712 | # c.GatewayClient.connect_timeout = 40.0 1713 | 1714 | ## Deprecated, use `GatewayClient.allowed_envs` 1715 | # Default: '' 1716 | # c.GatewayClient.env_whitelist = '' 1717 | 1718 | # Default: None 1719 | # c.GatewayClient.event_logger = None 1720 | 1721 | ## The time allowed for HTTP reconnection with the Gateway server for the first 1722 | # time. Next will be JUPYTER_GATEWAY_RETRY_INTERVAL multiplied by two in factor 1723 | # of numbers of retries but less than JUPYTER_GATEWAY_RETRY_INTERVAL_MAX. 1724 | # (JUPYTER_GATEWAY_RETRY_INTERVAL env var) 1725 | # Default: 1.0 1726 | # c.GatewayClient.gateway_retry_interval = 1.0 1727 | 1728 | ## The maximum time allowed for HTTP reconnection retry with the Gateway server. 1729 | # (JUPYTER_GATEWAY_RETRY_INTERVAL_MAX env var) 1730 | # Default: 30.0 1731 | # c.GatewayClient.gateway_retry_interval_max = 30.0 1732 | 1733 | ## The maximum retries allowed for HTTP reconnection with the Gateway server. 1734 | # (JUPYTER_GATEWAY_RETRY_MAX env var) 1735 | # Default: 5 1736 | # c.GatewayClient.gateway_retry_max = 5 1737 | 1738 | ## The class to use for Gateway token renewal. 1739 | # (JUPYTER_GATEWAY_TOKEN_RENEWER_CLASS env var) 1740 | # Default: 'jupyter_server.gateway.gateway_client.GatewayTokenRenewerBase' 1741 | # c.GatewayClient.gateway_token_renewer_class = 'jupyter_server.gateway.gateway_client.GatewayTokenRenewerBase' 1742 | 1743 | ## Additional HTTP headers to pass on the request. This value will be converted to a dict. 1744 | # (JUPYTER_GATEWAY_HEADERS env var) 1745 | # Default: '{}' 1746 | # c.GatewayClient.headers = '{}' 1747 | 1748 | ## The password for HTTP authentication. (JUPYTER_GATEWAY_HTTP_PWD env var) 1749 | # Default: None 1750 | # c.GatewayClient.http_pwd = None 1751 | 1752 | ## The username for HTTP authentication. (JUPYTER_GATEWAY_HTTP_USER env var) 1753 | # Default: None 1754 | # c.GatewayClient.http_user = None 1755 | 1756 | ## The gateway API endpoint for accessing kernel resources 1757 | # (JUPYTER_GATEWAY_KERNELS_ENDPOINT env var) 1758 | # Default: '/api/kernels' 1759 | # c.GatewayClient.kernels_endpoint = '/api/kernels' 1760 | 1761 | ## The gateway API endpoint for accessing kernelspecs 1762 | # (JUPYTER_GATEWAY_KERNELSPECS_ENDPOINT env var) 1763 | # Default: '/api/kernelspecs' 1764 | # c.GatewayClient.kernelspecs_endpoint = '/api/kernelspecs' 1765 | 1766 | ## The gateway endpoint for accessing kernelspecs resources 1767 | # (JUPYTER_GATEWAY_KERNELSPECS_RESOURCE_ENDPOINT env var) 1768 | # Default: '/kernelspecs' 1769 | # c.GatewayClient.kernelspecs_resource_endpoint = '/kernelspecs' 1770 | 1771 | ## Timeout pad to be ensured between KERNEL_LAUNCH_TIMEOUT and request_timeout 1772 | # such that request_timeout >= KERNEL_LAUNCH_TIMEOUT + launch_timeout_pad. 1773 | # (JUPYTER_GATEWAY_LAUNCH_TIMEOUT_PAD env var) 1774 | # Default: 2.0 1775 | # c.GatewayClient.launch_timeout_pad = 2.0 1776 | 1777 | ## The time allowed for HTTP request completion. (JUPYTER_GATEWAY_REQUEST_TIMEOUT 1778 | # env var) 1779 | # Default: 42.0 1780 | # c.GatewayClient.request_timeout = 42.0 1781 | 1782 | ## The url of the Kernel or Enterprise Gateway server where kernel specifications 1783 | # are defined and kernel management takes place. If defined, this Notebook 1784 | # server acts as a proxy for all kernel management and kernel specification 1785 | # retrieval. (JUPYTER_GATEWAY_URL env var) 1786 | # Default: None 1787 | # c.GatewayClient.url = None 1788 | 1789 | ## For HTTPS requests, determines if server's certificate should be validated or 1790 | # not. (JUPYTER_GATEWAY_VALIDATE_CERT env var) 1791 | # Default: True 1792 | # c.GatewayClient.validate_cert = True 1793 | 1794 | ## The websocket url of the Kernel or Enterprise Gateway server. If not 1795 | # provided, this value will correspond to the value of the Gateway url with 'ws' 1796 | # in place of 'http'. (JUPYTER_GATEWAY_WS_URL env var) 1797 | # Default: None 1798 | # c.GatewayClient.ws_url = None 1799 | 1800 | #------------------------------------------------------------------------------ 1801 | # EventLogger(LoggingConfigurable) configuration 1802 | #------------------------------------------------------------------------------ 1803 | ## An Event logger for emitting structured events. 1804 | # 1805 | # Event schemas must be registered with the EventLogger using the 1806 | # `register_schema` or `register_schema_file` methods. Every schema will be 1807 | # validated against Jupyter Event's metaschema. 1808 | 1809 | ## A list of logging.Handler instances to send events to. 1810 | # 1811 | # When set to None (the default), all events are discarded. 1812 | # Default: None 1813 | # c.EventLogger.handlers = None 1814 | 1815 | #------------------------------------------------------------------------------ 1816 | # ZMQChannelsWebsocketConnection(BaseKernelWebsocketConnection) configuration 1817 | #------------------------------------------------------------------------------ 1818 | ## A Jupyter Server Websocket Connection 1819 | 1820 | ## (bytes/sec) 1821 | # Maximum rate at which stream output can be sent on iopub before they are 1822 | # limited. 1823 | # Default: 1000000 1824 | # c.ZMQChannelsWebsocketConnection.iopub_data_rate_limit = 1000000 1825 | 1826 | ## (msgs/sec) 1827 | # Maximum rate at which messages can be sent on iopub before they are 1828 | # limited. 1829 | # Default: 1000 1830 | # c.ZMQChannelsWebsocketConnection.iopub_msg_rate_limit = 1000 1831 | 1832 | ## Preferred kernel message protocol over websocket to use (default: None). If an 1833 | # empty string is passed, select the legacy protocol. If None, the selected 1834 | # protocol will depend on what the front-end supports (usually the most recent 1835 | # protocol supported by the back-end and the front-end). 1836 | # See also: BaseKernelWebsocketConnection.kernel_ws_protocol 1837 | # c.ZMQChannelsWebsocketConnection.kernel_ws_protocol = None 1838 | 1839 | ## Whether to limit the rate of IOPub messages (default: True). If True, use 1840 | # iopub_msg_rate_limit, iopub_data_rate_limit and/or rate_limit_window to tune 1841 | # the rate. 1842 | # Default: True 1843 | # c.ZMQChannelsWebsocketConnection.limit_rate = True 1844 | 1845 | ## (sec) Time window used to 1846 | # check the message and data rate limits. 1847 | # Default: 3 1848 | # c.ZMQChannelsWebsocketConnection.rate_limit_window = 3 1849 | 1850 | # See also: BaseKernelWebsocketConnection.session 1851 | # c.ZMQChannelsWebsocketConnection.session = None 1852 | 1853 | print("\nSummary of Jupyter Configuration:\n", c, "\n", sep="") 1854 | --------------------------------------------------------------------------------