diff --git a/.babelrc b/.babelrc deleted file mode 100644 index cea726b873..0000000000 --- a/.babelrc +++ /dev/null @@ -1,3 +0,0 @@ -{ - "presets": ["es2015"], -} diff --git a/.bowerrc b/.bowerrc deleted file mode 100644 index b1c953d5ac..0000000000 --- a/.bowerrc +++ /dev/null @@ -1,3 +0,0 @@ -{ - "directory": "notebook/static/components" -} \ No newline at end of file diff --git a/.bumpversion.cfg b/.bumpversion.cfg new file mode 100644 index 0000000000..54c50538da --- /dev/null +++ b/.bumpversion.cfg @@ -0,0 +1,19 @@ +[bumpversion] +current_version = 7, 0, 0, 'alpha', 0 +commit = False +tag = False +parse = (?P\d+)\,\ (?P\d+)\,\ (?P\d+)\,\ \'(?P\S+)\'\,\ (?P\d+) +serialize = + {major}, {minor}, {patch}, '{release}', {build} + +[bumpversion:part:release] +optional_value = final +values = + alpha + beta + candidate + final + +[bumpversion:part:build] + +[bumpversion:file:notebook/_version.py] diff --git a/.eslintignore b/.eslintignore index db228f0817..5a18b7b26a 100644 --- a/.eslintignore +++ b/.eslintignore @@ -1,5 +1,22 @@ -*.min.js -*components* -*node_modules* -*built* -*build* +lint-staged.config.js +.eslintrc.js + +node_modules +**/build +**/lib +**/node_modules +**/mock_packages +**/static +**/typings +**/schemas +**/themes +coverage +*.map.js +*.bundle.js + +# jetbrains IDE stuff +.idea/ + +# ms IDE stuff +.history/ +.vscode/ diff --git a/.eslintrc.js b/.eslintrc.js new file mode 100644 index 0000000000..0e6b6a7878 --- /dev/null +++ b/.eslintrc.js @@ -0,0 +1,57 @@ +module.exports = { + env: { + browser: true, + es6: true, + commonjs: true, + node: true, + 'jest/globals': true + }, + root: true, + extends: [ + 'eslint:recommended', + 'plugin:@typescript-eslint/eslint-recommended', + 'plugin:@typescript-eslint/recommended', + 'plugin:prettier/recommended', + 'plugin:react/recommended', + 'plugin:jest/recommended' + ], + parser: '@typescript-eslint/parser', + parserOptions: { + project: 'tsconfig.eslint.json', + sourceType: 'module' + }, + plugins: ['@typescript-eslint', 'jest'], + rules: { + '@typescript-eslint/naming-convention': [ + 'error', + { + selector: 'interface', + format: ['PascalCase'], + custom: { + regex: '^I[A-Z]', + match: true + } + } + ], + '@typescript-eslint/no-unused-vars': ['warn', { args: 'none' }], + '@typescript-eslint/no-explicit-any': 'off', + '@typescript-eslint/no-namespace': 'off', + '@typescript-eslint/no-var-requires': 'off', + '@typescript-eslint/no-use-before-define': 'off', + '@typescript-eslint/no-empty-interface': 'off', + '@typescript-eslint/quotes': [ + 'error', + 'single', + { avoidEscape: true, allowTemplateLiterals: false } + ], + 'jest/no-done-callback': 'off', + curly: ['error', 'all'], + eqeqeq: 'error', + 'prefer-arrow-callback': 'error' + }, + settings: { + react: { + version: 'detect' + } + } +}; diff --git a/.eslintrc.json b/.eslintrc.json index b7bfd661ca..3b41a5ad9f 100644 --- a/.eslintrc.json +++ b/.eslintrc.json @@ -1,13 +1,13 @@ { - "parserOptions": { - "ecmaVersion": 6, - "sourceType": "module" - }, - "rules": { - "semi": 1, - "no-cond-assign": 2, - "no-debugger": 2, - "comma-dangle": 0, - "no-unreachable" : 2 - } + "parserOptions": { + "ecmaVersion": 6, + "sourceType": "module" + }, + "rules": { + "semi": 1, + "no-cond-assign": 2, + "no-debugger": 2, + "comma-dangle": 0, + "no-unreachable": 2 + } } diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md index 17d7b7b212..637d009caa 100644 --- a/.github/ISSUE_TEMPLATE/bug_report.md +++ b/.github/ISSUE_TEMPLATE/bug_report.md @@ -1,13 +1,11 @@ --- + name: Is this a bug in Notebook? Open an issue. about: If you're not sure, feel free to post your question on Jupyter's Discourse channel. title: '' labels: '' assignees: '' - ---- - - + --> **Describe the bug** A clear and concise description of what the bug is. **To Reproduce** Steps to reproduce the behavior: + 1. Go to '...' 2. Click on '....' 3. Scroll down to '....' @@ -42,9 +41,10 @@ A clear and concise description of what you expected to happen. If applicable, add screenshots to help explain your problem. **Desktop (please complete the following information):** - - OS: [e.g. iOS] - - Browser [e.g. chrome, safari] - - Version [e.g. 22] + +- OS: [e.g. iOS] +- Browser [e.g. chrome, safari] +- Version [e.g. 22] **Additional context** Add any other context about the problem here. diff --git a/.github/actions/build-dist/action.yml b/.github/actions/build-dist/action.yml new file mode 100644 index 0000000000..0154822567 --- /dev/null +++ b/.github/actions/build-dist/action.yml @@ -0,0 +1,44 @@ +name: "Build Jupyter Notebook" +description: "Build Jupyter Notebook from source" +runs: + using: "composite" + steps: + - name: Base Setup + uses: jupyterlab/maintainer-tools/.github/actions/base-setup@v1 + + - name: Install dependencies + shell: bash + run: | + python -m pip install --upgrade jupyter_packaging~=0.10 "jupyterlab>=4.0.0a20,<5" build + + - name: Build pypi distributions + shell: bash + run: | + python -m build + + - name: Build npm distributions + shell: bash + run: | + mkdir pkgs + jlpm lerna exec -- npm pack + cp packages/*/*.tgz pkgs + + - name: Build checksum file + shell: bash + run: | + cd dist + sha256sum * | tee SHA256SUMS + cd ../pkgs + sha256sum * | tee SHA256SUMS + + - name: Upload distributions + uses: actions/upload-artifact@v2 + with: + name: notebook-dist-${{ github.run_number }} + path: ./dist + + - name: Upload distributions + uses: actions/upload-artifact@v2 + with: + name: notebook-pkgs-${{ github.run_number }} + path: ./pkgs diff --git a/.github/workflows/binder.yml b/.github/workflows/binder.yml new file mode 100644 index 0000000000..ad9a237e9f --- /dev/null +++ b/.github/workflows/binder.yml @@ -0,0 +1,15 @@ +name: Binder Badge +on: + pull_request_target: + types: [opened] + +jobs: + binder: + runs-on: ubuntu-latest + permissions: + pull-requests: write + steps: + - uses: jupyterlab/maintainer-tools/.github/actions/binder-link@v1 + with: + github_token: ${{ secrets.github_token }} + url_path: tree diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml new file mode 100644 index 0000000000..8d1ce2f146 --- /dev/null +++ b/.github/workflows/build.yml @@ -0,0 +1,110 @@ +name: Build + +on: + push: + branches: + - '*' + pull_request: + branches: + - '*' + +permissions: + contents: + write + +env: + PIP_DISABLE_PIP_VERSION_CHECK: 1 + +defaults: + run: + shell: bash -l {0} + +jobs: + build: + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v2 + + - name: Build + uses: ./.github/actions/build-dist + + test: + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v2 + + - name: Base Setup + uses: jupyterlab/maintainer-tools/.github/actions/base-setup@v1 + + - name: Install dependencies + run: | + python -m pip install -U jupyter_packaging~=0.10 + + - name: Install the package + run: | + python -m pip install . + jupyter labextension list 2>&1 | grep -ie "@jupyter-notebook/lab-extension.*enabled.*ok" - + jupyter server extension list 2>&1 | grep -ie "notebook.*enabled" - + python -m jupyterlab.browser_check + + - name: Lint + run: | + jlpm + jlpm run eslint:check + jlpm run prettier:check + + - name: Test + run: | + jlpm run build:test + jlpm run test + + install: + needs: [build] + runs-on: ${{ matrix.os }}-latest + strategy: + fail-fast: false + matrix: + os: [ubuntu, macos, windows] + python: ['3.7', '3.10'] + include: + - python: '3.7' + dist: 'notebook*.tar.gz' + - python: '3.10' + dist: 'notebook*.whl' + - os: windows + py_cmd: python + - os: macos + py_cmd: python3 + - os: ubuntu + py_cmd: python + steps: + - name: Install Python + uses: actions/setup-python@v2 + with: + python-version: ${{ matrix.python }} + architecture: 'x64' + - uses: actions/download-artifact@v2 + with: + name: notebook-dist-${{ github.run_number }} + path: ./dist + - name: Install the prerequisites + run: | + ${{ matrix.py_cmd }} -m pip install pip wheel + - name: Install the package + run: | + cd dist + ${{ matrix.py_cmd }} -m pip install -vv ${{ matrix.dist }} + - name: Validate environment + run: | + ${{ matrix.py_cmd }} -m pip freeze + ${{ matrix.py_cmd }} -m pip check + - name: Validate the install + run: | + jupyter labextension list + jupyter labextension list 2>&1 | grep -ie "@jupyter-notebook/lab-extension.*enabled.*ok" - + jupyter server extension list + jupyter server extension list 2>&1 | grep -ie "notebook.*enabled" - + jupyter notebook --version + jupyter notebook --help diff --git a/.github/workflows/buildutils.yml b/.github/workflows/buildutils.yml new file mode 100644 index 0000000000..d915f884e9 --- /dev/null +++ b/.github/workflows/buildutils.yml @@ -0,0 +1,80 @@ +name: Build Utilities + +on: + push: + branches: '*' + pull_request: + branches: '*' + +defaults: + run: + shell: bash -l {0} + +jobs: + versioning: + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v2 + + - name: Base Setup + uses: jupyterlab/maintainer-tools/.github/actions/base-setup@v1 + + - name: Install dependencies + run: | + python -m pip install -U "jupyterlab>=4.0.0a20,<5" jupyter_packaging~=0.10 + jlpm + jlpm run build + + - name: Configure git identity to commit + run: | + git config --global user.email "you@example.com" + git config --global user.name "Your Name" + + - name: Reset version + run: | + # TODO: improve this with a mock package? + # This step is to ensure the workflow always starts with a final version + sed -i -E "s/VersionInfo\(.*\)/VersionInfo\(9, 8, 7, 'final', 0\)/" notebook/_version.py + sed -i -E "s/current_version = .*/current_version = 9, 8, 7, 'final', 0/" .bumpversion.cfg + jlpm run lerna version 9.8.7 --no-push --force-publish --no-git-tag-version --yes + git commit -am "Release 9.8.7" + + - name: Patch Release + run: | + jlpm release:patch --force + + - name: Minor Release + run: | + jlpm release:bump minor --force + + - name: Release Cycle + run: | + # beta + jlpm release:bump release --force + # rc + jlpm release:bump release --force + # final + jlpm release:bump release --force + + - name: Major Release + run: | + jlpm release:bump major --force + + npm: + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v2 + + - name: Install Python + uses: actions/setup-python@v2 + with: + python-version: '3.9' + architecture: 'x64' + + - name: Install dependencies + run: | + python -m pip install -U "jupyterlab>=4.0.0a20,<5" jupyter_packaging~=0.10 pip + jlpm + jlpm run build diff --git a/.github/workflows/check-release.yml b/.github/workflows/check-release.yml index be28522243..e08cceefe9 100644 --- a/.github/workflows/check-release.yml +++ b/.github/workflows/check-release.yml @@ -1,9 +1,11 @@ name: Check Release on: push: - branches: ["master"] + branches: + - "*" pull_request: - branches: ["*"] + branches: + - "*" permissions: contents: @@ -12,54 +14,23 @@ permissions: jobs: check_release: runs-on: ubuntu-latest - strategy: - matrix: - group: [check_release, link_check] steps: - name: Checkout uses: actions/checkout@v2 - - name: Install Python - uses: actions/setup-python@v2 - with: - python-version: 3.9 - architecture: "x64" - - name: Install node - uses: actions/setup-node@v2 - with: - node-version: '14.x' - - name: Get pip cache dir - id: pip-cache - run: | - echo "::set-output name=dir::$(pip cache dir)" - - name: Cache pip - uses: actions/cache@v1 - with: - path: ${{ steps.pip-cache.outputs.dir }} - key: ${{ runner.os }}-pip-${{ hashFiles('setup.cfg') }} - restore-keys: | - ${{ runner.os }}-pip- - ${{ runner.os }}-pip- - - name: Cache checked links - if: ${{ matrix.group == 'link_check' }} - uses: actions/cache@v2 - with: - path: ~/.cache/pytest-link-check - key: ${{ runner.os }}-linkcheck-${{ hashFiles('**/*.md', '**/*.rst') }}-md-links - restore-keys: | - ${{ runner.os }}-linkcheck- + + - name: Base Setup + uses: jupyterlab/maintainer-tools/.github/actions/base-setup@v1 + - name: Upgrade packaging dependencies run: | - pip install --upgrade pip setuptools wheel --user + pip install --upgrade jupyter-packaging~=0.10 --user + - name: Install Dependencies run: | - pip install -e . + pip install . + - name: Check Release - if: ${{ matrix.group == 'check_release' }} - env: - TWINE_PASSWORD: ${{ secrets.TEST_PYPI_TOKEN }} uses: jupyter-server/jupyter_releaser/.github/actions/check-release@v1 with: token: ${{ secrets.GITHUB_TOKEN }} - - name: Check Links - if: ${{ matrix.group == 'link_check' }} - uses: jupyter-server/jupyter_releaser/.github/actions/check-links@v1 + version_spec: next diff --git a/.github/workflows/js.yml b/.github/workflows/js.yml deleted file mode 100644 index 9ce5424e20..0000000000 --- a/.github/workflows/js.yml +++ /dev/null @@ -1,61 +0,0 @@ -name: Linux JS Tests - -on: - push: - branches: '*' - pull_request: - branches: '*' - -jobs: - build: - runs-on: ${{ matrix.os }}-latest - strategy: - fail-fast: false - matrix: - os: [ubuntu, macos] - group: [notebook, base, services] - steps: - - name: Checkout - uses: actions/checkout@v2 - - name: Set up Python - uses: actions/setup-python@v1 - with: - python-version: 3.8 - - name: Set up Node - uses: actions/setup-node@v1 - with: - node-version: '12.x' - - - name: Cache node modules - uses: actions/cache@v2 - env: - cache-name: cache-node-modules - with: - # npm cache files are stored in `~/.npm` on Linux/macOS - path: ~/.npm - key: ${{ runner.os }}-build-${{ env.cache-name }}-${{ hashFiles('**/package-lock.json') }} - restore-keys: | - ${{ runner.os }}-build-${{ env.cache-name }}- - ${{ runner.os }}-build- - ${{ runner.os }}- - - - name: Cache pip on Linux - uses: actions/cache@v1 - if: startsWith(runner.os, 'Linux') - with: - path: ~/.cache/pip - key: ${{ runner.os }}-pip-${{ matrix.python }}-${{ hashFiles('**/requirements.txt', 'setup.py') }} - restore-keys: | - ${{ runner.os }}-pip-${{ matrix.python }} - - - name: Install dependencies - run: | - pip install --upgrade pip - pip install --upgrade setuptools wheel - npm install - npm install -g casperjs@1.1.3 phantomjs-prebuilt@2.1.7 - pip install .[test] - - - name: Run Tests - run: | - python -m notebook.jstest ${{ matrix.group }} diff --git a/.github/workflows/python-nbconvert.yml b/.github/workflows/python-nbconvert.yml deleted file mode 100644 index d7dfd07c1d..0000000000 --- a/.github/workflows/python-nbconvert.yml +++ /dev/null @@ -1,53 +0,0 @@ -# The NBConvert Service requires pandoc. Instead of testing -# Pandoc on every operating system (which should already be -# done in nbconvert directly), we'll only test these services -# on ubuntu where we can easily load Pandoc from a Github -# Actions docker image (this docker image is not on other -# operating systems). -name: NBConvert Service Tests -on: - push: - branches: '*' - pull_request: - branches: '*' -jobs: - build: - runs-on: ubuntu-latest - strategy: - fail-fast: false - matrix: - python-version: [ '3.7', '3.8', '3.9', '3.10' ] - steps: - - name: Checkout - uses: actions/checkout@v1 - - name: Install Python ${{ matrix.python-version }} - uses: actions/setup-python@v1 - with: - python-version: ${{ matrix.python-version }} - architecture: 'x64' - - name: Setup Pandoc - uses: r-lib/actions/setup-pandoc@v1 - - name: Upgrade packaging dependencies - run: | - pip install --upgrade pip setuptools wheel - - name: Get pip cache dir - id: pip-cache - run: | - echo "::set-output name=dir::$(pip cache dir)" - - name: Cache pip - uses: actions/cache@v1 - with: - path: ${{ steps.pip-cache.outputs.dir }} - key: ${{ runner.os }}-pip-${{ matrix.python-version }}-${{ hashFiles('setup.py') }} - restore-keys: | - ${{ runner.os }}-pip-${{ matrix.python-version }}- - ${{ runner.os }}-pip- - - name: Install the Python dependencies - run: | - pip install -e .[test] - - name: Run NBConvert Tests - run: | - pytest notebook/nbconvert/tests/ - - name: Run NBConvert Service Tests - run: | - pytest notebook/services/nbconvert/tests/ diff --git a/.github/workflows/python.yml b/.github/workflows/python.yml deleted file mode 100644 index 282ea1fd85..0000000000 --- a/.github/workflows/python.yml +++ /dev/null @@ -1,53 +0,0 @@ -name: Python Tests -on: - push: - branches: '*' - pull_request: - branches: '*' -jobs: - build: - runs-on: ${{ matrix.os }}-latest - strategy: - fail-fast: false - matrix: - os: [ubuntu, macos, windows] - python-version: [ '3.7', '3.8', '3.9', '3.10' ] - steps: - - name: Checkout - uses: actions/checkout@v1 - - name: Install Python ${{ matrix.python-version }} - uses: actions/setup-python@v1 - with: - python-version: ${{ matrix.python-version }} - architecture: 'x64' - - name: Upgrade packaging dependencies - run: | - pip install --upgrade pip setuptools wheel --user - - name: Get pip cache dir - id: pip-cache - run: | - echo "::set-output name=dir::$(pip cache dir)" - - name: Cache pip - uses: actions/cache@v1 - with: - path: ${{ steps.pip-cache.outputs.dir }} - key: ${{ runner.os }}-pip-${{ matrix.python-version }}-${{ hashFiles('setup.py') }} - restore-keys: | - ${{ runner.os }}-pip-${{ matrix.python-version }}- - ${{ runner.os }}-pip- - - name: Install the Python dependencies - run: | - pip install -e .[test] codecov - - name: List installed packages - run: | - pip freeze - pip check - - name: Run Server-side tests - run: | - pytest -vv --cov notebook --cov-branch --cov-report term-missing:skip-covered --ignore-glob=notebook/tests/selenium/* --ignore-glob=notebook/nbconvert/tests/* --ignore-glob=notebook/services/nbconvert/tests/* - - name: Run Integration Tests - run: | - pytest -v notebook/tests/test_notebookapp_integration.py --integration_tests - - name: Coverage - run: | - codecov diff --git a/.github/workflows/selenium.yml b/.github/workflows/selenium.yml deleted file mode 100644 index b0c470eb87..0000000000 --- a/.github/workflows/selenium.yml +++ /dev/null @@ -1,46 +0,0 @@ -name: Selenium Tests - -on: - push: - branches: '*' - pull_request: - branches: '*' -jobs: - build: - runs-on: ${{ matrix.os }}-latest - strategy: - fail-fast: false - matrix: - os: [ubuntu, macos] - python-version: [ '3.7', '3.8', '3.9', '3.10' ] - steps: - - name: Checkout - uses: actions/checkout@v2 - - - name: Set up Python - uses: actions/setup-python@v1 - with: - python-version: ${{ matrix.python-version }} - architecture: 'x64' - - - name: Set up Node - uses: actions/setup-node@v1 - with: - node-version: '12.x' - - - name: Install JS - run: | - npm install - - - name: Install Python dependencies - run: | - python -m pip install -U pip setuptools wheel - pip install --upgrade selenium - pip install pytest - pip install .[test] - - - name: Run Tests - run: | - export JUPYTER_TEST_BROWSER=firefox - export MOZ_HEADLESS=1 - pytest -sv notebook/tests/selenium diff --git a/.github/workflows/ui-tests.yml b/.github/workflows/ui-tests.yml new file mode 100644 index 0000000000..7428a6f1de --- /dev/null +++ b/.github/workflows/ui-tests.yml @@ -0,0 +1,100 @@ +name: UI Tests + +on: [push, pull_request] + +jobs: + build: + name: Build + runs-on: ubuntu-latest + + steps: + - name: Checkout + uses: actions/checkout@v2 + + - name: Build + uses: ./.github/actions/build-dist + + ui-tests: + needs: [build] + runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + browser: [firefox, chromium] + steps: + - name: Checkout + uses: actions/checkout@v2 + + - name: Install Python + uses: actions/setup-python@v2 + with: + python-version: '3.9' + architecture: 'x64' + + - uses: actions/download-artifact@v2 + with: + name: notebook-dist-${{ github.run_number }} + path: ./dist + + - name: Install the prerequisites + run: | + python -m pip install pip wheel + + - name: Install the package + run: | + cd dist + python -m pip install -vv notebook*.whl + + - name: Install the test dependencies + run: | + cd ui-tests + jlpm --frozen-lockfile + jlpm playwright install + + - name: Start Jupyter Notebook + run: | + cd ui-tests + jlpm start:detached + + - name: Wait for Jupyter Notebook + uses: ifaxity/wait-on-action@v1 + with: + resource: http-get://127.0.0.1:8888/ + timeout: 360000 + + - name: Test + run: | + cd ui-tests + jlpm test --browser ${{ matrix.browser }} + + - name: Upload Playwright Test assets + if: always() + uses: actions/upload-artifact@v2 + with: + name: notebook-${{ matrix.browser }}-test-assets + path: | + ui-tests/test-results + + - name: Upload Playwright Test report + if: always() + uses: actions/upload-artifact@v2 + with: + name: notebook-${{ matrix.browser }}-test-report + path: | + ui-tests/playwright-report + + - name: Update snapshots + if: failure() + run: | + cd ui-tests + # remove previous snapshots from other browser + jlpm rimraf "test/**/*-snapshots/*.png" + # generate new snapshots + jlpm run test:update --browser ${{ matrix.browser }} + + - name: Upload updated snapshots + if: failure() + uses: actions/upload-artifact@v2 + with: + name: notebook-${{ matrix.browser }}-updated-snapshots + path: ui-tests/test \ No newline at end of file diff --git a/.gitignore b/.gitignore index f040e4811c..4c4b5db58b 100644 --- a/.gitignore +++ b/.gitignore @@ -1,58 +1,126 @@ -MANIFEST -build -dist -_build -docs/man/*.gz -docs/source/api/generated -docs/source/config.rst -docs/gh-pages -notebook/i18n/*/LC_MESSAGES/*.mo -notebook/i18n/*/LC_MESSAGES/nbjs.json -notebook/static/components -notebook/static/style/*.min.css* -notebook/static/*/js/built/ -notebook/static/*/built/ -notebook/static/built/ -notebook/static/*/js/main.min.js* -notebook/static/lab/*bundle.js -node_modules -*.py[co] -__pycache__ -*.egg-info -*~ -*.bak +*.bundle.* +lib/ +node_modules/ +*.egg-info/ .ipynb_checkpoints -.tox -.DS_Store -\#*# -.#* +*.tsbuildinfo + +# Created by https://www.gitignore.io/api/python +# Edit at https://www.gitignore.io/?templates=python + +### Python ### +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +pip-wheel-metadata/ +share/python-wheels/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ .coverage -.pytest_cache -src - -*.swp -*.map -.idea/ -Read the Docs -config.rst -*.iml -/.project -/.pydevproject - -package-lock.json -geckodriver.log -*.iml - -# jetbrains IDE stuff -*.iml -.idea/ - -# ms IDE stuff -*.code-workspace -.history -.vscode +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +.hypothesis/ +.pytest_cache/ + +# Translations +*.mo +*.pot + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +target/ -# copied changelog -docs/source/changelog.md +# pyenv +.python-version -.jupyter_releaser_checkout +# celery beat schedule file +celerybeat-schedule + +# SageMath parsed files +*.sage.py + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# Mr Developer +.mr.developer.cfg +.project +.pydevproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# OS X stuff +*.DS_Store + +# End of https://www.gitignore.io/api/python + +_temp_extension +junit.xml +[uU]ntitled* +notebook/static/* +!notebook/static/favicons +notebook/labextension +notebook/schemas + +# playwright +ui-tests/test-results +ui-tests/playwright-report + +# VSCode +.vscode diff --git a/.mailmap b/.mailmap deleted file mode 100644 index bd6544e25c..0000000000 --- a/.mailmap +++ /dev/null @@ -1,149 +0,0 @@ -A. J. Holyoake ajholyoake -Aaron Culich Aaron Culich -Aron Ahmadia ahmadia -Benjamin Ragan-Kelley -Benjamin Ragan-Kelley Min RK -Benjamin Ragan-Kelley MinRK -Barry Wark Barry Wark -Ben Edwards Ben Edwards -Bradley M. Froehle Bradley M. Froehle -Bradley M. Froehle Bradley Froehle -Brandon Parsons Brandon Parsons -Brian E. Granger Brian Granger -Brian E. Granger Brian Granger <> -Brian E. Granger bgranger <> -Brian E. Granger bgranger -Christoph Gohlke cgohlke -Cyrille Rossant rossant -Damián Avila damianavila -Damián Avila damianavila -Damon Allen damontallen -Darren Dale darren.dale <> -Darren Dale Darren Dale <> -Dav Clark Dav Clark <> -Dav Clark Dav Clark -David Hirschfeld dhirschfeld -David P. Sanders David P. Sanders -David Warde-Farley David Warde-Farley <> -Doug Blank Doug Blank -Eugene Van den Bulke Eugene Van den Bulke -Evan Patterson -Evan Patterson -Evan Patterson -Evan Patterson -Evan Patterson epatters -Evan Patterson epatters -Ernie French Ernie French -Ernie French ernie french -Ernie French ernop -Fernando Perez -Fernando Perez Fernando Perez -Fernando Perez fperez <> -Fernando Perez fptest <> -Fernando Perez fptest1 <> -Fernando Perez Fernando Perez -Fernando Perez Fernando Perez <> -Fernando Perez Fernando Perez -Frank Murphy Frank Murphy -Gabriel Becker gmbecker -Gael Varoquaux gael.varoquaux <> -Gael Varoquaux gvaroquaux -Gael Varoquaux Gael Varoquaux <> -Ingolf Becker watercrossing -Jake Vanderplas Jake Vanderplas -Jakob Gager jakobgager -Jakob Gager jakobgager -Jakob Gager jakobgager -Jason Grout -Jason Grout -Jason Gors jason gors -Jason Gors jgors -Jens Hedegaard Nielsen Jens Hedegaard Nielsen -Jens Hedegaard Nielsen Jens H Nielsen -Jens Hedegaard Nielsen Jens H. Nielsen -Jez Ng Jez Ng -Jonathan Frederic Jonathan Frederic -Jonathan Frederic Jonathan Frederic -Jonathan Frederic Jonathan Frederic -Jonathan Frederic jon -Jonathan Frederic U-Jon-PC\Jon -Jonathan March Jonathan March -Jonathan March jdmarch -Jörgen Stenarson Jörgen Stenarson -Jörgen Stenarson Jorgen Stenarson -Jörgen Stenarson Jorgen Stenarson <> -Jörgen Stenarson jstenar -Jörgen Stenarson jstenar <> -Jörgen Stenarson Jörgen Stenarson -Juergen Hasch juhasch -Juergen Hasch juhasch -Julia Evans Julia Evans -Kester Tong KesterTong -Kyle Kelley Kyle Kelley -Kyle Kelley rgbkrk -Laurent Dufréchou -Laurent Dufréchou -Laurent Dufréchou laurent dufrechou <> -Laurent Dufréchou laurent.dufrechou <> -Laurent Dufréchou Laurent Dufrechou <> -Laurent Dufréchou laurent.dufrechou@gmail.com <> -Laurent Dufréchou ldufrechou -Lorena Pantano Lorena -Luis Pedro Coelho Luis Pedro Coelho -Marc Molla marcmolla -Martín Gaitán Martín Gaitán -Matthias Bussonnier Matthias BUSSONNIER -Matthias Bussonnier Bussonnier Matthias -Matthias Bussonnier Matthias BUSSONNIER -Matthias Bussonnier Matthias Bussonnier -Michael Droettboom Michael Droettboom -Nicholas Bollweg Nicholas Bollweg (Nick) -Nicolas Rougier -Nikolay Koldunov Nikolay Koldunov -Omar Andrés Zapata Mesa Omar Andres Zapata Mesa -Omar Andrés Zapata Mesa Omar Andres Zapata Mesa -Pankaj Pandey Pankaj Pandey -Pascal Schetelat pascal-schetelat -Paul Ivanov Paul Ivanov -Pauli Virtanen Pauli Virtanen <> -Pauli Virtanen Pauli Virtanen -Pierre Gerold Pierre Gerold -Pietro Berkes Pietro Berkes -Piti Ongmongkolkul piti118 -Prabhu Ramachandran Prabhu Ramachandran <> -Puneeth Chaganti Puneeth Chaganti -Robert Kern rkern <> -Robert Kern Robert Kern -Robert Kern Robert Kern -Robert Kern Robert Kern <> -Robert Marchman Robert Marchman -Satrajit Ghosh Satrajit Ghosh -Satrajit Ghosh Satrajit Ghosh -Scott Sanderson Scott Sanderson -smithj1 smithj1 -smithj1 smithj1 -Steven Johnson stevenJohnson -Steven Silvester blink1073 -S. Weber s8weber -Stefan van der Walt Stefan van der Walt -Silvia Vinyes Silvia -Silvia Vinyes silviav12 -Sylvain Corlay -Sylvain Corlay sylvain.corlay -Ted Drain TD22057 -Théophile Studer Théophile Studer -Thomas Kluyver Thomas -Thomas Spura Thomas Spura -Timo Paulssen timo -vds vds2212 -vds vds -Ville M. Vainio -Ville M. Vainio ville -Ville M. Vainio ville -Ville M. Vainio vivainio <> -Ville M. Vainio Ville M. Vainio -Ville M. Vainio Ville M. Vainio -Walter Doerwald walter.doerwald <> -Walter Doerwald Walter Doerwald <> -W. Trevor King W. Trevor King -Yoval P. y-p diff --git a/.prettierignore b/.prettierignore new file mode 100644 index 0000000000..9e52555399 --- /dev/null +++ b/.prettierignore @@ -0,0 +1,7 @@ +node_modules +**/node_modules +**/lib +**/package.json +**/static +**/labextension +build diff --git a/.prettierrc b/.prettierrc new file mode 100644 index 0000000000..544138be45 --- /dev/null +++ b/.prettierrc @@ -0,0 +1,3 @@ +{ + "singleQuote": true +} diff --git a/CHANGELOG.md b/CHANGELOG.md index e0fef4f52f..0fd7634f73 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -203,24 +203,24 @@ Use `pip install pip --upgrade` to upgrade pip. Check pip version with ### Merged PRs -* Add square logo and desktop entry files [#6010](https://github.com/jupyter/notebook/pull/6010) ([@befeleme](https://github.com/befeleme)) -* Modernize Changelog [#6008](https://github.com/jupyter/notebook/pull/6008) ([@afshin](https://github.com/afshin)) -* Add missing "import inspect" [#5999](https://github.com/jupyter/notebook/pull/5999) ([@mgeier](https://github.com/mgeier)) -* Add Codecov badge to README [#5989](https://github.com/jupyter/notebook/pull/5989) ([@thomasrockhu](https://github.com/thomasrockhu)) -* Remove configuration for nosetests from setup.cfg [#5986](https://github.com/jupyter/notebook/pull/5986) ([@frenzymadness](https://github.com/frenzymadness)) -* Update security.rst [#5978](https://github.com/jupyter/notebook/pull/5978) ([@dlrice](https://github.com/dlrice)) -* Docs-Translations: Updated Hindi and Chinese Readme.md [#5976](https://github.com/jupyter/notebook/pull/5976) ([@rjn01](https://github.com/rjn01)) -* Allow /metrics by default if auth is off [#5974](https://github.com/jupyter/notebook/pull/5974) ([@blairdrummond](https://github.com/blairdrummond)) -* Skip terminal tests on Windows 3.9+ (temporary) [#5968](https://github.com/jupyter/notebook/pull/5968) ([@kevin-bates](https://github.com/kevin-bates)) -* Update GatewayKernelManager to derive from AsyncMappingKernelManager [#5966](https://github.com/jupyter/notebook/pull/5966) ([@kevin-bates](https://github.com/kevin-bates)) -* Drop use of deprecated pyzmq.ioloop [#5965](https://github.com/jupyter/notebook/pull/5965) ([@kevin-bates](https://github.com/kevin-bates)) -* Drop support for Python 3.5 [#5962](https://github.com/jupyter/notebook/pull/5962) ([@kevin-bates](https://github.com/kevin-bates)) -* Allow jupyter_server-based contents managers in notebook [#5957](https://github.com/jupyter/notebook/pull/5957) ([@afshin](https://github.com/afshin)) -* Russian translation fixes [#5954](https://github.com/jupyter/notebook/pull/5954) ([@insolor](https://github.com/insolor)) -* Increase culling test idle timeout [#5952](https://github.com/jupyter/notebook/pull/5952) ([@kevin-bates](https://github.com/kevin-bates)) -* Re-enable support for answer_yes flag [#5941](https://github.com/jupyter/notebook/pull/5941) ([@afshin](https://github.com/afshin)) -* Replace Travis and Appveyor with Github Actions [#5938](https://github.com/jupyter/notebook/pull/5938) ([@kevin-bates](https://github.com/kevin-bates)) -* DOC: Server extension, extra docs on configuration/authentication. [#5937](https://github.com/jupyter/notebook/pull/5937) ([@Carreau](https://github.com/Carreau)) +- Add square logo and desktop entry files [#6010](https://github.com/jupyter/notebook/pull/6010) ([@befeleme](https://github.com/befeleme)) +- Modernize Changelog [#6008](https://github.com/jupyter/notebook/pull/6008) ([@afshin](https://github.com/afshin)) +- Add missing "import inspect" [#5999](https://github.com/jupyter/notebook/pull/5999) ([@mgeier](https://github.com/mgeier)) +- Add Codecov badge to README [#5989](https://github.com/jupyter/notebook/pull/5989) ([@thomasrockhu](https://github.com/thomasrockhu)) +- Remove configuration for nosetests from setup.cfg [#5986](https://github.com/jupyter/notebook/pull/5986) ([@frenzymadness](https://github.com/frenzymadness)) +- Update security.rst [#5978](https://github.com/jupyter/notebook/pull/5978) ([@dlrice](https://github.com/dlrice)) +- Docs-Translations: Updated Hindi and Chinese Readme.md [#5976](https://github.com/jupyter/notebook/pull/5976) ([@rjn01](https://github.com/rjn01)) +- Allow /metrics by default if auth is off [#5974](https://github.com/jupyter/notebook/pull/5974) ([@blairdrummond](https://github.com/blairdrummond)) +- Skip terminal tests on Windows 3.9+ (temporary) [#5968](https://github.com/jupyter/notebook/pull/5968) ([@kevin-bates](https://github.com/kevin-bates)) +- Update GatewayKernelManager to derive from AsyncMappingKernelManager [#5966](https://github.com/jupyter/notebook/pull/5966) ([@kevin-bates](https://github.com/kevin-bates)) +- Drop use of deprecated pyzmq.ioloop [#5965](https://github.com/jupyter/notebook/pull/5965) ([@kevin-bates](https://github.com/kevin-bates)) +- Drop support for Python 3.5 [#5962](https://github.com/jupyter/notebook/pull/5962) ([@kevin-bates](https://github.com/kevin-bates)) +- Allow jupyter_server-based contents managers in notebook [#5957](https://github.com/jupyter/notebook/pull/5957) ([@afshin](https://github.com/afshin)) +- Russian translation fixes [#5954](https://github.com/jupyter/notebook/pull/5954) ([@insolor](https://github.com/insolor)) +- Increase culling test idle timeout [#5952](https://github.com/jupyter/notebook/pull/5952) ([@kevin-bates](https://github.com/kevin-bates)) +- Re-enable support for answer_yes flag [#5941](https://github.com/jupyter/notebook/pull/5941) ([@afshin](https://github.com/afshin)) +- Replace Travis and Appveyor with Github Actions [#5938](https://github.com/jupyter/notebook/pull/5938) ([@kevin-bates](https://github.com/kevin-bates)) +- DOC: Server extension, extra docs on configuration/authentication. [#5937](https://github.com/jupyter/notebook/pull/5937) ([@Carreau](https://github.com/Carreau)) ### Contributors to this release @@ -251,7 +251,7 @@ Thank you to all the contributors: ## Merged PRs -- do not require nose for testing ([5826](https://github.com/jupyter/notebook/pull/5826)) +- do not require nose for testing ([5826](https://github.com/jupyter/notebook/pull/5826)) - [docs] Update Chinese and Hindi readme.md ([5823](https://github.com/jupyter/notebook/pull/5823)) - Add support for creating terminals via GET ([5813](https://github.com/jupyter/notebook/pull/5813)) - Made doc translations in Hindi and Chinese ([5787](https://github.com/jupyter/notebook/pull/5787)) @@ -521,46 +521,46 @@ it's 1.0 release in preparation for a future transition. - Multiple translation enhancements and bug-fixes. - Remove deprecated ANSI CSS styles. - Native support to forward requests to Jupyter Gateway(s) (Embedded - NB2KG). + NB2KG). - Use JavaScript to redirect users to notebook homepage. - Enhanced SSL/TLS security by using PROTOCOL_TLS which selects the - highest ssl/tls protocol version available that both the client and - server support. When PROTOCOL_TLS is not available use - PROTOCOL_SSLv23. + highest ssl/tls protocol version available that both the client and + server support. When PROTOCOL_TLS is not available use + PROTOCOL_SSLv23. - Add `?no_track_activity=1` argument to allow API requests. to not be - registered as activity (e.g. API calls by external activity - monitors). + registered as activity (e.g. API calls by external activity + monitors). - Kernels shutting down due to an idle timeout is no longer considered - an activity-updating event. + an activity-updating event. - Further improve compatibility with tornado 6 with improved checks - for when websockets are closed. + for when websockets are closed. - Launch the browser with a local file which redirects to the server - address including the authentication token. This prevents another - logged-in user from stealing the token from command line arguments - and authenticating to the server. The single-use token previously - used to mitigate this has been removed. Thanks to Dr. Owain Kenway - for suggesting the local file approach. + address including the authentication token. This prevents another + logged-in user from stealing the token from command line arguments + and authenticating to the server. The single-use token previously + used to mitigate this has been removed. Thanks to Dr. Owain Kenway + for suggesting the local file approach. - Respect nbconvert entrypoints as sources for exporters - Update to CodeMirror to 5.37, which includes f-string syntax for - Python 3.6. + Python 3.6. - Update jquery-ui to 1.12 - Execute cells by clicking icon in input prompt. - New "Save as" menu option. - When serving on a loopback interface, protect against DNS rebinding - by checking the `Host` header from the browser. This check can be - disabled if necessary by setting `NotebookApp.allow_remote_access`. (Disabled by default while we work out some Mac issues in - [3754](https://github.com/jupyter/notebook/issues/3754)). + by checking the `Host` header from the browser. This check can be + disabled if necessary by setting `NotebookApp.allow_remote_access`. (Disabled by default while we work out some Mac issues in + [3754](https://github.com/jupyter/notebook/issues/3754)). - Add kernel_info_timeout traitlet to enable restarting slow kernels. - Add `custom_display_host` config option to override displayed URL. - Add /metrics endpoint for Prometheus Metrics. - Optimize large file uploads. - Allow access control headers to be overriden in - jupyter_notebook_config.py to support greater CORS and proxy - configuration flexibility. + jupyter_notebook_config.py to support greater CORS and proxy + configuration flexibility. - Add support for terminals on windows. - Add a "restart and run all" button to the toolbar. - Frontend/extension-config: allow default json files in a .d - directory. + directory. - Allow setting token via jupyter_token env. - Cull idle kernels using `--MappingKernelManager.cull_idle_timeout`. - Allow read-only notebooks to be trusted. @@ -570,27 +570,27 @@ Security Fixes included in previous minor releases of Jupyter Notebook and also included in version 6.0. - Fix Open Redirect vulnerability (CVE-2019-10255) where certain - malicious URLs could redirect from the Jupyter login page to a - malicious site after a successful login. + malicious URLs could redirect from the Jupyter login page to a + malicious site after a successful login. - Contains a security fix for a cross-site inclusion (XSSI) - vulnerability (CVE-2019--9644), where files at a known URL could be - included in a page from an unauthorized website if the user is - logged into a Jupyter server. The fix involves setting the - `X-Content-Type-Options: nosniff` header, and applying CSRF checks - previously on all non-GET API requests to GET requests to API - endpoints and the /files/ endpoint. + vulnerability (CVE-2019--9644), where files at a known URL could be + included in a page from an unauthorized website if the user is + logged into a Jupyter server. The fix involves setting the + `X-Content-Type-Options: nosniff` header, and applying CSRF checks + previously on all non-GET API requests to GET requests to API + endpoints and the /files/ endpoint. - Check Host header to more securely protect localhost deployments - from DNS rebinding. This is a pre-emptive measure, not fixing a - known vulnerability. Use `.NotebookApp.allow_remote_access` and - `.NotebookApp.local_hostnames` to configure access. + from DNS rebinding. This is a pre-emptive measure, not fixing a + known vulnerability. Use `.NotebookApp.allow_remote_access` and + `.NotebookApp.local_hostnames` to configure access. - Upgrade bootstrap to 3.4, fixing an XSS vulnerability, which has - been assigned - [CVE-2018-14041](https://nvd.nist.gov/vuln/detail/CVE-2018-14041). + been assigned + [CVE-2018-14041](https://nvd.nist.gov/vuln/detail/CVE-2018-14041). - Contains a security fix preventing malicious directory names from - being able to execute javascript. + being able to execute javascript. - Contains a security fix preventing nbconvert endpoints from - executing javascript with access to the server API. CVE request - pending. + executing javascript with access to the server API. CVE request + pending. Thanks for all the contributors: @@ -732,15 +732,15 @@ Thanks for all the contributors: ## 5.7.8 - Fix regression in restarting kernels in 5.7.5. The restart handler - would return before restart was completed. + would return before restart was completed. - Further improve compatibility with tornado 6 with improved checks - for when websockets are closed. + for when websockets are closed. - Fix regression in 5.7.6 on Windows where .js files could have the - wrong mime-type. + wrong mime-type. - Fix Open Redirect vulnerability (CVE-2019-10255) where certain - malicious URLs could redirect from the Jupyter login page to a - malicious site after a successful login. 5.7.7 contained only a - partial fix for this issue. + malicious URLs could redirect from the Jupyter login page to a + malicious site after a successful login. 5.7.7 contained only a + partial fix for this issue. ## 5.7.6 @@ -761,7 +761,7 @@ demonstrated with other browsers. - Fix compatibility with tornado 6 ([4392](https://github.com/jupyter/notebook/pull/4392), [4449](https://github.com/jupyter/notebook/pull/4449)). - Fix opening integer filedescriptor during startup on Python 2 ([4349](https://github.com/jupyter/notebook/pull/4349)) - Fix compatibility with asynchronous - [KernelManager.restart_kernel]{.title-ref} methods ([4412](https://github.com/jupyter/notebook/pull/4412)) + [KernelManager.restart_kernel]{.title-ref} methods ([4412](https://github.com/jupyter/notebook/pull/4412)) ## 5.7.4 @@ -774,14 +774,14 @@ and consequently crashes ([4284](https://github.com/jupyter/notebook/pull/4284)) 5.7.3 contains one security improvement and one security fix: - Launch the browser with a local file which redirects to the server - address including the authentication token ([4260](https://github.com/jupyter/notebook/pull/4260)). This prevents another logged-in user from stealing - the token from command line arguments and authenticating to the - server. The single-use token previously used to mitigate this has - been removed. Thanks to Dr. Owain Kenway for suggesting the local - file approach. + address including the authentication token ([4260](https://github.com/jupyter/notebook/pull/4260)). This prevents another logged-in user from stealing + the token from command line arguments and authenticating to the + server. The single-use token previously used to mitigate this has + been removed. Thanks to Dr. Owain Kenway for suggesting the local + file approach. - Upgrade bootstrap to 3.4, fixing an XSS vulnerability, which has - been assigned - [CVE-2018-14041](https://nvd.nist.gov/vuln/detail/CVE-2018-14041) ([4271](https://github.com/jupyter/notebook/pull/4271)). + been assigned + [CVE-2018-14041](https://nvd.nist.gov/vuln/detail/CVE-2018-14041) ([4271](https://github.com/jupyter/notebook/pull/4271)). ## 5.7.2 @@ -798,20 +798,20 @@ executing javascript with access to the server API. CVE request pending. New features: - Update to CodeMirror to 5.37, which includes f-string syntax for - Python 3.6 ([3816](https://github.com/jupyter/notebook/pull/3816)) + Python 3.6 ([3816](https://github.com/jupyter/notebook/pull/3816)) - Update jquery-ui to 1.12 ([3836](https://github.com/jupyter/notebook/pull/3836)) - Check Host header to more securely protect localhost deployments - from DNS rebinding. This is a pre-emptive measure, not fixing a - known vulnerability ([3766](https://github.com/jupyter/notebook/pull/3766)). Use - `.NotebookApp.allow_remote_access` and - `.NotebookApp.local_hostnames` to configure access. + from DNS rebinding. This is a pre-emptive measure, not fixing a + known vulnerability ([3766](https://github.com/jupyter/notebook/pull/3766)). Use + `.NotebookApp.allow_remote_access` and + `.NotebookApp.local_hostnames` to configure access. - Allow access-control-allow-headers to be overridden ([3886](https://github.com/jupyter/notebook/pull/3886)) - Allow configuring max_body_size and max_buffer_size ([3829](https://github.com/jupyter/notebook/pull/3829)) - Allow configuring get_secure_cookie keyword-args ([3778](https://github.com/jupyter/notebook/pull/3778)) - Respect nbconvert entrypoints as sources for exporters ([3879](https://github.com/jupyter/notebook/pull/3879)) - Include translation sources in source distributions ([3925](https://github.com/jupyter/notebook/pull/3925), [3931](https://github.com/jupyter/notebook/pull/3931)) - Various improvements to documentation ([3799](https://github.com/jupyter/notebook/pull/3799), [3800](https://github.com/jupyter/notebook/pull/3800), - [3806](https://github.com/jupyter/notebook/pull/3806), [3883](https://github.com/jupyter/notebook/pull/3883), [3908](https://github.com/jupyter/notebook/pull/3908)) + [3806](https://github.com/jupyter/notebook/pull/3806), [3883](https://github.com/jupyter/notebook/pull/3883), [3908](https://github.com/jupyter/notebook/pull/3908)) Fixing problems: @@ -819,7 +819,7 @@ Fixing problems: - Fix possible type error when closing activity stream ([3907](https://github.com/jupyter/notebook/pull/3907)) - Disable metadata editing for non-editable cells ([3744](https://github.com/jupyter/notebook/pull/3744)) - Fix some styling and alignment of prompts caused by regressions in - 5.6.0. + 5.6.0. - Enter causing page reload in shortcuts editor ([3871](https://github.com/jupyter/notebook/pull/3871)) - Fix uploading to the same file twice ([3712](https://github.com/jupyter/notebook/pull/3712)) @@ -860,9 +860,9 @@ New features: - Execute cells by clicking icon in input prompt ([3535](https://github.com/jupyter/notebook/pull/3535), [3687](https://github.com/jupyter/notebook/pull/3687)) - New "Save as" menu option ([3289](https://github.com/jupyter/notebook/pull/3289)) - When serving on a loopback interface, protect against DNS rebinding - by checking the `Host` header from the browser ([3714](https://github.com/jupyter/notebook/pull/3714)). This check can be - disabled if necessary by setting `NotebookApp.allow_remote_access`. (Disabled by default while we work out some Mac issues in - [3754](https://github.com/jupyter/notebook/issues/3754)). + by checking the `Host` header from the browser ([3714](https://github.com/jupyter/notebook/pull/3714)). This check can be + disabled if necessary by setting `NotebookApp.allow_remote_access`. (Disabled by default while we work out some Mac issues in + [3754](https://github.com/jupyter/notebook/issues/3754)). - Add kernel_info_timeout traitlet to enable restarting slow kernels ([3665](https://github.com/jupyter/notebook/pull/3665)) - Add `custom_display_host` config option to override displayed URL ([3668](https://github.com/jupyter/notebook/pull/3668)) - Add /metrics endpoint for Prometheus Metrics ([3490](https://github.com/jupyter/notebook/pull/3490)) @@ -906,13 +906,13 @@ New features: - Display hostname in the terminal when running remotely ([3356](https://github.com/jupyter/notebook/pull/3356), [3593](https://github.com/jupyter/notebook/pull/3593)) - Add slides exportation/download to the menu ([3287](https://github.com/jupyter/notebook/pull/3287)) - Add any extra installed nbconvert exporters to the "Download as" - menu ([3323](https://github.com/jupyter/notebook/pull/3323)) + menu ([3323](https://github.com/jupyter/notebook/pull/3323)) - Editor: warning when overwriting a file that is modified on disk ([2783](https://github.com/jupyter/notebook/pull/2783)) - Display a warning message if cookies are not enabled ([3511](https://github.com/jupyter/notebook/pull/3511)) - Basic `__version__` reporting for extensions ([3541](https://github.com/jupyter/notebook/pull/3541)) - Add `NotebookApp.terminals_enabled` config option ([3478](https://github.com/jupyter/notebook/pull/3478)) - Make buffer time between last modified on disk and last modified on - last save configurable ([3273](https://github.com/jupyter/notebook/pull/3273)) + last save configurable ([3273](https://github.com/jupyter/notebook/pull/3273)) - Allow binding custom shortcuts for 'close and halt' ([3314](https://github.com/jupyter/notebook/pull/3314)) - Add description for 'Trusted' notification ([3386](https://github.com/jupyter/notebook/pull/3386)) - Add `settings['activity_sources']` ([3401](https://github.com/jupyter/notebook/pull/3401)) @@ -933,7 +933,7 @@ Fixing problems: - Prevent default on pageup/pagedown when completer is active ([3500](https://github.com/jupyter/notebook/pull/3500)) - Prevent default event handling on new terminal ([3497](https://github.com/jupyter/notebook/pull/3497)) - ConfigManager should not write out default values found in the .d - directory ([3485](https://github.com/jupyter/notebook/pull/3485)) + directory ([3485](https://github.com/jupyter/notebook/pull/3485)) - Fix leak of iopub object in activity monitoring ([3424](https://github.com/jupyter/notebook/pull/3424)) - Javascript lint in notebooklist.js ([3409](https://github.com/jupyter/notebook/pull/3409)) - Some Javascript syntax fixes ([3294](https://github.com/jupyter/notebook/pull/3294)) @@ -945,10 +945,10 @@ Fixing problems: - API spec improvements, API handler improvements ([3368](https://github.com/jupyter/notebook/pull/3368)) - Set notebook to dirty state after change to kernel metadata ([3350](https://github.com/jupyter/notebook/pull/3350)) - Use CSP header to treat served files as belonging to a separate - origin ([3341](https://github.com/jupyter/notebook/pull/3341)) + origin ([3341](https://github.com/jupyter/notebook/pull/3341)) - Don't install gettext into builtins ([3330](https://github.com/jupyter/notebook/pull/3330)) - Add missing `import _` ([3316](https://github.com/jupyter/notebook/pull/3316), - [3326](https://github.com/jupyter/notebook/pull/3326)) + [3326](https://github.com/jupyter/notebook/pull/3326)) - Write `notebook.json` file atomically ([3305](https://github.com/jupyter/notebook/pull/3305)) - Fix clicking with modifiers, page title updates ([3282](https://github.com/jupyter/notebook/pull/3282)) - Upgrade jQuery to version 2.2 ([3428](https://github.com/jupyter/notebook/pull/3428)) @@ -964,12 +964,12 @@ Documentation: - Add explanation on how to change the type of a cell to Markdown ([3377](https://github.com/jupyter/notebook/pull/3377)) - Update docs with confd implementation details ([3520](https://github.com/jupyter/notebook/pull/3520)) - Add more information for where `jupyter_notebook_config.py` is - located ([3346](https://github.com/jupyter/notebook/pull/3346)) + located ([3346](https://github.com/jupyter/notebook/pull/3346)) - Document options to enable nbextensions in specific sections ([3525](https://github.com/jupyter/notebook/pull/3525)) - jQuery attribute selector value MUST be surrounded by quotes ([3527](https://github.com/jupyter/notebook/pull/3527)) - Do not execute special notebooks with nbsphinx ([3360](https://github.com/jupyter/notebook/pull/3360)) - Other minor fixes in [3288](https://github.com/jupyter/notebook/pull/3288), - [3528](https://github.com/jupyter/notebook/pull/3528), [3293](https://github.com/jupyter/notebook/pull/3293), [3367](https://github.com/jupyter/notebook/pull/3367) + [3528](https://github.com/jupyter/notebook/pull/3528), [3293](https://github.com/jupyter/notebook/pull/3293), [3367](https://github.com/jupyter/notebook/pull/3367) Testing: @@ -1040,16 +1040,16 @@ it and bringing it to our attention. ## 5.4.0 - Fix creating files and folders after navigating directories in the - dashboard ([3264](https://github.com/jupyter/notebook/pull/3264)). + dashboard ([3264](https://github.com/jupyter/notebook/pull/3264)). - Enable printing notebooks in colour, removing the CSS that made - everything black and white ([3212](https://github.com/jupyter/notebook/pull/3212)). + everything black and white ([3212](https://github.com/jupyter/notebook/pull/3212)). - Limit the completion options displayed in the notebook to 1000, to - avoid performance issues with very long lists ([3195](https://github.com/jupyter/notebook/pull/3195)). + avoid performance issues with very long lists ([3195](https://github.com/jupyter/notebook/pull/3195)). - Accessibility improvements in `tree.html` ([3271](https://github.com/jupyter/notebook/pull/3271)). - Added alt-text to the kernel logo image in the notebook UI ([3228](https://github.com/jupyter/notebook/pull/3228)). - Added a test on Travis CI to flag if symlinks are accidentally - introduced in the future. This should prevent the issue that - necessitated `release-5.3.1`{.interpreted-text role="ref"} ([3227](https://github.com/jupyter/notebook/pull/3227)). + introduced in the future. This should prevent the issue that + necessitated `release-5.3.1`{.interpreted-text role="ref"} ([3227](https://github.com/jupyter/notebook/pull/3227)). - Use lowercase letters for random IDs generated in our Javascript ([3264](https://github.com/jupyter/notebook/pull/3264)). - Removed duplicate code setting `TextCell.notebook` ([3256](https://github.com/jupyter/notebook/pull/3256)). @@ -1082,7 +1082,7 @@ notebook dashboard are moved to the OS trash vs. deleted permanently). - Send files to os trash mechanism on delete ([1968](https://github.com/jupyter/notebook/pull/1968)). - Allow programmatic copy to clipboard ([3088](https://github.com/jupyter/notebook/pull/3088)). - Use DOM History API for navigating between directories in the file - browser ([3115](https://github.com/jupyter/notebook/pull/3115)). + browser ([3115](https://github.com/jupyter/notebook/pull/3115)). - Add translated files to folder(docs-translations) ([3065](https://github.com/jupyter/notebook/pull/3065)). - Allow non empty dirs to be deleted ([3108](https://github.com/jupyter/notebook/pull/3108)). - Set cookie on base_url ([2959](https://github.com/jupyter/notebook/pull/2959)). @@ -1091,7 +1091,7 @@ notebook dashboard are moved to the OS trash vs. deleted permanently). - Config option to shut down server after n seconds with no kernels ([2963](https://github.com/jupyter/notebook/pull/2963)). - Display a "close" button on load notebook error ([3176](https://github.com/jupyter/notebook/pull/3176)). - Add action to command pallette to run CodeMirror's "indentAuto" - on selection ([3175](https://github.com/jupyter/notebook/pull/3175)). + on selection ([3175](https://github.com/jupyter/notebook/pull/3175)). - Add option to specify extra services ([3158](https://github.com/jupyter/notebook/pull/3158)). - Warn_bad_name should not use global name ([3160](https://github.com/jupyter/notebook/pull/3160)). - Avoid overflow of hidden form ([3148](https://github.com/jupyter/notebook/pull/3148)). @@ -1099,11 +1099,11 @@ notebook dashboard are moved to the OS trash vs. deleted permanently). - Find available kernelspecs more efficiently ([3136](https://github.com/jupyter/notebook/pull/3136)). - Don't try to translate missing help strings ([3122](https://github.com/jupyter/notebook/pull/3122)). - Frontend/extension-config: allow default json files in a .d - directory ([3116](https://github.com/jupyter/notebook/pull/3116)). + directory ([3116](https://github.com/jupyter/notebook/pull/3116)). - Use [requirejs]{.title-ref} vs. [require]{.title-ref} ([3097](https://github.com/jupyter/notebook/pull/3097)). - Fixes some ui bugs in firefox \#3044 ([3058](https://github.com/jupyter/notebook/pull/3058)). - Compare non-specific language code when choosing to use arabic - numerals ([3055](https://github.com/jupyter/notebook/pull/3055)). + numerals ([3055](https://github.com/jupyter/notebook/pull/3055)). - Fix save-script deprecation ([3053](https://github.com/jupyter/notebook/pull/3053)). - Include moment locales in package_data ([3051](https://github.com/jupyter/notebook/pull/3051)). - Fix moment locale loading in bidi support ([3048](https://github.com/jupyter/notebook/pull/3048)). @@ -1194,7 +1194,7 @@ involved in this release. - Avoid base64-literals in image tests ([2851](https://github.com/jupyter/notebook/pull/2851)). - Upgrade xterm.js to 2.9.2 ([2849](https://github.com/jupyter/notebook/pull/2849)). - Changed all python variables named file to file_name to not override - built_in file ([2830](https://github.com/jupyter/notebook/pull/2830)). + built_in file ([2830](https://github.com/jupyter/notebook/pull/2830)). - Add more doc tests ([2823](https://github.com/jupyter/notebook/pull/2823)). - Typos fix ([2815](https://github.com/jupyter/notebook/pull/2815)). - Rename and update license \[ci skip\] ([2810](https://github.com/jupyter/notebook/pull/2810)). @@ -1203,7 +1203,7 @@ involved in this release. - Factor out output_prompt_function, as is done with input prompt ([2774](https://github.com/jupyter/notebook/pull/2774)). - Use rfc5987 encoding for filenames ([2767](https://github.com/jupyter/notebook/pull/2767)). - Added path to the resources metadata, the same as in - from_filename(...) in nbconvert.exporters.py ([2753](https://github.com/jupyter/notebook/pull/2753)). + from_filename(...) in nbconvert.exporters.py ([2753](https://github.com/jupyter/notebook/pull/2753)). - Make "extrakeys" consistent for notebook and editor ([2745](https://github.com/jupyter/notebook/pull/2745)). - Bidi support ([2357](https://github.com/jupyter/notebook/pull/2357)). @@ -1233,7 +1233,7 @@ involved in this release. - Stop notebook server from command line ([2388](https://github.com/jupyter/notebook/pull/2388)). - Improve "View" and "Edit" file handling in dashboard ([2449](https://github.com/jupyter/notebook/pull/2449)) and ([2402](https://github.com/jupyter/notebook/pull/2402)). - Provide a promise to replace use of the - `app_initialized.NotebookApp` event ([2710](https://github.com/jupyter/notebook/pull/2710)). + `app_initialized.NotebookApp` event ([2710](https://github.com/jupyter/notebook/pull/2710)). - Fix disabled collapse/expand output button ([2681](https://github.com/jupyter/notebook/pull/2681)). - Cull idle kernels using `--MappingKernelManager.cull_idle_timeout` ([2215](https://github.com/jupyter/notebook/pull/2215)). - Allow read-only notebooks to be trusted ([2718](https://github.com/jupyter/notebook/pull/2718)). @@ -1264,7 +1264,7 @@ Files in the dashboard may now be sorted by last modified date or name ### Cell tags -There is a new cell toolbar for adding *cell tags* +There is a new cell toolbar for adding _cell tags_ ([2048](https://github.com/jupyter/notebook/pull/2048)): ![image](/_static/images/cell-tags-toolbar.png) @@ -1293,7 +1293,7 @@ After: ### Customise keyboard shortcuts -You can now edit keyboard shortcuts for *Command Mode* within the UI +You can now edit keyboard shortcuts for _Command Mode_ within the UI ([1347](https://github.com/jupyter/notebook/pull/1347)): ![image](/_static/images/shortcut-editor.png) @@ -1304,41 +1304,41 @@ instructions. ### Other additions - You can copy and paste cells between notebooks, using - `Ctrl-C`{.interpreted-text role="kbd"} and - `Ctrl-V`{.interpreted-text role="kbd"} (`Cmd-C`{.interpreted-text - role="kbd"} and `Cmd-V`{.interpreted-text role="kbd"} on Mac). + `Ctrl-C`{.interpreted-text role="kbd"} and + `Ctrl-V`{.interpreted-text role="kbd"} (`Cmd-C`{.interpreted-text + role="kbd"} and `Cmd-V`{.interpreted-text role="kbd"} on Mac). - It's easier to configure a password for the notebook with the new - `jupyter notebook password` command ([2007](https://github.com/jupyter/notebook/pull/2007)). -- The file list can now be ordered by *last modified* or by *name* ([943](https://github.com/jupyter/notebook/pull/943)). + `jupyter notebook password` command ([2007](https://github.com/jupyter/notebook/pull/2007)). +- The file list can now be ordered by _last modified_ or by _name_ ([943](https://github.com/jupyter/notebook/pull/943)). - Markdown cells now support attachments. Simply drag and drop an - image from your desktop to a markdown cell to add it. Unlike - relative links that you enter manually, attachments are embedded in - the notebook itself. An unreferenced attachment will be - automatically scrubbed from the notebook on save ([621](https://github.com/jupyter/notebook/pull/621)). + image from your desktop to a markdown cell to add it. Unlike + relative links that you enter manually, attachments are embedded in + the notebook itself. An unreferenced attachment will be + automatically scrubbed from the notebook on save ([621](https://github.com/jupyter/notebook/pull/621)). - Undoing cell deletion now supports undeleting multiple cells. Cells - may not be in the same order as before their deletion, depending on - the actions you did on the meantime, but this should should help - reduce the impact of accidentally deleting code. -- The file browser now has *Edit* and *View* buttons. + may not be in the same order as before their deletion, depending on + the actions you did on the meantime, but this should should help + reduce the impact of accidentally deleting code. +- The file browser now has _Edit_ and _View_ buttons. - The file browser now supports moving multiple files at once ([1088](https://github.com/jupyter/notebook/pull/1088)). - The Notebook will refuse to run as root unless the `--allow-root` - flag is given ([1115](https://github.com/jupyter/notebook/pull/1115)). + flag is given ([1115](https://github.com/jupyter/notebook/pull/1115)). - Keyboard shortcuts are now declarative ([1234](https://github.com/jupyter/notebook/pull/1234)). - Toggling line numbers can now affect all cells ([1312](https://github.com/jupyter/notebook/pull/1312)). -- Add more visible *Trusted* and *Untrusted* notifications ([1658](https://github.com/jupyter/notebook/pull/1658)). +- Add more visible _Trusted_ and _Untrusted_ notifications ([1658](https://github.com/jupyter/notebook/pull/1658)). - The favicon (browser shortcut icon) now changes to indicate when the - kernel is busy ([1837](https://github.com/jupyter/notebook/pull/1837)). + kernel is busy ([1837](https://github.com/jupyter/notebook/pull/1837)). - Header and toolbar visibility is now persisted in nbconfig and - across sessions ([1769](https://github.com/jupyter/notebook/pull/1769)). + across sessions ([1769](https://github.com/jupyter/notebook/pull/1769)). - Load server extensions with ConfigManager so that merge happens - recursively, unlike normal config values, to make it load more - consistently with frontend extensions([2108](https://github.com/jupyter/notebook/pull/2108)). + recursively, unlike normal config values, to make it load more + consistently with frontend extensions([2108](https://github.com/jupyter/notebook/pull/2108)). - The notebook server now supports the [bundler - API](https://jupyter-notebook.readthedocs.io/en/latest/extending/bundler_extensions.html) - from the [jupyter_cms incubator - project](https://github.com/jupyter-incubator/contentmanagement) ([1579](https://github.com/jupyter/notebook/pull/1579)). + API](https://jupyter-notebook.readthedocs.io/en/latest/extending/bundler_extensions.html) + from the [jupyter_cms incubator + project](https://github.com/jupyter-incubator/contentmanagement) ([1579](https://github.com/jupyter/notebook/pull/1579)). - The notebook server now provides information about kernel activity - in its kernel resource API ([1827](https://github.com/jupyter/notebook/pull/1827)). + in its kernel resource API ([1827](https://github.com/jupyter/notebook/pull/1827)). Remember that upgrading `notebook` only affects the user interface. Upgrading kernels and libraries may also provide new features, better @@ -1347,10 +1347,10 @@ stability and integration with the notebook interface. ## 4.4.0 - Allow override of output callbacks to redirect output messages. This - is used to implement the ipywidgets Output widget, for example. + is used to implement the ipywidgets Output widget, for example. - Fix an async bug in message handling by allowing comm message - handlers to return a promise which halts message processing until - the promise resolves. + handlers to return a promise which halts message processing until + the promise resolves. See the 4.4 milestone on GitHub for a complete list of [issues](https://github.com/jupyter/notebook/issues?utf8=%E2%9C%93&q=is%3Aissue%20milestone%3A4.4) @@ -1364,10 +1364,10 @@ involved in this release. handling of the "editable" cell metadata field. - Monkey-patch for CodeMirror that resolves - [\#2037](https://github.com/jupyter/notebook/issues/2037) without - breaking [\#1967](https://github.com/jupyter/notebook/issues/1967) + [\#2037](https://github.com/jupyter/notebook/issues/2037) without + breaking [\#1967](https://github.com/jupyter/notebook/issues/1967) - Read-only (`"editable": false`) cells can be executed but cannot be - split, merged, or deleted + split, merged, or deleted See the 4.3.2 milestone on GitHub for a complete list of [issues](https://github.com/jupyter/notebook/issues?utf8=%E2%9C%93&q=is%3Aissue%20milestone%3A4.3.2) @@ -1383,9 +1383,9 @@ improvements to the newly-released token authentication. **Security fix**: - CVE-2016-9971. Fix CSRF vulnerability, where malicious forms could - create untitled files and start kernels (no remote execution or - modification of existing files) for users of certain browsers (Firefox, Internet Explorer / Edge). All previous notebook releases - are affected. + create untitled files and start kernels (no remote execution or + modification of existing files) for users of certain browsers (Firefox, Internet Explorer / Edge). All previous notebook releases + are affected. Bug fixes: @@ -1420,12 +1420,12 @@ you can paste into your browser. Highlights: - API for creating mime-type based renderer extensions using - `OutputArea.register_mime_type` and `Notebook.render_cell_output` - methods. See - [mimerender-cookiecutter](https://github.com/jupyterlab/mimerender-cookiecutter) - for reference implementations and cookiecutter. + `OutputArea.register_mime_type` and `Notebook.render_cell_output` + methods. See + [mimerender-cookiecutter](https://github.com/jupyterlab/mimerender-cookiecutter) + for reference implementations and cookiecutter. - Enable token authentication by default. See - `server_security`{.interpreted-text role="ref"} for more details. + `server_security`{.interpreted-text role="ref"} for more details. - Update security docs to reflect new signature system - Switched from term.js to xterm.js @@ -1477,7 +1477,7 @@ involved in this release. > Highlights: - Fix regression in 4.2.2 that delayed loading custom.js until after - `notebook_loaded` and `app_initialized` events have fired. + `notebook_loaded` and `app_initialized` events have fired. - Fix some outdated docs and links. ## 4.2.2 @@ -1488,13 +1488,13 @@ All users are strongly encouraged to upgrade to 4.2.2. > Highlights: - **Security fix**: CVE-2016-6524, where untrusted latex output could - be added to the page in a way that could execute javascript. + be added to the page in a way that could execute javascript. - Fix missing POST in OPTIONS responses. - Fix for downloading non-ascii filenames. - Avoid clobbering ssl_options, so that users can specify more - detailed SSL configuration. + detailed SSL configuration. - Fix inverted load order in nbconfig, so user config has highest - priority. + priority. - Improved error messages here and there. ## 4.2.1 @@ -1515,14 +1515,14 @@ package, as well. Highlighted changes: - Upgrade MathJax to 2.6 to fix vertical-bar appearing on some - equations. + equations. - Restore ability for notebook directory to be root (4.1 regression) - Large outputs are now throttled, reducing the ability of output - floods to kill the browser. + floods to kill the browser. - Fix the notebook ignoring cell executions while a kernel is starting - by queueing the messages. + by queueing the messages. - Fix handling of url prefixes (e.g. JupyterHub) in terminal and edit - pages. + pages. - Support nested SVGs in output. And various other fixes and improvements. @@ -1541,46 +1541,46 @@ Bug fixes: UI changes: -- Moved the cell toolbar selector into the *View* menu. Added a button - that triggers a "hint" animation to the main toolbar so users can - find the new location. (Click here to see a - [screencast](https://cloud.githubusercontent.com/assets/335567/10711889/59665a5a-7a3e-11e5-970f-86b89592880c.gif) - ) +- Moved the cell toolbar selector into the _View_ menu. Added a button + that triggers a "hint" animation to the main toolbar so users can + find the new location. (Click here to see a + [screencast](https://cloud.githubusercontent.com/assets/335567/10711889/59665a5a-7a3e-11e5-970f-86b89592880c.gif) + ) - > ![image](/_static/images/cell-toolbar-41.png) + > ![image](/_static/images/cell-toolbar-41.png) -- Added *Restart & Run All* to the *Kernel* menu. Users can also bind - it to a keyboard shortcut on action - `restart-kernel-and-run-all-cells`. +- Added _Restart & Run All_ to the _Kernel_ menu. Users can also bind + it to a keyboard shortcut on action + `restart-kernel-and-run-all-cells`. - Added multiple-cell selection. Users press `Shift-Up/Down` or - `Shift-K/J` to extend selection in command mode. Various actions - such as cut/copy/paste, execute, and cell type conversions apply to - all selected cells. + `Shift-K/J` to extend selection in command mode. Various actions + such as cut/copy/paste, execute, and cell type conversions apply to + all selected cells. - ![image](/_static/images/multi-select-41.png) + ![image](/_static/images/multi-select-41.png) - Added a command palette for executing Jupyter actions by name. Users - press `Cmd/Ctrl-Shift-P` or click the new command palette icon on - the toolbar. + press `Cmd/Ctrl-Shift-P` or click the new command palette icon on + the toolbar. - ![image](/_static/images/command-palette-41.png) + ![image](/_static/images/command-palette-41.png) -- Added a *Find and Replace* dialog to the *Edit* menu. Users can also - press `F` in command mode to show the dialog. +- Added a _Find and Replace_ dialog to the _Edit_ menu. Users can also + press `F` in command mode to show the dialog. - ![image](/_static/images/find-replace-41.png) + ![image](/_static/images/find-replace-41.png) Other improvements: - Custom KernelManager methods can be Tornado coroutines, allowing - async operations. + async operations. - Make clearing output optional when rewriting input with - `set_next_input(replace=True)`. + `set_next_input(replace=True)`. - Added support for TLS client authentication via - `--NotebookApp.client-ca`. + `--NotebookApp.client-ca`. - Added tags to `jupyter/notebook` releases on DockerHub. `latest` - continues to track the master branch. + continues to track the master branch. See the 4.1 milestone on GitHub for a complete list of [issues](https://github.com/jupyter/notebook/issues?page=3&q=milestone%3A4.1+is%3Aclosed+is%3Aissue&utf8=%E2%9C%93) @@ -1601,9 +1601,9 @@ handled. Security fixes for maliciously crafted files. - [CVE-2015-6938](http://www.openwall.com/lists/oss-security/2015/09/02/3): - malicious filenames + malicious filenames - [CVE-2015-7337](http://www.openwall.com/lists/oss-security/2015/09/16/3): - malicious binary files in text editor. + malicious binary files in text editor. Thanks to Jonathan Kamens at Quantopian and Juan Broullón for the reports. diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 0000000000..afb088a5e6 --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,95 @@ +# Contributing to Jupyter Notebook + +Thanks for contributing to Jupyter Notebook! + +Make sure to follow [Project Jupyter's Code of Conduct](https://github.com/jupyter/governance/blob/master/conduct/code_of_conduct.md) +for a friendly and welcoming collaborative environment. + +## Setting up a development environment + +Note: You will need NodeJS to build the extension package. + +The `jlpm` command is JupyterLab's pinned version of [yarn](https://yarnpkg.com/) that is installed with JupyterLab. You may use +`yarn` or `npm` in lieu of `jlpm` below. + +**Note**: we recomment using `mamba` to speed the creating of the environment. + +```bash +# create a new environment +mamba create -n notebook -c conda-forge python nodejs -y + +# activate the environment +mamba activate notebook + +# Install package in development mode +pip install -e . + +# Link the notebook extension and @jupyter-notebook schemas +jlpm develop + +# Enable the server extension +jupyter server extension enable notebook +``` + +`notebook` follows a monorepo structure. To build all the packages at once: + +```bash +jlpm build +``` + +There is also a `watch` script to watch for changes and rebuild the app automatically: + +```bash +jlpm watch +``` + +To make sure the `notebook` server extension is installed: + +```bash +$ jupyter server extension list +Config dir: /home/username/.jupyter + +Config dir: /home/username/miniforge3/envs/notebook/etc/jupyter + jupyterlab enabled + - Validating jupyterlab... + jupyterlab 3.0.0 OK + notebook enabled + - Validating notebook... + notebook 7.0.0a0 OK + +Config dir: /usr/local/etc/jupyter +``` + +Then start Jupyter Notebook with: + +```bash +jupyter notebook +``` + +## Running Tests + +To run the tests: + +```bash +jlpm run build:test +jlpm run test +``` + +There are also end to end tests to cover higher level user interactions, located in the [`ui-tests`](./ui-tests) folder. To run these tests: + +```bash +cd ui-tests +# start a new Jupyter server in a terminal +jlpm start + +# in a new terminal, run the tests +jlpm test +``` + +The `test` script calls the Playwright test runner. You can pass additional arguments to `playwright` by appending parameters to the command. For example to run the test in headed mode, `jlpm test --headed`. + +Checkout the [Playwright Command Line Reference](https://playwright.dev/docs/test-cli/) for more information about the available command line options. + +Running the end to end tests in headful mode will trigger something like the following: + +![playwight-headed-demo](https://user-images.githubusercontent.com/591645/141274633-ca9f9c2f-eef6-430e-9228-a35827f8133d.gif) diff --git a/CONTRIBUTING.rst b/CONTRIBUTING.rst deleted file mode 100644 index 6f947cb58c..0000000000 --- a/CONTRIBUTING.rst +++ /dev/null @@ -1,197 +0,0 @@ -Contributing to the Jupyter Notebook -==================================== - -If you're reading this section, you're probably interested in contributing to -Jupyter. Welcome and thanks for your interest in contributing! - -Please take a look at the Contributor documentation, familiarize yourself with -using the Jupyter Notebook, and introduce yourself on the mailing list and -share what area of the project you are interested in working on. - -General Guidelines ------------------- - -For general documentation about contributing to Jupyter projects, see the -`Project Jupyter Contributor Documentation`__. - -__ https://jupyter.readthedocs.io/en/latest/contributing/content-contributor.html - - -Setting Up a Development Environment ------------------------------------- - -Installing Node.js and npm -^^^^^^^^^^^^^^^^^^^^^^^^^^ - -Building the Notebook from its GitHub source code requires some tools to -create and minify JavaScript components and the CSS, -specifically Node.js and Node's package manager, ``npm``. -It should be node version ≥ 6.0. - -If you use ``conda``, you can get them with:: - - conda install -c conda-forge nodejs - -If you use `Homebrew `_ on Mac OS X:: - - brew install node - -Installation on Linux may vary, but be aware that the `nodejs` or `npm` packages -included in the system package repository may be too old to work properly. - -You can also use the installer from the `Node.js website `_. - - -Installing the Jupyter Notebook -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - -Once you have installed the dependencies mentioned above, use the following -steps:: - - pip install --upgrade setuptools pip - git clone https://github.com/jupyter/notebook - cd notebook - pip install -e . - -If you are using a system-wide Python installation and you only want to install the notebook for you, -you can add ``--user`` to the install commands. - -Once you have done this, you can launch the master branch of Jupyter notebook -from any directory in your system with:: - - jupyter notebook - -Verification -^^^^^^^^^^^^ - -While running the notebook, select one of your notebook files (the file will have the extension ``.ipynb``). -In the top tab you will click on "Help" and then click on "About". In the pop window you will see information about the version of Jupyter that you are running. You will see "The version of the notebook server is:". -If you are working in development mode, you will see that your version of Jupyter notebook will include the word "dev". If it does not include the word "dev", you are currently not working in development mode and should follow the steps below to uninstall and reinstall Jupyter. - -Troubleshooting the Installation -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - -If you do not see that your Jupyter Notebook is not running on dev mode, it's possible that you are -running other instances of Jupyter Notebook. You can try the following steps: - -1. Uninstall all instances of the notebook package. These include any installations you made using - pip or conda. -2. Run ``python3 -m pip install -e .`` in the notebook repository to install the notebook from there. -3. Run ``npm run build`` to make sure the Javascript and CSS are updated and compiled. -4. Launch with ``python3 -m notebook --port 8989``, and check that the browser is pointing to ``localhost:8989`` - (rather than the default 8888). You don't necessarily have to launch with port 8989, as long as you use - a port that is neither the default nor in use, then it should be fine. -5. Verify the installation with the steps in the previous section. - - -Rebuilding JavaScript and CSS -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - -There is a build step for the JavaScript and CSS in the notebook. -To make sure that you are working with up-to-date code, you will need to run -this command whenever there are changes to JavaScript or LESS sources:: - - npm run build - -**IMPORTANT:** Don't forget to run ``npm run build`` after switching branches. -When switching between branches of different versions (e.g. ``4.x`` and -``master``), run ``pip install -e .``. If you have tried the above and still -find that the notebook is not reflecting the current source code, try cleaning -the repo with ``git clean -xfd`` and reinstalling with ``pip install -e .``. - -Development Tip -""""""""""""""" - -When doing development, you can use this command to automatically rebuild -JavaScript and LESS sources as they are modified:: - - npm run build:watch - -Git Hooks -""""""""" - -If you want to automatically update dependencies and recompile JavaScript and -CSS after checking out a new commit, you can install post-checkout and -post-merge hooks which will do it for you:: - - git-hooks/install-hooks.sh - -See ``git-hooks/README.md`` for more details. - - -Running Tests -------------- - -Python Tests -^^^^^^^^^^^^ - -Install dependencies:: - - pip install -e '.[test]' - -To run the Python tests, use:: - - pytest - -If you want coverage statistics as well, you can run:: - - py.test --cov notebook -v --pyargs notebook - -JavaScript Tests -^^^^^^^^^^^^^^^^ - -To run the JavaScript tests, you will need to have PhantomJS and CasperJS -installed:: - - npm install -g casperjs phantomjs-prebuilt - -Then, to run the JavaScript tests:: - - python -m notebook.jstest [group] - -where ``[group]`` is an optional argument that is a path relative to -``notebook/tests/``. -For example, to run all tests in ``notebook/tests/notebook``:: - - python -m notebook.jstest notebook - -or to run just ``notebook/tests/notebook/deletecell.js``:: - - python -m notebook.jstest notebook/deletecell.js - - -Building the Documentation --------------------------- - -To build the documentation you'll need `Sphinx `_, -`pandoc `_ and a few other packages. - -To install (and activate) a conda environment named ``notebook_docs`` -containing all the necessary packages (except pandoc), use:: - - conda create -n notebook_docs pip - conda activate notebook_docs # Linux and OS X - activate notebook_docs # Windows - pip install .[docs] - -If you want to install the necessary packages with ``pip``, use the following instead:: - - pip install .[docs] - -Once you have installed the required packages, you can build the docs with:: - - cd docs - make html - -After that, the generated HTML files will be available at -``build/html/index.html``. You may view the docs in your browser. - -You can automatically check if all hyperlinks are still valid:: - - make linkcheck - -Windows users can find ``make.bat`` in the ``docs`` folder. - -You should also have a look at the `Project Jupyter Documentation Guide`__. - -__ https://jupyter.readthedocs.io/en/latest/contributing/docs-contributions/index.html diff --git a/MANIFEST.in b/MANIFEST.in index c28b820105..743cf31fb3 100644 --- a/MANIFEST.in +++ b/MANIFEST.in @@ -1,32 +1,22 @@ include LICENSE -include CONTRIBUTING.rst -include README.md -include CHANGELOG.md -include package.json -include bower.json -include .bowerrc +include *.md include pyproject.toml include setup.py -include setupbase.py -include Dockerfile -include *.js -graft tools -graft notebook/tests - -# Translations -graft notebook/i18n +include jupyter-config/notebook.json -# Documentation -graft docs -exclude docs/\#* +include package.json +include install.json +include ts*.json -# Examples -graft examples +graft notebook/labextension +graft notebook/static +graft notebook/templates -# docs subdirs we want to skip -prune docs/build -prune docs/gh-pages -prune docs/dist +# Javascript files +graft src +graft style +prune **/node_modules +prune lib # Patterns to exclude from any directory global-exclude *~ diff --git a/README.md b/README.md index 8f6c2c7491..6796a75c06 100644 --- a/README.md +++ b/README.md @@ -1,41 +1,57 @@ # Jupyter Notebook -[![Google Group](https://img.shields.io/badge/-Google%20Group-lightgrey.svg)](https://groups.google.com/forum/#!forum/jupyter) -[![Build Status](https://travis-ci.org/jupyter/notebook.svg?branch=master)](https://travis-ci.org/jupyter/notebook) +![Github Actions Status](https://github.com/jupyter/notebook/workflows/Build/badge.svg) [![Documentation Status](https://readthedocs.org/projects/jupyter-notebook/badge/?version=latest)](https://jupyter-notebook.readthedocs.io/en/latest/?badge=latest) +[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/jupyter/notebook/main?urlpath=tree) [![codecov](https://codecov.io/gh/jupyter/notebook/branch/master/graph/badge.svg)](https://codecov.io/gh/jupyter/notebook) The Jupyter notebook is a web-based notebook environment for interactive computing. -![Jupyter notebook example](docs/resources/running_code_med.png "Jupyter notebook example") +![Jupyter notebook example](docs/resources/running_code_med.png 'Jupyter notebook example') ### Notice -Please note that this repository is currently maintained by a skeleton crew of maintainers from the Jupyter community. We encourage users to transition to JupyterLab, where more immediate support can occur. Our approach moving forward will be: -1. To maintain the security of the Jupyter Notebook. That means security-related issues and pull requests are our highest priority. -2. To address JupyterLab [feature parity issues](https://github.com/jupyterlab/jupyterlab/issues?q=is%3Aopen+is%3Aissue+label%3A%22tag%3AFeature+Parity%22). As part of this effort, we are also working on a better [notebook-only experience](https://github.com/jupyterlab/jupyterlab/issues/8450) in JupyterLab for users who prefer the UI of the classic Jupyter Notebook. -3. To be responsive to the hard work of community members who have opened pull requests. We are triaging these PRs. We cannot support or maintain new features at this time, but we welcome security and other sustainability fixes. +The Jupyter Notebook project is currently undertaking a transition to a more modern code base built from the ground-up using JupyterLab components and extensions. -If you have an open pull request with a new feature or if you were planning to open one, please consider shipping it as a [notebook extension](https://jupyter-notebook.readthedocs.io/en/stable/extending/) instead. +There is new stream of work which was submitted and then accepted as a Jupyter Enhancement Proposal (JEP): https://jupyter.org/enhancement-proposals/79-notebook-v7/notebook-v7.html -##### Alternatives to contributing to `notebook` -Additionally, please consider whether your contribution would be appropriate for either the underlying server for Jupyter front-ends, [jupyter_server](https://github.com/jupyter/jupyter_server) or in the [JupyterLab front-end](https://github.com/jupyterlab/jupyterlab). +#### Notebook v7 + +The next major version of Notebook will be based on: + +- JupyterLab components for the frontend +- Jupyter Server for the Python server + +This results in a rather change to the `jupyter/notebook` code base. + +To learn more about Notebook v7: https://jupyter.org/enhancement-proposals/79-notebook-v7/notebook-v7.html + +#### Classic Notebook v6 + +Maintainance and security-related issues are now being addressed in the [`6.4.x`](https://github.com/jupyter/notebook/tree/6.4.x) branch. + +New features and continuous improvement is now focused on Notebook v7 (see section above). + +If you have an open pull request with a new feature or if you were planning to open one, we encourage switching over to the Jupyter Server and JupyterLab architecture, and distribute it as a server extension and / or JupyterLab prebuilt extension. That way your new feature will also be compatible with the new Notebook v7. + +### Jupyter notebook, the language-agnostic evolution of IPython notebo -### Jupyter notebook, the language-agnostic evolution of IPython notebook Jupyter notebook is a language-agnostic HTML notebook application for Project Jupyter. In 2015, Jupyter notebook was released as a part of The Big Split™ of the IPython codebase. IPython 3 was the last major monolithic -release containing both language-agnostic code, such as the *IPython notebook*, -and language specific code, such as the *IPython kernel for Python*. As +release containing both language-agnostic code, such as the _IPython notebook_, +and language specific code, such as the _IPython kernel for Python_. As computing spans across many languages, Project Jupyter will continue to develop the language-agnostic **Jupyter notebook** in this repo and with the help of the community develop language specific kernels which are found in their own discrete repos. -[[The Big Split™ announcement](https://blog.jupyter.org/the-big-split-9d7b88a031a7)] -[[Jupyter Ascending blog post](https://blog.jupyter.org/jupyter-ascending-1bf5b362d97e)] + +- [The Big Split™ announcement](https://blog.jupyter.org/the-big-split-9d7b88a031a7) +- [Jupyter Ascending blog post](https://blog.jupyter.org/jupyter-ascending-1bf5b362d97e) ## Installation + You can find the installation documentation for the [Jupyter platform, on ReadTheDocs](https://jupyter.readthedocs.io/en/latest/install.html). The documentation for advanced usage of Jupyter notebook can be found @@ -44,7 +60,9 @@ The documentation for advanced usage of Jupyter notebook can be found For a local installation, make sure you have [pip installed](https://pip.readthedocs.io/en/stable/installing/) and run: - $ pip install notebook +```bash +pip install notebook +``` ## Usage - Running Jupyter notebook @@ -52,7 +70,9 @@ For a local installation, make sure you have Launch with: - $ jupyter notebook +```bash +jupyter notebook +``` ### Running in a remote installation @@ -60,17 +80,23 @@ You need some configuration before starting Jupyter notebook remotely. See [Runn ## Development Installation -See [`CONTRIBUTING.rst`](CONTRIBUTING.rst) for how to set up a local development installation. +See [`CONTRIBUTING.md`](CONTRIBUTING.md) for how to set up a local development installation. ## Contributing -If you are interested in contributing to the project, see [`CONTRIBUTING.rst`](CONTRIBUTING.rst). +If you are interested in contributing to the project, see [`CONTRIBUTING.md`](CONTRIBUTING.md). + +## Community Guidelines and Code of Conduct + +This repository is a Jupyter project and follows the Jupyter +[Community Guides and Code of Conduct](https://jupyter.readthedocs.io/en/latest/community/content-community.html). ## Resources + - [Project Jupyter website](https://jupyter.org) - [Online Demo at jupyter.org/try](https://jupyter.org/try) - [Documentation for Jupyter notebook](https://jupyter-notebook.readthedocs.io/en/latest/) [[PDF](https://media.readthedocs.org/pdf/jupyter-notebook/latest/jupyter-notebook.pdf)] - [Korean Version of Installation](https://github.com/ChungJooHo/Jupyter_Kor_doc/) - [Documentation for Project Jupyter](https://jupyter.readthedocs.io/en/latest/index.html) [[PDF](https://media.readthedocs.org/pdf/jupyter/latest/jupyter.pdf)] - [Issues](https://github.com/jupyter/notebook/issues) -- [Technical support - Jupyter Google Group](https://groups.google.com/forum/#!forum/jupyter) +- [Technical support - Jupyter Google Group](https://discourse.jupyter.org/) diff --git a/RELEASE.md b/RELEASE.md index 81fdd0fdee..451db86400 100644 --- a/RELEASE.md +++ b/RELEASE.md @@ -1,80 +1,9 @@ -# Making a Release of Notebook +# Releasing Jupyter Notebook -## Using `jupyter_releaser` +## Automated releases The recommended way to make a release is to use [`jupyter_releaser`](https://github.com/jupyter-server/jupyter_releaser#checklist-for-adoption). -## Manual Release Process +We follow a similar bump strategy as in JupyterLab: https://github.com/jupyterlab/jupyterlab/blob/master/RELEASE.md#bump-version -### Start from a fresh git checkout and conda environment - -#### Set the release branch - -```bash -export release_branch=master -``` - -#### Create the git checkout - -```bash -git clone git@github.com:jupyter/notebook.git -cd notebook -git checkout ${release_banch} -``` - -#### Create and activate the conda environment - -```bash -conda create -n notebook-release -c conda-forge jupyter -conda activate notebook-release -``` - -### Perform a local dev install - -```bash -pip install -ve . -``` - -### Install release dependencies - -```bash -conda install -c conda-forge nodejs babel -npm install -g po2json -pip install jupyter_releaser # used for build dependencies (build, twine, tbump) -``` - -### Update the version - -```bash -tbump --only-patch # set the new version -python setup.py jsversion -git commit -am "Release $(python setup.py --version)" -git tag $(python setup.py --version) -``` - -### Create the artifacts - -```bash -rm -rf dist -python -m build . -``` - -### Upload the artifacts - -```bash -twine check dist/* && twine upload dist/* -``` - -### Change back to dev version - -```bash -tbump --only-patch # Add the .dev suffix -python setup.py jsversion -git commit -am "Back to dev version" -``` - -### Push the commits and tags - -```bash -git push origin ${release_branch} --tags -``` +If you would still like to do the release manually instead, read below. diff --git a/app/index.js b/app/index.js new file mode 100644 index 0000000000..5e753c50bc --- /dev/null +++ b/app/index.js @@ -0,0 +1,338 @@ +// Copyright (c) Jupyter Development Team. +// Distributed under the terms of the Modified BSD License. + +// Inspired by: https://github.com/jupyterlab/jupyterlab/blob/master/dev_mode/index.js + +import { PageConfig, URLExt } from '@jupyterlab/coreutils'; + +require('./style.js'); +require('./extraStyle.js'); + +function loadScript(url) { + return new Promise((resolve, reject) => { + const newScript = document.createElement('script'); + newScript.onerror = reject; + newScript.onload = resolve; + newScript.async = true; + document.head.appendChild(newScript); + newScript.src = url; + }); +} +async function loadComponent(url, scope) { + await loadScript(url); + + // From MIT-licensed https://github.com/module-federation/module-federation-examples/blob/af043acd6be1718ee195b2511adf6011fba4233c/advanced-api/dynamic-remotes/app1/src/App.js#L6-L12 + // eslint-disable-next-line no-undef + await __webpack_init_sharing__('default'); + const container = window._JUPYTERLAB[scope]; + // Initialize the container, it may provide shared modules and may need ours + // eslint-disable-next-line no-undef + await container.init(__webpack_share_scopes__.default); +} + +async function createModule(scope, module) { + try { + const factory = await window._JUPYTERLAB[scope].get(module); + return factory(); + } catch (e) { + console.warn( + `Failed to create module: package: ${scope}; module: ${module}` + ); + throw e; + } +} + +/** + * The main function + */ +async function main() { + // load extra packages + require('@jupyterlab/celltags'); + + const mimeExtensionsMods = [ + require('@jupyterlab/javascript-extension'), + require('@jupyterlab/json-extension'), + require('@jupyterlab/pdf-extension'), + require('@jupyterlab/vega5-extension') + ]; + const mimeExtensions = await Promise.all(mimeExtensionsMods); + + const disabled = []; + // TODO: formalize the way the set of initial extensions and plugins are specified + let baseMods = [ + // @jupyter-notebook plugins + require('@jupyter-notebook/application-extension'), + require('@jupyter-notebook/console-extension'), + require('@jupyter-notebook/docmanager-extension'), + require('@jupyter-notebook/documentsearch-extension'), + require('@jupyter-notebook/help-extension'), + require('@jupyter-notebook/notebook-extension'), + // to handle opening new tabs after creating a new terminal + require('@jupyter-notebook/terminal-extension'), + + // @jupyterlab plugins + require('@jupyterlab/application-extension').default.filter(({ id }) => + [ + '@jupyterlab/application-extension:commands', + '@jupyterlab/application-extension:context-menu', + '@jupyterlab/application-extension:faviconbusy' + ].includes(id) + ), + require('@jupyterlab/apputils-extension').default.filter(({ id }) => + [ + '@jupyterlab/apputils-extension:palette', + '@jupyterlab/apputils-extension:settings', + '@jupyterlab/apputils-extension:state', + '@jupyterlab/apputils-extension:themes', + '@jupyterlab/apputils-extension:themes-palette-menu', + '@jupyterlab/apputils-extension:toolbar-registry' + ].includes(id) + ), + require('@jupyterlab/codemirror-extension').default.filter(({ id }) => + [ + '@jupyterlab/codemirror-extension:services', + '@jupyterlab/codemirror-extension:codemirror' + ].includes(id) + ), + require('@jupyterlab/completer-extension').default.filter(({ id }) => + ['@jupyterlab/completer-extension:manager'].includes(id) + ), + require('@jupyterlab/console-extension').default.filter(({ id }) => + [ + '@jupyterlab/console-extension:completer', + '@jupyterlab/console-extension:cursor-position', + '@jupyterlab/console-extension:factory', + '@jupyterlab/console-extension:foreign', + '@jupyterlab/console-extension:tracker' + ].includes(id) + ), + require('@jupyterlab/docmanager-extension').default.filter(({ id }) => + [ + '@jupyterlab/docmanager-extension:plugin', + '@jupyterlab/docmanager-extension:download' + ].includes(id) + ), + require('@jupyterlab/docprovider-extension'), + require('@jupyterlab/documentsearch-extension').default.filter(({ id }) => + ['@jupyterlab/documentsearch:plugin'].includes(id) + ), + require('@jupyterlab/filebrowser-extension').default.filter(({ id }) => + ['@jupyterlab/filebrowser-extension:factory'].includes(id) + ), + require('@jupyterlab/fileeditor-extension').default.filter(({ id }) => + ['@jupyterlab/fileeditor-extension:plugin'].includes(id) + ), + require('@jupyterlab/mainmenu-extension'), + require('@jupyterlab/mathjax2-extension'), + require('@jupyterlab/notebook-extension').default.filter(({ id }) => + [ + '@jupyterlab/notebook-extension:code-console', + '@jupyterlab/notebook-extension:export', + '@jupyterlab/notebook-extension:factory', + '@jupyterlab/notebook-extension:tracker', + '@jupyterlab/notebook-extension:widget-factory' + ].includes(id) + ), + require('@jupyterlab/rendermime-extension'), + require('@jupyterlab/shortcuts-extension'), + // so new terminals can be create from the menu + require('@jupyterlab/terminal-extension'), + require('@jupyterlab/theme-light-extension'), + require('@jupyterlab/theme-dark-extension'), + require('@jupyterlab/translation-extension'), + // Add the "Hub Control Panel" menu option when running in JupyterHub + require('@jupyterlab/user-extension'), + require('@jupyterlab/hub-extension') + ]; + + // The motivation here is to only load a specific set of plugins dependending on + // the current page + const page = PageConfig.getOption('notebookPage'); + switch (page) { + case 'tree': { + baseMods = baseMods.concat([ + require('@jupyterlab/filebrowser-extension').default.filter(({ id }) => + [ + '@jupyterlab/filebrowser-extension:browser', + '@jupyterlab/filebrowser-extension:download', + '@jupyterlab/filebrowser-extension:file-upload-status', + '@jupyterlab/filebrowser-extension:open-with', + '@jupyterlab/filebrowser-extension:share-file' + ].includes(id) + ), + require('@jupyter-notebook/tree-extension'), + require('@jupyterlab/running-extension') + ]); + break; + } + case 'notebooks': { + baseMods = baseMods.concat([ + require('@jupyterlab/completer-extension').default.filter(({ id }) => + ['@jupyterlab/completer-extension:notebooks'].includes(id) + ), + require('@jupyterlab/tooltip-extension').default.filter(({ id }) => + [ + '@jupyterlab/tooltip-extension:manager', + '@jupyterlab/tooltip-extension:notebooks' + ].includes(id) + ) + ]); + break; + } + case 'consoles': { + baseMods = baseMods.concat([ + require('@jupyterlab/completer-extension').default.filter(({ id }) => + ['@jupyterlab/completer-extension:consoles'].includes(id) + ), + require('@jupyterlab/tooltip-extension').default.filter(({ id }) => + [ + '@jupyterlab/tooltip-extension:manager', + '@jupyterlab/tooltip-extension:consoles' + ].includes(id) + ) + ]); + break; + } + case 'edit': { + baseMods = baseMods.concat([ + require('@jupyterlab/completer-extension').default.filter(({ id }) => + ['@jupyterlab/completer-extension:files'].includes(id) + ), + require('@jupyterlab/filebrowser-extension').default.filter(({ id }) => + ['@jupyterlab/filebrowser-extension:browser'].includes(id) + ) + ]); + break; + } + } + + /** + * Iterate over active plugins in an extension. + * + * #### Notes + * This also populates the disabled + */ + function* activePlugins(extension) { + // Handle commonjs or es2015 modules + let exports; + if (Object.prototype.hasOwnProperty.call(extension, '__esModule')) { + exports = extension.default; + } else { + // CommonJS exports. + exports = extension; + } + + let plugins = Array.isArray(exports) ? exports : [exports]; + for (let plugin of plugins) { + if (PageConfig.Extension.isDisabled(plugin.id)) { + disabled.push(plugin.id); + continue; + } + yield plugin; + } + } + + const extension_data = JSON.parse( + PageConfig.getOption('federated_extensions') + ); + + const mods = []; + const federatedExtensionPromises = []; + const federatedMimeExtensionPromises = []; + const federatedStylePromises = []; + + const extensions = await Promise.allSettled( + extension_data.map(async data => { + await loadComponent( + `${URLExt.join( + PageConfig.getOption('fullLabextensionsUrl'), + data.name, + data.load + )}`, + data.name + ); + return data; + }) + ); + + extensions.forEach(p => { + if (p.status === 'rejected') { + // There was an error loading the component + console.error(p.reason); + return; + } + + const data = p.value; + if (data.extension) { + federatedExtensionPromises.push(createModule(data.name, data.extension)); + } + if (data.mimeExtension) { + federatedMimeExtensionPromises.push( + createModule(data.name, data.mimeExtension) + ); + } + if (data.style) { + federatedStylePromises.push(createModule(data.name, data.style)); + } + }); + + // Add the base frontend extensions + const baseFrontendMods = await Promise.all(baseMods); + baseFrontendMods.forEach(p => { + for (let plugin of activePlugins(p)) { + mods.push(plugin); + } + }); + + // Add the federated extensions. + const federatedExtensions = await Promise.allSettled( + federatedExtensionPromises + ); + federatedExtensions.forEach(p => { + if (p.status === 'fulfilled') { + for (let plugin of activePlugins(p.value)) { + mods.push(plugin); + } + } else { + console.error(p.reason); + } + }); + + // Add the federated mime extensions. + const federatedMimeExtensions = await Promise.allSettled( + federatedMimeExtensionPromises + ); + federatedMimeExtensions.forEach(p => { + if (p.status === 'fulfilled') { + for (let plugin of activePlugins(p.value)) { + mimeExtensions.push(plugin); + } + } else { + console.error(p.reason); + } + }); + + // Load all federated component styles and log errors for any that do not + (await Promise.allSettled(federatedStylePromises)) + .filter(({ status }) => status === 'rejected') + .forEach(({ reason }) => { + console.error(reason); + }); + + const NotebookApp = require('@jupyter-notebook/application').NotebookApp; + const app = new NotebookApp({ mimeExtensions }); + + app.registerPluginModules(mods); + + // Expose global app instance when in dev mode or when toggled explicitly. + const exposeAppInBrowser = + (PageConfig.getOption('exposeAppInBrowser') || '').toLowerCase() === 'true'; + + if (exposeAppInBrowser) { + window.jupyterapp = app; + } + + await app.start(); +} + +window.addEventListener('load', main); diff --git a/app/package.json b/app/package.json new file mode 100644 index 0000000000..17bcaa368d --- /dev/null +++ b/app/package.json @@ -0,0 +1,240 @@ +{ + "name": "@jupyter-notebook/app", + "version": "7.0.0-alpha.0", + "private": true, + "scripts": { + "build": "webpack", + "build:prod": "webpack --mode=production", + "clean": "rimraf build && jlpm run clean:static", + "clean:static": "rimraf -g \"../notebook/static/!(favicons)\"", + "prepublishOnly": "yarn run build", + "watch": "webpack --config ./webpack.config.watch.js" + }, + "resolutions": { + "@jupyter-notebook/application": "~7.0.0-alpha.0", + "@jupyter-notebook/application-extension": "~7.0.0-alpha.0", + "@jupyter-notebook/console-extension": "~7.0.0-alpha.0", + "@jupyter-notebook/docmanager-extension": "~7.0.0-alpha.0", + "@jupyter-notebook/documentsearch-extension": "~7.0.0-alpha.0", + "@jupyter-notebook/help-extension": "~7.0.0-alpha.0", + "@jupyter-notebook/notebook-extension": "~7.0.0-alpha.0", + "@jupyter-notebook/terminal-extension": "~7.0.0-alpha.0", + "@jupyter-notebook/tree-extension": "~7.0.0-alpha.0", + "@jupyter-notebook/ui-components": "~7.0.0-alpha.0", + "@jupyterlab/application": "~4.0.0-alpha.5", + "@jupyterlab/application-extension": "~4.0.0-alpha.5", + "@jupyterlab/apputils": "~4.0.0-alpha.5", + "@jupyterlab/apputils-extension": "~4.0.0-alpha.5", + "@jupyterlab/celltags": "~4.0.0-alpha.5", + "@jupyterlab/codeeditor": "~4.0.0-alpha.5", + "@jupyterlab/codemirror-extension": "~4.0.0-alpha.5", + "@jupyterlab/completer": "~4.0.0-alpha.5", + "@jupyterlab/completer-extension": "~4.0.0-alpha.5", + "@jupyterlab/console": "~4.0.0-alpha.5", + "@jupyterlab/console-extension": "~4.0.0-alpha.5", + "@jupyterlab/coreutils": "~6.0.0-alpha.5", + "@jupyterlab/docmanager": "~4.0.0-alpha.5", + "@jupyterlab/docmanager-extension": "~4.0.0-alpha.5", + "@jupyterlab/docprovider": "~4.0.0-alpha.5", + "@jupyterlab/docprovider-extension": "~4.0.0-alpha.5", + "@jupyterlab/documentsearch": "~4.0.0-alpha.5", + "@jupyterlab/documentsearch-extension": "~4.0.0-alpha.5", + "@jupyterlab/filebrowser": "~4.0.0-alpha.5", + "@jupyterlab/filebrowser-extension": "~4.0.0-alpha.5", + "@jupyterlab/fileeditor": "~4.0.0-alpha.5", + "@jupyterlab/fileeditor-extension": "~4.0.0-alpha.5", + "@jupyterlab/hub-extension": "~4.0.0-alpha.5", + "@jupyterlab/javascript-extension": "~4.0.0-alpha.5", + "@jupyterlab/json-extension": "~4.0.0-alpha.5", + "@jupyterlab/mainmenu": "~4.0.0-alpha.5", + "@jupyterlab/mainmenu-extension": "~4.0.0-alpha.5", + "@jupyterlab/mathjax2-extension": "~4.0.0-alpha.5", + "@jupyterlab/notebook": "~4.0.0-alpha.5", + "@jupyterlab/notebook-extension": "~4.0.0-alpha.5", + "@jupyterlab/observables": "~5.0.0-alpha.5", + "@jupyterlab/outputarea": "~4.0.0-alpha.5", + "@jupyterlab/pdf-extension": "~4.0.0-alpha.5", + "@jupyterlab/rendermime": "~4.0.0-alpha.5", + "@jupyterlab/rendermime-extension": "~4.0.0-alpha.5", + "@jupyterlab/rendermime-interfaces": "~4.0.0-alpha.5", + "@jupyterlab/running-extension": "~4.0.0-alpha.5", + "@jupyterlab/services": "~7.0.0-alpha.5", + "@jupyterlab/settingregistry": "~4.0.0-alpha.5", + "@jupyterlab/shared-models": "~4.0.0-alpha.5", + "@jupyterlab/shortcuts-extension": "~4.0.0-alpha.5", + "@jupyterlab/statedb": "~4.0.0-alpha.5", + "@jupyterlab/statusbar": "~4.0.0-alpha.5", + "@jupyterlab/terminal": "~4.0.0-alpha.5", + "@jupyterlab/terminal-extension": "~4.0.0-alpha.5", + "@jupyterlab/theme-dark-extension": "~4.0.0-alpha.5", + "@jupyterlab/theme-light-extension": "~4.0.0-alpha.5", + "@jupyterlab/tooltip": "~4.0.0-alpha.5", + "@jupyterlab/tooltip-extension": "~4.0.0-alpha.5", + "@jupyterlab/translation": "~4.0.0-alpha.5", + "@jupyterlab/translation-extension": "~4.0.0-alpha.5", + "@jupyterlab/ui-components": "~4.0.0-alpha.20", + "@jupyterlab/user": "~4.0.0-alpha.5", + "@jupyterlab/user-extension": "~4.0.0-alpha.5", + "@jupyterlab/vega5-extension": "~4.0.0-alpha.5", + "@lumino/algorithm": "~1.9.1", + "@lumino/application": "~1.28.1", + "@lumino/commands": "~1.20.0", + "@lumino/coreutils": "~1.12.0", + "@lumino/disposable": "~1.10.1", + "@lumino/domutils": "~1.8.1", + "@lumino/dragdrop": "~1.14.0", + "@lumino/messaging": "~1.10.1", + "@lumino/properties": "~1.8.1", + "@lumino/signaling": "~1.10.1", + "@lumino/virtualdom": "~1.14.1", + "@lumino/widgets": "~1.31.1", + "react": "~17.0.2", + "react-dom": "~17.0.2", + "yjs": "~13.5.27" + }, + "dependencies": { + "@jupyter-notebook/application": "^7.0.0-alpha.0", + "@jupyter-notebook/application-extension": "^7.0.0-alpha.0", + "@jupyter-notebook/console-extension": "^7.0.0-alpha.0", + "@jupyter-notebook/docmanager-extension": "^7.0.0-alpha.0", + "@jupyter-notebook/documentsearch-extension": "^7.0.0-alpha.0", + "@jupyter-notebook/help-extension": "^7.0.0-alpha.0", + "@jupyter-notebook/notebook-extension": "^7.0.0-alpha.0", + "@jupyter-notebook/terminal-extension": "^7.0.0-alpha.0", + "@jupyter-notebook/tree-extension": "^7.0.0-alpha.0", + "@jupyter-notebook/ui-components": "^7.0.0-alpha.0", + "@jupyterlab/application-extension": "^4.0.0-alpha.5", + "@jupyterlab/apputils-extension": "^4.0.0-alpha.5", + "@jupyterlab/celltags": "^4.0.0-alpha.5", + "@jupyterlab/codemirror-extension": "^4.0.0-alpha.5", + "@jupyterlab/completer-extension": "^4.0.0-alpha.5", + "@jupyterlab/console-extension": "^4.0.0-alpha.5", + "@jupyterlab/coreutils": "~6.0.0-alpha.5", + "@jupyterlab/docmanager-extension": "^4.0.0-alpha.5", + "@jupyterlab/docprovider-extension": "^4.0.0-alpha.5", + "@jupyterlab/documentsearch-extension": "^4.0.0-alpha.5", + "@jupyterlab/filebrowser-extension": "^4.0.0-alpha.5", + "@jupyterlab/fileeditor-extension": "^4.0.0-alpha.5", + "@jupyterlab/hub-extension": "^4.0.0-alpha.5", + "@jupyterlab/javascript-extension": "^4.0.0-alpha.5", + "@jupyterlab/json-extension": "^4.0.0-alpha.5", + "@jupyterlab/mainmenu-extension": "^4.0.0-alpha.5", + "@jupyterlab/mathjax2-extension": "^4.0.0-alpha.5", + "@jupyterlab/notebook-extension": "^4.0.0-alpha.5", + "@jupyterlab/pdf-extension": "^4.0.0-alpha.5", + "@jupyterlab/rendermime-extension": "^4.0.0-alpha.5", + "@jupyterlab/running-extension": "^4.0.0-alpha.5", + "@jupyterlab/shortcuts-extension": "^4.0.0-alpha.5", + "@jupyterlab/terminal-extension": "^4.0.0-alpha.5", + "@jupyterlab/theme-dark-extension": "^4.0.0-alpha.5", + "@jupyterlab/theme-light-extension": "^4.0.0-alpha.5", + "@jupyterlab/tooltip-extension": "^4.0.0-alpha.5", + "@jupyterlab/translation-extension": "^4.0.0-alpha.5", + "@jupyterlab/user-extension": "^4.0.0-alpha.5", + "@jupyterlab/vega5-extension": "^4.0.0-alpha.5" + }, + "devDependencies": { + "@jupyterlab/builder": "^4.0.0-alpha.5", + "@jupyterlab/buildutils": "^4.0.0-alpha.5", + "@types/rimraf": "^3.0.0", + "css-loader": "~5.0.1", + "file-loader": "~5.0.2", + "fs-extra": "^8.1.0", + "glob": "~7.1.6", + "mini-css-extract-plugin": "~0.9.0", + "npm-run-all": "^4.1.5", + "raw-loader": "~4.0.0", + "rimraf": "~3.0.2", + "style-loader": "~1.0.1", + "svg-url-loader": "~6.0.0", + "url-loader": "~4.1.1", + "watch": "~1.0.2", + "webpack": "^5.7.0", + "webpack-bundle-analyzer": "^4.1.0", + "webpack-cli": "^4.2.0", + "webpack-merge": "^5.1.2", + "whatwg-fetch": "^3.0.0" + }, + "jupyterlab": { + "name": "Jupyter Notebook", + "extensions": [ + "@jupyter-notebook/application-extension", + "@jupyter-notebook/console-extension", + "@jupyter-notebook/docmanager-extension", + "@jupyter-notebook/documentsearch-extension", + "@jupyter-notebook/help-extension", + "@jupyter-notebook/notebook-extension", + "@jupyter-notebook/terminal-extension", + "@jupyter-notebook/tree-extension", + "@jupyterlab/application-extension", + "@jupyterlab/apputils-extension", + "@jupyterlab/codemirror-extension", + "@jupyterlab/completer-extension", + "@jupyterlab/console-extension", + "@jupyterlab/docmanager-extension", + "@jupyterlab/documentsearch-extension", + "@jupyterlab/filebrowser-extension", + "@jupyterlab/fileeditor-extension", + "@jupyterlab/hub-extension", + "@jupyterlab/mainmenu-extension", + "@jupyterlab/mathjax2-extension", + "@jupyterlab/notebook-extension", + "@jupyterlab/rendermime-extension", + "@jupyterlab/running-extension", + "@jupyterlab/shortcuts-extension", + "@jupyterlab/terminal-extension", + "@jupyterlab/theme-dark-extension", + "@jupyterlab/theme-light-extension", + "@jupyterlab/tooltip-extension", + "@jupyterlab/translation-extension", + "@jupyterlab/user-extension" + ], + "singletonPackages": [ + "@jupyterlab/application", + "@jupyterlab/apputils", + "@jupyterlab/celltags", + "@jupyterlab/codeeditor", + "@jupyterlab/completer", + "@jupyterlab/console", + "@jupyterlab/coreutils", + "@jupyterlab/docmanager", + "@jupyterlab/docprovider", + "@jupyterlab/documentsearch", + "@jupyterlab/filebrowser", + "@jupyterlab/fileeditor", + "@jupyterlab/mainmenu", + "@jupyterlab/notebook", + "@jupyterlab/observables", + "@jupyterlab/outputarea", + "@jupyterlab/rendermime", + "@jupyterlab/rendermime-interfaces", + "@jupyterlab/services", + "@jupyterlab/settingregistry", + "@jupyterlab/shared-models", + "@jupyterlab/statedb", + "@jupyterlab/statusbar", + "@jupyterlab/terminal", + "@jupyterlab/tooltip", + "@jupyterlab/translation", + "@jupyterlab/user", + "@jupyterlab/ui-components", + "@lumino/algorithm", + "@lumino/application", + "@lumino/commands", + "@lumino/coreutils", + "@lumino/disposable", + "@lumino/domutils", + "@lumino/dragdrop", + "@lumino/messaging", + "@lumino/properties", + "@lumino/signaling", + "@lumino/virtualdom", + "@lumino/widgets", + "react", + "react-dom", + "yjs" + ], + "mimeExtensions": {}, + "linkedPackages": {} + } +} diff --git a/app/publicpath.js b/app/publicpath.js new file mode 100644 index 0000000000..751281fe5b --- /dev/null +++ b/app/publicpath.js @@ -0,0 +1,37 @@ +// Copyright (c) Jupyter Development Team. +// Distributed under the terms of the Modified BSD License. + +// We dynamically set the webpack public path based on the page config +// settings from the JupyterLab app. We copy some of the pageconfig parsing +// logic in @jupyterlab/coreutils below, since this must run before any other +// files are loaded (including @jupyterlab/coreutils). + +/** + * Get global configuration data for the Jupyter application. + * + * @param name - The name of the configuration option. + * + * @returns The config value or an empty string if not found. + * + * #### Notes + * All values are treated as strings. + * For browser based applications, it is assumed that the page HTML + * includes a script tag with the id `jupyter-config-data` containing the + * configuration as valid JSON. In order to support the classic Notebook, + * we fall back on checking for `body` data of the given `name`. + */ +function getOption(name) { + let configData = Object.create(null); + // Use script tag if available. + if (typeof document !== 'undefined' && document) { + const el = document.getElementById('jupyter-config-data'); + + if (el) { + configData = JSON.parse(el.textContent || '{}'); + } + } + return configData[name] || ''; +} + +// eslint-disable-next-line no-undef +__webpack_public_path__ = getOption('fullStaticUrl') + '/'; diff --git a/app/style.js b/app/style.js new file mode 100644 index 0000000000..461bab1ce9 --- /dev/null +++ b/app/style.js @@ -0,0 +1 @@ +import '@jupyterlab/celltags/style/index.js'; diff --git a/app/webpack.config.js b/app/webpack.config.js new file mode 100644 index 0000000000..639402d247 --- /dev/null +++ b/app/webpack.config.js @@ -0,0 +1,180 @@ +// Copyright (c) Jupyter Development Team. +// Distributed under the terms of the Modified BSD License. + +// Heavily inspired (and slightly tweaked) from: +// https://github.com/jupyterlab/jupyterlab/blob/master/examples/federated/core_package/webpack.config.js + +const fs = require('fs-extra'); +const path = require('path'); +const webpack = require('webpack'); +const merge = require('webpack-merge').default; +const { ModuleFederationPlugin } = webpack.container; +const BundleAnalyzerPlugin = require('webpack-bundle-analyzer') + .BundleAnalyzerPlugin; + +const Build = require('@jupyterlab/builder').Build; +const baseConfig = require('@jupyterlab/builder/lib/webpack.config.base'); + +const data = require('./package.json'); + +const names = Object.keys(data.dependencies).filter(name => { + const packageData = require(path.join(name, 'package.json')); + return packageData.jupyterlab !== undefined; +}); + +// Ensure a clear build directory. +const buildDir = path.resolve(__dirname, 'build'); +if (fs.existsSync(buildDir)) { + fs.removeSync(buildDir); +} +fs.ensureDirSync(buildDir); + +// Copy extra files +const index = path.resolve(__dirname, 'index.js'); +const cssImports = path.resolve(__dirname, 'style.js'); +fs.copySync(index, path.resolve(buildDir, 'index.js')); +fs.copySync(cssImports, path.resolve(buildDir, 'extraStyle.js')); + +const extras = Build.ensureAssets({ + packageNames: names, + output: buildDir, + schemaOutput: path.resolve(__dirname, '..', 'notebook') +}); + +/** + * Create the webpack ``shared`` configuration + */ +function createShared(packageData) { + // Set up module federation sharing config + const shared = {}; + const extensionPackages = packageData.jupyterlab.extensions; + + // Make sure any resolutions are shared + for (let [pkg, requiredVersion] of Object.entries(packageData.resolutions)) { + shared[pkg] = { requiredVersion }; + } + + // Add any extension packages that are not in resolutions (i.e., installed from npm) + for (let pkg of extensionPackages) { + if (!shared[pkg]) { + shared[pkg] = { + requiredVersion: require(`${pkg}/package.json`).version + }; + } + } + + // Add dependencies and sharedPackage config from extension packages if they + // are not already in the shared config. This means that if there is a + // conflict, the resolutions package version is the one that is shared. + const extraShared = []; + for (let pkg of extensionPackages) { + let pkgShared = {}; + let { + dependencies = {}, + jupyterlab: { sharedPackages = {} } = {} + } = require(`${pkg}/package.json`); + for (let [dep, requiredVersion] of Object.entries(dependencies)) { + if (!shared[dep]) { + pkgShared[dep] = { requiredVersion }; + } + } + + // Overwrite automatic dependency sharing with custom sharing config + for (let [dep, config] of Object.entries(sharedPackages)) { + if (config === false) { + delete pkgShared[dep]; + } else { + if ('bundled' in config) { + config.import = config.bundled; + delete config.bundled; + } + pkgShared[dep] = config; + } + } + extraShared.push(pkgShared); + } + + // Now merge the extra shared config + const mergedShare = {}; + for (let sharedConfig of extraShared) { + for (let [pkg, config] of Object.entries(sharedConfig)) { + // Do not override the basic share config from resolutions + if (shared[pkg]) { + continue; + } + + // Add if we haven't seen the config before + if (!mergedShare[pkg]) { + mergedShare[pkg] = config; + continue; + } + + // Choose between the existing config and this new config. We do not try + // to merge configs, which may yield a config no one wants + let oldConfig = mergedShare[pkg]; + + // if the old one has import: false, use the new one + if (oldConfig.import === false) { + mergedShare[pkg] = config; + } + } + } + + Object.assign(shared, mergedShare); + + // Transform any file:// requiredVersion to the version number from the + // imported package. This assumes (for simplicity) that the version we get + // importing was installed from the file. + for (let [pkg, { requiredVersion }] of Object.entries(shared)) { + if (requiredVersion && requiredVersion.startsWith('file:')) { + shared[pkg].requiredVersion = require(`${pkg}/package.json`).version; + } + } + + // Add singleton package information + for (let pkg of packageData.jupyterlab.singletonPackages) { + if (shared[pkg]) { + shared[pkg].singleton = true; + } + } + + return shared; +} + +// Make a bootstrap entrypoint +const entryPoint = path.join(buildDir, 'bootstrap.js'); +const bootstrap = 'import("./index.js");'; +fs.writeFileSync(entryPoint, bootstrap); + +if (process.env.NODE_ENV === 'production') { + baseConfig.mode = 'production'; +} + +if (process.argv.includes('--analyze')) { + extras.push(new BundleAnalyzerPlugin()); +} + +module.exports = [ + merge(baseConfig, { + mode: 'development', + entry: ['./publicpath.js', './' + path.relative(__dirname, entryPoint)], + output: { + path: path.resolve(__dirname, '..', 'notebook/static/'), + library: { + type: 'var', + name: ['_JUPYTERLAB', 'CORE_OUTPUT'] + }, + filename: 'bundle.js' + }, + plugins: [ + new ModuleFederationPlugin({ + library: { + type: 'var', + name: ['_JUPYTERLAB', 'CORE_LIBRARY_FEDERATION'] + }, + name: 'CORE_FEDERATION', + shared: createShared(data) + }) + ] + }) +].concat(extras); diff --git a/app/webpack.config.watch.js b/app/webpack.config.watch.js new file mode 100644 index 0000000000..afebfa6491 --- /dev/null +++ b/app/webpack.config.watch.js @@ -0,0 +1,17 @@ +const base = require('./webpack.config'); +const ExtraWatchWebpackPlugin = require('extra-watch-webpack-plugin'); + +module.exports = [ + { + ...base[0], + bail: false, + watch: true, + plugins: [ + ...base[0].plugins, + new ExtraWatchWebpackPlugin({ + files: ['../packages/_metapackage/tsconfig.tsbuildinfo'] + }) + ] + }, + ...base.slice(1) +]; diff --git a/binder/environment.yml b/binder/environment.yml new file mode 100644 index 0000000000..e6af5214fa --- /dev/null +++ b/binder/environment.yml @@ -0,0 +1,13 @@ +name: notebook +channels: +- conda-forge +dependencies: +- ipywidgets=7.6 +- jupyterlab=3 +- jupyterlab-language-pack-fr-FR +- jupyterlab-link-share>=0.2 +- matplotlib +- numpy +- nodejs +- python >=3.9,<3.10 +- xeus-python diff --git a/binder/example.ipynb b/binder/example.ipynb new file mode 100644 index 0000000000..51a2c3208d --- /dev/null +++ b/binder/example.ipynb @@ -0,0 +1,339 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Welcome to RetroLab! 👋\n", + "\n", + "**RetroLab is an alternative distribution of JupyterLab**. It is built using the same components as in JupyterLab, and reuse a lot of the work from the JupyterLab community by leveraging the new federated (prebuilt) extension system.\n", + "\n", + "The goal of RetroLab is to provide an interface focused on the notebook for users that would like a leaner and simpler interface with a **modern look and old school touch to it**.\n", + "\n", + "It is supposed to complement JupyterLab and its single document mode, not to replace it! All these different interfaces can perfectly be installed together in the same environment:\n", + "\n", + "- JupyterLab (`jupyterlab` package)\n", + "- NBClassic (`nbclassic` package): provides the Classic Notebook interface formely developed in https://github.com/jupyter/notebook\n", + "- RetroLab (`retrolab` package): the interface you are probably currently using if looking at this notebook :)" + ] + }, + { + "attachments": { + "2d33971b-509e-433b-809e-2f0861a13105.png": { + "image/png": "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" + }, + "5aa6b072-c4d7-47de-9e75-0a107a37e2f2.png": { + "image/png": "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" + }, + "c448a783-da5a-499b-a52d-62be28a72438.png": { + "image/png": "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" + }, + "d183cf17-977b-4c28-b892-123bde959d5b.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Files 📂 and Running Sessions 🏃‍♀️\n", + "\n", + "Just like in the classic notebook, RetroLab lets you navigate the files in a separate browser tab. \n", + "\n", + "Go ahead and click on the Jupyter icon in the top left corner!\n", + "\n", + "![image.png](attachment:d183cf17-977b-4c28-b892-123bde959d5b.png)\n", + "\n", + "It will open a new browser tab with the listing of the files on the server:\n", + "\n", + "![image.png](attachment:5aa6b072-c4d7-47de-9e75-0a107a37e2f2.png)\n", + "\n", + "It also shows the list of running sessions and terminals in the `Running` tab:\n", + "\n", + "![image.png](attachment:c448a783-da5a-499b-a52d-62be28a72438.png)\n", + "\n", + "Alternatively it is also possible to access this page using the command in the `View` menu:\n", + "\n", + "![image.png](attachment:2d33971b-509e-433b-809e-2f0861a13105.png)" + ] + }, + { + "attachments": { + "72f98bea-d61c-40cd-8f56-29df50ae5f8d.png": { + "image/png": "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" + }, + "86ac8b15-8a6b-4d4d-b315-0c8a73870e3b.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Editing Files 🖊️\n", + "\n", + "RetroLab also has support for editing files. Double-click on a file (or `Right Click > Open`) to open the editor:\n", + "\n", + "![image.png](attachment:72f98bea-d61c-40cd-8f56-29df50ae5f8d.png)\n", + "\n", + "![image.png](attachment:86ac8b15-8a6b-4d4d-b315-0c8a73870e3b.png)" + ] + }, + { + "attachments": { + "23b23672-e7ae-44f0-9588-63208bcf0caf.png": { + "image/png": "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" + }, + "9016e117-00db-490f-80c4-fa3ed6766d0f.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Terminals 🖥️\n", + "\n", + "To create a new Terminal, select `File > New > Terminal` in the menu:\n", + "\n", + "![image.png](attachment:9016e117-00db-490f-80c4-fa3ed6766d0f.png)\n", + "\n", + "The terminal opens in a new browser tab:\n", + "\n", + "![image.png](attachment:23b23672-e7ae-44f0-9588-63208bcf0caf.png)" + ] + }, + { + "attachments": { + "72198f40-0581-4a18-bc23-8b4674351a97.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Command Palette 🎨\n", + "\n", + "RetroLab includes a command palette, just like in JupyterLab.\n", + "\n", + "Hit `Ctrl-Shift-C` or `Accel-Shift-C` to activate it. Or via the menu with `View > Activate Command Palette`:\n", + "\n", + "![image.png](attachment:72198f40-0581-4a18-bc23-8b4674351a97.png)\n", + "\n", + "Using the palette is very convenient and can give a significant productivity boost over time!" + ] + }, + { + "attachments": { + "52cfe8f1-5d7f-4e99-8f43-95a16a8601bb.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Themes 🌈\n", + "\n", + "Since RetroLab is heavily built on top of JupyterLab, it also has support for a Dark Mode! 🕶️\n", + "\n", + "Go to `Settings > JupyterLab Theme > JupyterLab Dark` to select the theme:\n", + "\n", + "![image.png](attachment:52cfe8f1-5d7f-4e99-8f43-95a16a8601bb.png)\n", + "\n", + "\n", + "New themes can be installed using the federated extension system. These themes will be compatible with both JupyterLab and RetroLab." + ] + }, + { + "attachments": { + "ac1323eb-c6e0-4b7c-80f3-7bf5f84adf98.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Zen Mode 😌\n", + "\n", + "This is an exclusivity in RetroLab 😎\n", + "\n", + "Activate the palette and choose `Toggle Zen Mode`. The interface will focus on the notebook and the notebook only!\n", + "\n", + "![image.png](attachment:ac1323eb-c6e0-4b7c-80f3-7bf5f84adf98.png)\n", + "\n", + "Press `Escape` to exit, or re-run the `Toggle Zen Mode` command from the palette." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Third Party Extensions 🧩\n", + "\n", + "RetroLab supports third-party extensions developed for JupyterLab 3.0+, using the new distribution system. These extensions can be installed via `pip`.\n", + "\n", + "For example the extension to enable Jupyter Widgets rendering in both JupyterLab and RetroLab can be installed using the following command (run the cell): " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!pip install ipywidgets" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now reload the page and resume from here. In the next section we will be able to create and use Jupyter Widgets!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Widgets\n", + "\n", + "Now let's instantiate a new widget:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "from ipywidgets import IntSlider\n", + "slider = IntSlider()\n", + "slider" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "slider" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Rich Display\n", + "\n", + "Just like in many Jupyter Frontends, RetroLab supports rich display rendering. For example:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from IPython.display import Latex\n", + "Latex(r\"\"\"\\begin{eqnarray}\n", + "\\nabla \\times \\vec{\\mathbf{B}} -\\, \\frac1c\\, \\frac{\\partial\\vec{\\mathbf{E}}}{\\partial t} & = \\frac{4\\pi}{c}\\vec{\\mathbf{j}} \\\\\n", + "\\nabla \\cdot \\vec{\\mathbf{E}} & = 4 \\pi \\rho \\\\\n", + "\\nabla \\times \\vec{\\mathbf{E}}\\, +\\, \\frac1c\\, \\frac{\\partial\\vec{\\mathbf{B}}}{\\partial t} & = \\vec{\\mathbf{0}} \\\\\n", + "\\nabla \\cdot \\vec{\\mathbf{B}} & = 0 \n", + "\\end{eqnarray}\"\"\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Matplotlib figures:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "x = np.linspace(0, 10, 100)\n", + "\n", + "plt.plot(x, np.sin(x))\n", + "plt.plot(x, np.cos(x))\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Or even HTML:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from IPython.display import HTML\n", + "from IPython.display import display\n", + "\n", + "s = \"\"\"\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
Header 1Header 2
row 1, cell 1row 1, cell 2
row 2, cell 1row 2, cell 2
\"\"\"\n", + "h = HTML(s)\n", + "display(h)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## That's it!\n", + "\n", + "Hope you enjoyed the tour. If you have more question or any other issues, don't hesitate to go to the repository on GitHub!\n", + "\n", + "https://github.com/jupyter/notebook" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/binder/postBuild b/binder/postBuild new file mode 100644 index 0000000000..be56c9a480 --- /dev/null +++ b/binder/postBuild @@ -0,0 +1,6 @@ +#!/bin/bash +set -euo pipefail + +python -m pip install -e . +jlpm && jlpm run build +jlpm run develop diff --git a/bower.json b/bower.json deleted file mode 100644 index 393db02ad1..0000000000 --- a/bower.json +++ /dev/null @@ -1,29 +0,0 @@ -{ - "name": "jupyter-notebook-deps", - "version": "0.0.1", - "dependencies": { - "backbone": "components/backbone#~1.2", - "bootstrap": "bootstrap#~3.4", - "bootstrap-tour": "0.9.0", - "codemirror": "components/codemirror#5.56.0+components1", - "create-react-class": "https://cdn.jsdelivr.net/npm/create-react-class@15.6.3/create-react-class.min.js", - "es6-promise": "~1.0", - "font-awesome": "components/font-awesome#~4.7.0", - "jed": "~1.1.1", - "jquery": "components/jquery#~3.5.0", - "jquery-typeahead": "~2.10.6", - "jquery-ui": "components/jqueryui#~1.12", - "marked": "~0.7", - "MathJax": "^2.7.4", - "moment": "~2.19.3", - "react": "~16.0.0", - "requirejs": "~2.2", - "requirejs-text": "~2.0.15", - "requirejs-plugins": "~1.0.3", - "text-encoding": "~0.1", - "underscore": "components/underscore#~1.8.3", - "xterm.js": "https://unpkg.com/xterm@~3.1.0/dist/xterm.js", - "xterm.js-css": "https://unpkg.com/xterm@~3.1.0/dist/xterm.css", - "xterm.js-fit": "https://unpkg.com/xterm@~3.1.0/dist/addons/fit/fit.js" - } -} diff --git a/buildutils/package.json b/buildutils/package.json new file mode 100644 index 0000000000..cf3904c08f --- /dev/null +++ b/buildutils/package.json @@ -0,0 +1,43 @@ +{ + "name": "@jupyter-notebook/buildutils", + "version": "7.0.0-alpha.0", + "private": true, + "description": "Jupyter Notebook - Build Utilities", + "homepage": "https://github.com/jupyter/notebook", + "bugs": { + "url": "https://github.com/jupyter/notebook/issues" + }, + "repository": { + "type": "git", + "url": "https://github.com/jupyter/notebook.git" + }, + "license": "BSD-3-Clause", + "author": "Project Jupyter", + "main": "lib/index.js", + "types": "lib/index.d.ts", + "directories": { + "lib": "lib/" + }, + "files": [ + "lib/*.d.ts", + "lib/*.js.map", + "lib/*.js" + ], + "scripts": { + "build": "tsc", + "clean": "rimraf lib && rimraf tsconfig.tsbuildinfo", + "prepublishOnly": "npm run build", + "watch": "tsc -w --listEmittedFiles" + }, + "dependencies": { + "@jupyterlab/buildutils": "^4.0.0-alpha.5", + "commander": "^6.2.0", + "fs-extra": "^9.1.0", + "typescript": "~4.1.3" + }, + "devDependencies": { + "@types/fs-extra": "^9.0.10", + "@types/node": "^14.6.1", + "rimraf": "~3.0.0" + } +} diff --git a/buildutils/src/develop.ts b/buildutils/src/develop.ts new file mode 100644 index 0000000000..ef9d6689c4 --- /dev/null +++ b/buildutils/src/develop.ts @@ -0,0 +1,56 @@ +/* ----------------------------------------------------------------------------- +| Copyright (c) Jupyter Development Team. +| Distributed under the terms of the Modified BSD License. +|----------------------------------------------------------------------------*/ + +import commander from 'commander'; + +import fs from 'fs-extra'; + +import path from 'path'; + +import process from 'process'; + +import { run } from '@jupyterlab/buildutils'; + +commander + .description('Setup the repository for develop mode') + .option('--overwrite', 'Force linking the notebook schemas') + .option('--source', 'The path to the notebook package') + .action((options: any) => { + const { overwrite } = options; + const prefix = run( + 'python -c "import sys; print(sys.prefix)"', + { + stdio: 'pipe' + }, + true + ); + const source = path.resolve(options.source ?? process.cwd()); + const sourceDir = path.join( + source, + 'notebook', + 'schemas', + '@jupyter-notebook' + ); + const destDir = path.join( + prefix, + 'share', + 'jupyter', + 'lab', + 'schemas', + '@jupyter-notebook' + ); + if (overwrite) { + try { + fs.unlinkSync(destDir); + console.log('Removed previous symlink:', destDir); + } catch (e) { + console.info('Skip unlinkink', destDir); + } + } + console.log('Symlinking:', sourceDir, destDir); + fs.symlinkSync(sourceDir, destDir, 'dir'); + }); + +commander.parse(process.argv); diff --git a/buildutils/src/ensure-repo.ts b/buildutils/src/ensure-repo.ts new file mode 100644 index 0000000000..33281e1179 --- /dev/null +++ b/buildutils/src/ensure-repo.ts @@ -0,0 +1,38 @@ +import * as path from 'path'; + +import * as fs from 'fs-extra'; + +import { writePackageData } from '@jupyterlab/buildutils'; + +/** + * Ensure the application package resolutions. + */ +function ensureResolutions(): string[] { + const basePath = path.resolve('.'); + const corePath = path.join(basePath, 'app', 'package.json'); + const corePackage = fs.readJSONSync(corePath); + + corePackage.jupyterlab.mimeExtensions = {}; + corePackage.jupyterlab.linkedPackages = {}; + corePackage.resolutions = {}; + + const packages = Object.keys(corePackage.dependencies).concat( + corePackage.jupyterlab.singletonPackages + ); + + packages.forEach(name => { + const data = require(`${name}/package.json`); + // Insist on a restricted version in the yarn resolution. + corePackage.resolutions[name] = `~${data.version}`; + }); + + // Write the package.json back to disk. + if (writePackageData(corePath, corePackage)) { + return ['Updated dev mode']; + } + return []; +} + +if (require.main === module) { + void ensureResolutions(); +} diff --git a/buildutils/src/release-bump.ts b/buildutils/src/release-bump.ts new file mode 100644 index 0000000000..e942c7ada7 --- /dev/null +++ b/buildutils/src/release-bump.ts @@ -0,0 +1,122 @@ +/* ----------------------------------------------------------------------------- +| Copyright (c) Jupyter Development Team. +| Distributed under the terms of the Modified BSD License. +|----------------------------------------------------------------------------*/ + +/** + * Inspired by: https://github.com/jupyterlab/jupyterlab/blob/master/buildutils/src/bumpversion.ts + */ + +import * as utils from '@jupyterlab/buildutils'; + +import commander from 'commander'; + +import { getPythonVersion, postbump } from './utils'; + +// Specify the program signature. +commander + .description('Update the version') + .option('--dry-run', 'Dry run') + .option('--force', 'Force the upgrade') + .option('--skip-commit', 'Whether to skip commit changes') + .arguments('') + .action((spec: any, opts: any) => { + // Get the previous version. + const prev = getPythonVersion(); + const isFinal = /\d+\.\d+\.\d+$/.test(prev); + + // Whether to commit after bumping + const commit = opts.skipCommit !== true; + + // for "next", determine whether to use "patch" or "build" + if (spec === 'next') { + spec = isFinal ? 'patch' : 'build'; + } + + // For patch, defer to `patch:release` command + if (spec === 'patch') { + let cmd = 'jlpm run release:patch'; + if (opts.force) { + cmd += ' --force'; + } + if (!commit) { + cmd += ' --skip-commit'; + } + utils.run(cmd); + process.exit(0); + } + + // Make sure we have a valid version spec. + const options = ['major', 'minor', 'release', 'build']; + if (options.indexOf(spec) === -1) { + throw new Error(`Version spec must be one of: ${options}`); + } + if (isFinal && spec === 'release') { + throw new Error('Use "major" or "minor" to switch back to alpha release'); + } + if (isFinal && spec === 'build') { + throw new Error('Cannot increment a build on a final release'); + } + + // Run pre-bump script. + utils.prebump(); + + // Handle dry runs. + if (opts.dryRun) { + utils.run(`bumpversion --dry-run --verbose ${spec}`); + return; + } + + // If this is a major release during the alpha cycle, bump + // just the Python version. + if (prev.indexOf('a') !== -1 && spec === 'major') { + // Bump the version. + utils.run(`bumpversion ${spec}`); + + // Run the post-bump script. + postbump(commit); + + return; + } + + // Determine the version spec to use for lerna. + let lernaVersion = 'preminor'; + if (spec === 'build') { + lernaVersion = 'prerelease'; + // a -> b + } else if (spec === 'release' && prev.indexOf('a') !== -1) { + lernaVersion = 'prerelease --preid=beta'; + // b -> rc + } else if (spec === 'release' && prev.indexOf('b') !== -1) { + lernaVersion = 'prerelease --preid=rc'; + // rc -> final + } else if (spec === 'release' && prev.indexOf('rc') !== -1) { + lernaVersion = 'patch'; + } + if (lernaVersion === 'preminor') { + lernaVersion += ' --preid=alpha'; + } + + let cmd = `jlpm run lerna version --force-publish --no-push --no-git-tag-version ${lernaVersion}`; + if (opts.force) { + cmd += ' --yes'; + } + // For a preminor release, we bump 10 minor versions so that we do + // not conflict with versions during minor releases of the top + // level package. + if (lernaVersion === 'preminor') { + for (let i = 0; i < 10; i++) { + utils.run(cmd); + } + } else { + utils.run(cmd); + } + + // Bump the version. + utils.run(`bumpversion ${spec} --allow-dirty`); + + // Run the post-bump script. + postbump(commit); + }); + +commander.parse(process.argv); diff --git a/buildutils/src/release-patch.ts b/buildutils/src/release-patch.ts new file mode 100644 index 0000000000..df72a1639e --- /dev/null +++ b/buildutils/src/release-patch.ts @@ -0,0 +1,54 @@ +/* ----------------------------------------------------------------------------- +| Copyright (c) Jupyter Development Team. +| Distributed under the terms of the Modified BSD License. +|----------------------------------------------------------------------------*/ + +/** + * Inspired by: https://github.com/jupyterlab/jupyterlab/blob/master/buildutils/src/patch-release.ts + */ + +import * as utils from '@jupyterlab/buildutils'; + +import commander from 'commander'; + +import { getPythonVersion, postbump } from './utils'; + +// Specify the program signature. +commander + .description('Create a patch release') + .option('--force', 'Force the upgrade') + .option('--skip-commit', 'Whether to skip commit changes') + .action((options: any) => { + // Make sure we can patch release. + const pyVersion = getPythonVersion(); + if ( + pyVersion.includes('a') || + pyVersion.includes('b') || + pyVersion.includes('rc') + ) { + throw new Error('Can only make a patch release from a final version'); + } + + // Run pre-bump actions. + utils.prebump(); + + // Patch the python version + utils.run('bumpversion patch'); // switches to alpha + utils.run('bumpversion release --allow-dirty'); // switches to beta + utils.run('bumpversion release --allow-dirty'); // switches to rc. + utils.run('bumpversion release --allow-dirty'); // switches to final. + + // Version the changed + let cmd = + 'jlpm run lerna version patch --no-push --force-publish --no-git-tag-version'; + if (options.force) { + cmd += ' --yes'; + } + utils.run(cmd); + + // Whether to commit after bumping + const commit = options.skipCommit !== true; + postbump(commit); + }); + +commander.parse(process.argv); diff --git a/buildutils/src/utils.ts b/buildutils/src/utils.ts new file mode 100644 index 0000000000..777e7bd95e --- /dev/null +++ b/buildutils/src/utils.ts @@ -0,0 +1,23 @@ +import { run } from '@jupyterlab/buildutils'; + +/** + * Get the current version of notebook + */ +export function getPythonVersion(): string { + const cmd = 'python setup.py --version'; + const lines = run(cmd, { stdio: 'pipe' }, true).split('\n'); + return lines[lines.length - 1]; +} + +export function postbump(commit = true): void { + // run the integrity + run('jlpm integrity'); + + const newPyVersion = getPythonVersion(); + + // Commit changes. + if (commit) { + run(`git commit -am "Release ${newPyVersion}"`); + run(`git tag ${newPyVersion}`); + } +} diff --git a/buildutils/tsconfig.json b/buildutils/tsconfig.json new file mode 100644 index 0000000000..945e3ce9d7 --- /dev/null +++ b/buildutils/tsconfig.json @@ -0,0 +1,10 @@ +{ + "extends": "../tsconfigbase", + "compilerOptions": { + "outDir": "lib", + "rootDir": "src", + "module": "commonjs" + }, + "include": ["src/*"], + "references": [] +} diff --git a/docs-translations/hi-IN/README.md b/docs-translations/hi-IN/README.md deleted file mode 100644 index e234e3dac7..0000000000 --- a/docs-translations/hi-IN/README.md +++ /dev/null @@ -1,77 +0,0 @@ -# Jupyter Notebook - -[![Google Group](https://img.shields.io/badge/-Google%20Group-lightgrey.svg)](https://groups.google.com/forum/#!forum/jupyter) -[![Build Status](https://travis-ci.org/jupyter/notebook.svg?branch=master)](https://travis-ci.org/jupyter/notebook) -[![Documentation Status](https://readthedocs.org/projects/jupyter-notebook/badge/?version=latest)](https://jupyter-notebook.readthedocs.io/en/latest/?badge=latest) - - - -Jupyter नोटबुक इंटरैक्टिव के लिए एक वेब-आधारित नोटबुक वातावरण है -कंप्यूटिंग। - -![Jupyter notebook example](resources/running_code_med.png "Jupyter notebook example") - -### नोटिस -कृपया ध्यान दें कि इस भंडार का रखरखाव वर्तमान में जुपिटर समुदाय के एक कंकाल के दल द्वारा किया जाता है। हम उपयोगकर्ताओं को जुपिटरलैब में संक्रमण के लिए प्रोत्साहित करते हैं, जहां अधिक तत्काल समर्थन हो सकता है। हमारा दृष्टिकोण आगे बढ़ेगा: - -1. जुपिटर नोटबुक की सुरक्षा बनाए रखने के लिए। इसका मतलब है कि सुरक्षा से संबंधित मुद्दे और पुल अनुरोध हमारी सर्वोच्च प्राथमिकता है। -2. JupyterLab को संबोधित करने के लिए [समता मुद्दों की सुविधा](https://github.com/jupyterlab/jupyterlab/issues?q=is%3Aopen+is%3Aissue+label%3A%22tag%3AFeature+Parity%22)| इस प्रयास के हिस्से के रूप में, हम एक बेहतर [नोटबुक-ओनली एक्सपीरियंस](https://github.com/jupyterlab/jupyterlab/issues/8450)JupyterLab में उन उपयोगकर्ताओं के लिए जो क्लासिक Jupyter नोटबुक के UI को पसंद करते हैं। -3. समुदाय के सदस्यों की कड़ी मेहनत के प्रति उत्तरदायी होना जिन्होंने पुल अनुरोधों को खोला है। हम इन पीआर को ट्राई कर रहे हैं। हम इस समय नई सुविधाओं का समर्थन या रखरखाव नहीं कर सकते हैं, लेकिन हम सुरक्षा और अन्य स्थिरता सुधारों का स्वागत करते हैं। - -यदि आपके पास एक नई सुविधा के साथ एक खुला पुल अनुरोध है या यदि आप एक खोलने की योजना बना रहे हैं, तो कृपया इसे [नोटबुक एक्सटेंशन](https://jupyter-notebook.readthedocs.io/en/stable/extending/) के रूप में शिपिंग करने पर विचार करें। बजाय। - -##### `नोटबुक` में योगदान करने के लिए विकल्प -इसके अतिरिक्त, कृपया विचार करें कि क्या आपका योगदान Jupyter फ्रंट-एंड के लिए अंतर्निहित सर्वर के लिए उपयुक्त होगा, [jupyter server](https://github.com/jupyter/jupyter_server) या में [JupyterLab फ़्रंट एंड](https://github.com/jupyterlab/jupyterlab). - -### जुपिटर नोटबुक, आइपीथॉन नोटबुक की भाषा-अज्ञेय विकास -Jupyter नोटबुक एक भाषा-अज्ञेय HTML नोटबुक अनुप्रयोग है -प्रोजेक्ट जुपिटर। 2015 में, जुपिटर नोटबुक के एक भाग के रूप में जारी किया गया था -IPython कोडबेस का बिग स्प्लिट ™। IPython 3 अंतिम प्रमुख अखंड था -दोनों भाषा-अज्ञेयवादी कोड, जैसे *IPython नोटबुक*, -और भाषा विशिष्ट कोड, जैसे कि *अजगर के लिए आईपीथॉन कर्नेल*। जैसा -कई भाषाओं में कंप्यूटिंग स्पैन, प्रोजेक्ट जुपिटर विकसित करना जारी रखेगा -भाषा-अज्ञेय **जुपिटर नोटबुक** इस रेपो में और की मदद से -समुदाय भाषा विशिष्ट गुठली विकसित करते हैं जो अपने आप में पाए जाते हैं -असतत रेपो। -[[Big Split™ घोषणा](https://blog.jupyter.org/the-big-split-9d7b88a031a7)] -[[Jupyter आरोही ब्लॉग पोस्ट](https://blog.jupyter.org/jupyter-ascending-1bf5b362d97e)] - -## स्थापना -आप के लिए स्थापना प्रलेखन पा सकते हैं -[बृहस्पति मंच, ReadTheDocs पर](https://jupyter.readthedocs.io/en/latest/install.html). -जुपिटर नोटबुक के उन्नत उपयोग के लिए दस्तावेज पाया जा सकता है -[यहाँ](https://jupyter-notebook.readthedocs.io/en/latest/). - -स्थानीय स्थापना के लिए, सुनिश्चित करें कि आपके पास है -[pip स्थापित](https://pip.readthedocs.io/en/stable/installing/) और भाग खड़ा हुआ: - - $ pip install notebook - -## उपयोग - जुपिटर नोटबुक चल रहा है - -### स्थानीय स्थापना में चल रहा है - -इसके साथ लॉन्च करें: - - $ jupyter notebook - -### एक दूरस्थ स्थापना में चल रहा है - -आपको बृहस्पति नोटबुक को दूरस्थ रूप से शुरू करने से पहले कुछ कॉन्फ़िगरेशन की आवश्यकता है। देखें [नोटबुक सर्वर चला रहा है](https://jupyter-notebook.readthedocs.io/en/stable/public_server.html). - -## विकास स्थापना - -स्थानीय विकास की स्थापना कैसे करें, इसके लिए [`CONTRIBUTING.rst`](CONTRIBUTING.rst) देखें। - -## योगदान - -यदि आप इस परियोजना में योगदान देने में रुचि रखते हैं, तो [`CONTRIBUTING.rst`](CONTRIBUTING.rst) देखें। - -## साधन -- [Project Jupyter website](https://jupyter.org) -- [Online Demo at jupyter.org/try](https://jupyter.org/try) -- [Documentation for Jupyter notebook](https://jupyter-notebook.readthedocs.io/en/latest/) [[PDF](https://media.readthedocs.org/pdf/jupyter-notebook/latest/jupyter-notebook.pdf)] -- [Korean Version of Installation](https://github.com/ChungJooHo/Jupyter_Kor_doc/) -- [Documentation for Project Jupyter](https://jupyter.readthedocs.io/en/latest/index.html) [[PDF](https://media.readthedocs.org/pdf/jupyter/latest/jupyter.pdf)] -- [Issues](https://github.com/jupyter/notebook/issues) -- [Technical support - Jupyter Google Group](https://groups.google.com/forum/#!forum/jupyter) \ No newline at end of file diff --git a/docs-translations/hi-IN/resources/Notebook_Editor.GIF b/docs-translations/hi-IN/resources/Notebook_Editor.GIF deleted file mode 100644 index 50e433d41f..0000000000 Binary files a/docs-translations/hi-IN/resources/Notebook_Editor.GIF and /dev/null differ diff --git a/docs-translations/hi-IN/resources/dashboard.GIF b/docs-translations/hi-IN/resources/dashboard.GIF deleted file mode 100644 index e34f1d971b..0000000000 Binary files a/docs-translations/hi-IN/resources/dashboard.GIF and /dev/null differ diff --git a/docs-translations/hi-IN/resources/edit_mode.GIF b/docs-translations/hi-IN/resources/edit_mode.GIF deleted file mode 100644 index 6dd34d0171..0000000000 Binary files a/docs-translations/hi-IN/resources/edit_mode.GIF and /dev/null differ diff --git a/docs-translations/hi-IN/resources/file_editor.GIF b/docs-translations/hi-IN/resources/file_editor.GIF deleted file mode 100644 index 69595f37fa..0000000000 Binary files a/docs-translations/hi-IN/resources/file_editor.GIF and /dev/null differ diff --git a/docs-translations/hi-IN/resources/running_code_med.png b/docs-translations/hi-IN/resources/running_code_med.png deleted file mode 100644 index 6f80194745..0000000000 Binary files a/docs-translations/hi-IN/resources/running_code_med.png and /dev/null differ diff --git a/docs-translations/ja-JP/README.md b/docs-translations/ja-JP/README.md deleted file mode 100644 index 4a344ce26e..0000000000 --- a/docs-translations/ja-JP/README.md +++ /dev/null @@ -1,57 +0,0 @@ -# Jupyter Notebook - -[![Google Group](https://img.shields.io/badge/-Google%20Group-lightgrey.svg)](https://groups.google.com/forum/#!forum/jupyter) -[![Build Status](https://travis-ci.org/jupyter/notebook.svg?branch=master)](https://travis-ci.org/jupyter/notebook) -[![Documentation Status](https://readthedocs.org/projects/jupyter-notebook/badge/?version=latest)](https://jupyter-notebook.readthedocs.io/en/latest/?badge=latest) - -英語版のリンク : [[English Version](http://github.com/jupyter/notebook/)] - -Jupyter Notebookは、インタラクティブなWebベースのノートブック形式の環境です。 - -![Jupyter notebook example](resources/running_code_med.png "Jupyter notebook example") - -### Jupyter Notebook, 言語に依存しないIPython Notebookの進化 - -Jupyter Notebookは、Project Jupyter用の言語に依存しないHTMLノートブックアプリケーションです。 -2015年、Jupyter NotebookはIPythonコードベースのThe Big Split™の一部としてリリースされました。IPython3はIPython Notebookなどのユーザーの言語に依存しないコードとIPython kernel for Pythonのような特定の言語ベースのコードの機能を持ってリリースしました。 -コンピューティングは多くの言語にまたがるため、Project Jupyterはこのリポジトリで言語に依存しない**Jupyter Notebook**を継続的に開発します。そして、コミュニティの助けを借りて、独自のリポジトリにある言語固有のカーネルを開発します。 -[[The Big Split™ announcement](https://blog.jupyter.org/the-big-split-9d7b88a031a7)] -[[Jupyter Ascending blog post](https://blog.jupyter.org/jupyter-ascending-1bf5b362d97e)] - -## インストール - -[Jupyter platform, on ReadTheDocs](https://jupyter.readthedocs.io/en/latest/install.html)から、インストールドキュメントをご覧になれます。 -Jupyter Notebookの発展的な使用方法に関するドキュメントは、[こちら](https://jupyter-notebook.readthedocs.io/en/latest/)をご覧ください。 - -ローカルへのインストールの場合、[pip](https://pip.readthedocs.io/en/stable/installing/)をインストールしていることを確認し、以下のコマンドを実行してください。 - - $ pip install notebook - -## 使用方法 - Jupyter Notebookの実行 - -### ローカルへのインストールにおける実行 - -以下のコマンドをを実行してください： - - $ jupyter notebook - -### リモートへのインストールにおける実行 - -Jupyter Notebookをリモートで起動する前に、いくつかの構成が必要です。 [Notebookサーバーの実行](https://jupyter-notebook.readthedocs.io/en/stable/public_server.html)を参照してください。 - -## 開発用インストール - -開発用インストールのセットアップ方法については、[`CONTRIBUTING.rst`](https://github.com/jupyter/notebook/blob/master/CONTRIBUTING.rst)を参照してください。 - -## 貢献 - -プロジェクトへの貢献に興味がある場合は、[`CONTRIBUTING.rst`](https://github.com/jupyter/notebook/blob/master/CONTRIBUTING.rst)をご覧ください。 - -## 参考 - -- [Project Jupyter website](https://jupyter.org) -- [Online Demo at try.jupyter.org](https://try.jupyter.org) -- [Documentation for Jupyter notebook](https://jupyter-notebook.readthedocs.io/en/latest/) [[PDF](https://media.readthedocs.org/pdf/jupyter-notebook/latest/jupyter-notebook.pdf)] -- [Documentation for Project Jupyter](https://jupyter.readthedocs.io/en/latest/index.html) [[PDF](https://media.readthedocs.org/pdf/jupyter/latest/jupyter.pdf)] -- [Issues](https://github.com/jupyter/notebook/issues) -- [Technical support - Jupyter Google Group](https://groups.google.com/forum/#!forum/jupyter) diff --git a/docs-translations/ja-JP/resources/Notebook_Editor.GIF b/docs-translations/ja-JP/resources/Notebook_Editor.GIF deleted file mode 100644 index 50e433d41f..0000000000 Binary files a/docs-translations/ja-JP/resources/Notebook_Editor.GIF and /dev/null differ diff --git a/docs-translations/ja-JP/resources/dashboard.GIF b/docs-translations/ja-JP/resources/dashboard.GIF deleted file mode 100644 index e34f1d971b..0000000000 Binary files a/docs-translations/ja-JP/resources/dashboard.GIF and /dev/null differ diff --git a/docs-translations/ja-JP/resources/edit_mode.GIF b/docs-translations/ja-JP/resources/edit_mode.GIF deleted file mode 100644 index 6dd34d0171..0000000000 Binary files a/docs-translations/ja-JP/resources/edit_mode.GIF and /dev/null differ diff --git a/docs-translations/ja-JP/resources/file_editor.GIF b/docs-translations/ja-JP/resources/file_editor.GIF deleted file mode 100644 index 69595f37fa..0000000000 Binary files a/docs-translations/ja-JP/resources/file_editor.GIF and /dev/null differ diff --git a/docs-translations/ja-JP/resources/running_code_med.png b/docs-translations/ja-JP/resources/running_code_med.png deleted file mode 100644 index 6f80194745..0000000000 Binary files a/docs-translations/ja-JP/resources/running_code_med.png and /dev/null differ diff --git a/docs-translations/ko-KR/HowtoRun.md b/docs-translations/ko-KR/HowtoRun.md deleted file mode 100644 index eb070dea53..0000000000 --- a/docs-translations/ko-KR/HowtoRun.md +++ /dev/null @@ -1,57 +0,0 @@ -# Notebook 실행하기 - - ## 첫 걸음 - 1. 다음 명령어를 통해 Notebook 서버를 시작하세요 : - - $ jupyter notebook - - 2. 브라우저에 Notebook이 실행된 것을 확인할 수 있습니다. - - -# Notebook 서버 시작하기 - - Notebook을 컴퓨터에 설치하였으면 Notebook 서버를 시작할 수 있습니다. 다음 명령어를 이용하여 Notebook서버를 시작할 수 있습니다. - - $ jupyter notebook - - 이 명령어를 실행하면, 터미널에 웹 응용프로그램의 주소와 서버에 대한 정보가 출력됩니다. - - $ jupyter notebook - $ [I 08:58:24.417 NotebookApp] Serving notebooks from local directory: /Users/catherline - $ [I 08:58:24.417 NotebookApp] 0 active kernels - $ [I 08:58:24.417 NotebookApp] The Jupyter Notebook is running at: http://localhost:8888/ - $ [I 08:58:24.417 NotebookApp] Use Control-C to stop this server and shut down all kernels - - 기본 브라우저를 통해 이 주소가 열립니다. - - Notebook이 브라우저에 열리면, Notebook의 목록을 보여주는 Notebook Dashboard를 볼 수 있습니다. 대체로 가장 상위의 디렉토리를 열어줄 것입니다. - - **Notebook Dashboard** - -![Notebook Dashboard example](resources/dashboard.GIF "Notebook Dashboard") - -# Notebook 서버의 명령어 소개 - - ## 커스텀 IP 나 포트를 이용하여 시작하려면 어떻게 해야할까? - - 기본값으로, Notebook 서버는 포트 8888로 시작됩니다. 만약 포트8888이 사용할 수 없다면, Notebook 서버는 다른 가능한 포트를 찾습니다. 또한 임의로 포트를 설정해주는 것도 가능합니다. 예를 들어 포트 9999로 실행하면 : - - $ jupyter notebook --port 9999 - - - ## 브라우저를 열지않고 Notebook를 열기 - - 브라우저를 열지 않고 Notebook 서버를 시작하려면 : - - $ jupyter notebook --no-browser - - - ## Notebook 서버 옵션 도움말 보기 - - Notebook 서버는 --help 옵션을 통해 도움말 메시지를 제공합니다 : - - $ jupyter notebook --help - - - - diff --git a/docs-translations/ko-KR/Installation.md b/docs-translations/ko-KR/Installation.md deleted file mode 100644 index d5375d3b5e..0000000000 --- a/docs-translations/ko-KR/Installation.md +++ /dev/null @@ -1,33 +0,0 @@ -# Jupyter Notebook 설치하기 - -## 필요한 것 : Python - -Jupyter Notebook 을 설치하기 위해선 Jupyter가 많은 프로그래밍 언어들로 동작되기 때문에, Python이 필요합니다. (Python 3.3이상, Python 2.7) - -Python과 Jupyter를 설치할 때 Anaconda를 이용하는 것을 추천합니다. 밑에서 이를 이용하여 설치할 것입니다. - -## Anaconda 와 conda 를 이용하여 Jupyter 설치하기 - -새로운 이용자들은 Anaconda를 설치하는 것을 강력하게 추천합니다. Anaconda는 Python과 Jupyter를 쉽게 설치하게 해주고, 과학적인 계산과 데이터를 위한 자주 사용되는 패키지들의 설치에도 유용합니다. - -설치 순서 : - - 1. Anaconda를 다운받으세요. Anaconda의 가장 최신의 Python 3버전을 다운 받는 것을 추천합니다. - 2. 다운 받은 Anaconda 의 다운로드 페이지에 있는 설명을 읽고 설치해주세요. - 3. 축하합니다. Jupyter Notebook 을 설치하셨습니다. Jupyter Notebook을 실행하려면 : - - $ jupyter notebook - -## 숙련된 Python 이용자 : pip을 통해 설치하기 - - Python 이용자라면, Anaconda 대신에 Python의 패키지 매니저 pip을 이용하여 설치하세요. - - 첫째로, 가장 최신의 pip인지를 확인하세요; 구 버전은 독립성에 문제가 있을 수 있습니다. - - $ pip install --upgrade pip - - 이제 다음을 이용하여 Jupyter Notebook를 설치하세요 : - - $ pip install jupyter - - (축하합니다. Jupyter Notebook를 설치하셨습니다.) diff --git a/docs-translations/ko-KR/README.md b/docs-translations/ko-KR/README.md deleted file mode 100644 index 4fad2a8dac..0000000000 --- a/docs-translations/ko-KR/README.md +++ /dev/null @@ -1,55 +0,0 @@ -# Jupyter Notebook - -[![Google Group](https://img.shields.io/badge/-Google%20Group-lightgrey.svg)](https://groups.google.com/forum/#!forum/jupyter) -[![Build Status](https://travis-ci.org/jupyter/notebook.svg?branch=master)](https://travis-ci.org/jupyter/notebook) -[![Documentation Status](https://readthedocs.org/projects/jupyter-notebook/badge/?version=latest)](http://jupyter-notebook.readthedocs.io/en/latest/?badge=latest) - -English 버전 링크 : [[English Version](http://github.com/jupyter/notebook/)] - -Jupyter notebook 은 상호 교환을 위한 웹 기반 환경입니다. - -![Jupyter notebook example](resources/running_code_med.png "Jupyter notebook example") - -### Jupyter notebook, 사용자의 언어에 독립적인 IPython notebook의 진화 -Jupyter notebook은 Jupyter 프로젝트를 위한 사용자 언어에 독립적인 HTML 응용 프로그램입니다. -2015년에 Jupyter notebook은 IPython 코드 기반의 The Big Split™ 의 일부분으로 시작되었습니다. -IPython 3는 *IPython notebook* 과 같은 사용자 언어에 독립적인 코드와 *IPython kernel for Python* 과 같은 특정 언어 기반의 코드의 기능을 가지고 출시되었습니다. -컴퓨터에는 많은 언어가 사용되기 때문에, Jupyter 프로젝트는 사용자 언어에 독립적인 **Jupyter notebook** 을 이 저장소와 개인의 독립적인 저장소에 있는 특정 언어 중심의 커널의 도움으로 지속적으로 개발할 것입니다. -[[The Big Split™ announcement](https://blog.jupyter.org/2015/04/15/the-big-split/)] -[[Jupyter Ascending blog post](http://blog.jupyter.org/2015/08/12/first-release-of-jupyter/)] - -## 설치 -설치법 문서는 다음 주소에서 찾을 수 있습니다. -You can find the installation documentation for the -[Jupyter platform, on ReadTheDocs](https://jupyter.readthedocs.io/en/latest/install.html). -조금 더 심화된 Jupyter notebook의 사용은 다음 주소에서 볼 수 있습니다. -[here](https://jupyter-notebook.readthedocs.io/en/latest/). - -설치를 위해서는 -[pip installed](https://pip.readthedocs.io/en/stable/installing/) 가 있는지 확인한 후 다음을 실행해주세요: - - $ pip install notebook - -## 활용 - Jupyter notebook 실행하기 - -### 로컬에서 실행할 때 - -이와 같이 실행하세요: - - $ jupyter notebook - -## 개발 설치 - -[`CONTRIBUTING.rst`](CONTRIBUTING.rst) 을 통해 설치법을 확인하세요. - -## 기여하기 - -이 프로젝트에 기여를 하고 싶다면, [`CONTRIBUTING.rst`](CONTRIBUTING.rst) 을 참고해주세요. - -## 자료 -- [Project Jupyter website](https://jupyter.org) -- [Online Demo at try.jupyter.org](https://try.jupyter.org) -- [Documentation for Jupyter notebook](https://jupyter-notebook.readthedocs.io/en/latest/) [[PDF](https://media.readthedocs.org/pdf/jupyter-notebook/latest/jupyter-notebook.pdf)] -- [Documentation for Project Jupyter](https://jupyter.readthedocs.io/en/latest/index.html) [[PDF](https://media.readthedocs.org/pdf/jupyter/latest/jupyter.pdf)] -- [Issues](https://github.com/jupyter/notebook/issues) -- [Technical support - Jupyter Google Group](https://groups.google.com/forum/#!forum/jupyter) diff --git a/docs-translations/ko-KR/UIComponents.md b/docs-translations/ko-KR/UIComponents.md deleted file mode 100644 index c582c7ead5..0000000000 --- a/docs-translations/ko-KR/UIComponents.md +++ /dev/null @@ -1,38 +0,0 @@ -# UI 기능 - -버그 리포트나 Jupyter Mailing list에 메일을 보내려고 할 때, 개발자나 사용자들이 버그를 진단하거나 해결해줄 경우 다른 UI를 사용하면 시간이 단축된다. -이번 장에서는 Notebook과 Notebook의 다른 모드의 UI 요소를 알려줄 것이다. - - ## Notebook Dashboard - -jupyter notebook 명령어를 실행하면 가장 먼저 Notebook Dashboard가 나타난다. - -![Notebook Dashboard example](resources/dashboard.GIF "Notebook Dashboard") - - - - ## Notebook 편집기 - -편집을 위해 Notebook을 선택했다면, Notebook은 Notebook편집기를 열어준다. - -![Notebook Editor example](resources/Notebook_Editor.GIF "Notebook Editor") - ## Notebook 의 사용자 도움 인터페이스 - -만약 Notebook 편집기의 특정 요소를 더 배우고 싶다면, 도움 메뉴 - 사용자 인터페이스 를 선택함으로써 사용사 인터페이스 도움말을 볼 수 있습니다. - - ## 편집 모드와 Notebook편집기 - -셀이 편집모드에 있다면, 셀 모드 지시자는 셀의 상태를 반영합니다. 이 상태는 오른쪽 위의 작은 연필모양으로 선택가능합니다. 셀이 명령 모드에 있다면, 그 위치에 아이콘이 없습니다. - -![Edit Mode example](resources/edit_mode.GIF "Edit Mode") - - ## 파일 편집기 - -이제 Notebook Dashboard 안의 Notebook 파일이 아닌 표시된 파일을 선택하여 열어야한다고 한다면, 파일은 파일 편집기로 열립니다. - -![File Editor example](resources/file_editor.GIF "File Editor") - - - - - diff --git a/docs-translations/ko-KR/resources/Notebook_Editor.GIF b/docs-translations/ko-KR/resources/Notebook_Editor.GIF deleted file mode 100644 index 50e433d41f..0000000000 Binary files a/docs-translations/ko-KR/resources/Notebook_Editor.GIF and /dev/null differ diff --git a/docs-translations/ko-KR/resources/dashboard.GIF b/docs-translations/ko-KR/resources/dashboard.GIF deleted file mode 100644 index e34f1d971b..0000000000 Binary files a/docs-translations/ko-KR/resources/dashboard.GIF and /dev/null differ diff --git a/docs-translations/ko-KR/resources/edit_mode.GIF b/docs-translations/ko-KR/resources/edit_mode.GIF deleted file mode 100644 index 6dd34d0171..0000000000 Binary files a/docs-translations/ko-KR/resources/edit_mode.GIF and /dev/null differ diff --git a/docs-translations/ko-KR/resources/file_editor.GIF b/docs-translations/ko-KR/resources/file_editor.GIF deleted file mode 100644 index 69595f37fa..0000000000 Binary files a/docs-translations/ko-KR/resources/file_editor.GIF and /dev/null differ diff --git a/docs-translations/ko-KR/resources/running_code_med.png b/docs-translations/ko-KR/resources/running_code_med.png deleted file mode 100644 index 6f80194745..0000000000 Binary files a/docs-translations/ko-KR/resources/running_code_med.png and /dev/null differ diff --git a/docs-translations/zh-CN/README.md b/docs-translations/zh-CN/README.md deleted file mode 100644 index 13da7f722b..0000000000 --- a/docs-translations/zh-CN/README.md +++ /dev/null @@ -1,77 +0,0 @@ -# Jupyter Notebook - -[![Google Group](https://img.shields.io/badge/-Google%20Group-lightgrey.svg)](https://groups.google.com/forum/#!forum/jupyter) -[![Build Status](https://travis-ci.org/jupyter/notebook.svg?branch=master)](https://travis-ci.org/jupyter/notebook) -[![Documentation Status](https://readthedocs.org/projects/jupyter-notebook/badge/?version=latest)](https://jupyter-notebook.readthedocs.io/en/latest/?badge=latest) - - - -Jupyter Notebook是用于交互的基于Web的笔记本环境 -计算。 - -![Jupyter notebook example](resources/running_code_med.png "Jupyter notebook example") - -### 注意 -请注意，这家商店目前由木星社区的骨干团队维护。我们鼓励用户过渡到 JupyterLab，那里可能会立即提供更多支持。我们的方法将向前发展： - -1.维护Jupiter笔记本电脑的安全性。这意味着与安全相关的问题和请求是我们的首要任务。 -2.解决JupyterLab [促进平等问题](https://github.com/jupyterlab/jupyterlab/issues?q=is%3Aopen+is%3Aissue+label%3A%22tag%3AFeature+Parity%22)|作为这项工作的一部分，我们有更好的[仅限笔记本电脑的体验](https://github.com/jupyterlab/jupyterlab/issues/8450)在JupyterLab中，适合喜欢经典Jupyter笔记本UI的用户。 -3.负责提出请求请求的社区成员的辛勤工作。我们正在尝试这些PR。我们目前无法支持或维护新设施，但是我们欢迎安全性和其他稳定性方面的改进。 - -如果您有一个具有新功能的打开请求请求，或者您打算打开一个请求，请将该请求命名为[notebook extension](https://jupyter-notebook.readthedocs.io/en/stable/extending/) 考虑运送为。代替。 - -##### 选择贡献“笔记本” -此外，请考虑您的贡献是否适合Jupyter前端的基础服务器， [jupyter server](https://github.com/jupyter/jupyter_server) 或在 [JupyterLab 前端](https://github.com/jupyterlab/jupyterlab). - -### Jupyter笔记本，与IPython笔记本无关的语言开发 -Jupyter Notebook是与语言无关的HTML Notebook应用程序 -木星计划。 2015年，木星作为笔记本的一部分发布 -IPython代码库的Big Split™。 IPython 3是最后一个主要的整体 -两种与语言无关的代码，例如 *IPython notebook*， -以及特定语言的代码，例如 *用于Python的IPython内核* 。如 -通过多种语言计算SPAN，Jupyter项目将继续发展 -与语言无关 **Jupyter Notebook** 在此仓库中更多帮助下 -社区开发自己发现的特定于语言的内核 -离散回购。 -[[Big Split™ 宣言](https://blog.jupyter.org/the-big-split-9d7b88a031a7)] -[[Jupyter 升序博客文章](https://blog.jupyter.org/jupyter-ascending-1bf5b362d97e)] - -## 成立 -您可以找到以下安装文件 -[Jupiter论坛，在ReadTheDocs上](https://jupyter.readthedocs.io/en/latest/install.html). -可以找到有关Jupiter笔记本的高级使用的文档 -[这里](https://jupyter-notebook.readthedocs.io/en/latest/). - -对于本地安装，请确保您已经 -[pip 成立时间](https://pip.readthedocs.io/en/stable/installing/) 并运行： - - $ pip install notebook - -## 用法-运行木星笔记本 - -### 在本地安装中运行 - -与启动 - - $ jupyter笔记本 - -### 在远程安装中运行 - -在远程启动Jupiter笔记本电脑之前，需要进行一些配置。请参阅 [运行笔记本服务器](https://jupyter-notebook.readthedocs.io/en/stable/public_server.html). - -## 开发设置 - -有关如何建立本地发展 [`CONTRIBUTING.rst`](CONTRIBUTING.rst) 看到。 - -## 贡献 - -如果您有兴趣为这个项目做贡献，请参阅 [`CONTRIBUTING.rst`](CONTRIBUTING.rst). - -## 资源 -- [Project Jupyter website](https://jupyter.org) -- [Online Demo at jupyter.org/try](https://jupyter.org/try) -- [Documentation for Jupyter notebook](https://jupyter-notebook.readthedocs.io/en/latest/) [[PDF](https://media.readthedocs.org/pdf/jupyter-notebook/latest/jupyter-notebook.pdf)] -- [Korean Version of Installation](https://github.com/ChungJooHo/Jupyter_Kor_doc/) -- [Documentation for Project Jupyter](https://jupyter.readthedocs.io/en/latest/index.html) [[PDF](https://media.readthedocs.org/pdf/jupyter/latest/jupyter.pdf)] -- [Issues](https://github.com/jupyter/notebook/issues) -- [Technical support - Jupyter Google Group](https://groups.google.com/forum/#!forum/jupyter) \ No newline at end of file diff --git a/docs-translations/zh-CN/resources/Notebook_Editor.GIF b/docs-translations/zh-CN/resources/Notebook_Editor.GIF deleted file mode 100644 index 50e433d41f..0000000000 Binary files a/docs-translations/zh-CN/resources/Notebook_Editor.GIF and /dev/null differ diff --git a/docs-translations/zh-CN/resources/dashboard.GIF b/docs-translations/zh-CN/resources/dashboard.GIF deleted file mode 100644 index e34f1d971b..0000000000 Binary files a/docs-translations/zh-CN/resources/dashboard.GIF and /dev/null differ diff --git a/docs-translations/zh-CN/resources/edit_mode.GIF b/docs-translations/zh-CN/resources/edit_mode.GIF deleted file mode 100644 index 6dd34d0171..0000000000 Binary files a/docs-translations/zh-CN/resources/edit_mode.GIF and /dev/null differ diff --git a/docs-translations/zh-CN/resources/file_editor.GIF b/docs-translations/zh-CN/resources/file_editor.GIF deleted file mode 100644 index 69595f37fa..0000000000 Binary files a/docs-translations/zh-CN/resources/file_editor.GIF and /dev/null differ diff --git a/docs-translations/zh-CN/resources/running_code_med.png b/docs-translations/zh-CN/resources/running_code_med.png deleted file mode 100644 index 6f80194745..0000000000 Binary files a/docs-translations/zh-CN/resources/running_code_med.png and /dev/null differ diff --git a/docs/Makefile b/docs/Makefile index 02cb617a36..f760bf014c 100644 --- a/docs/Makefile +++ b/docs/Makefile @@ -53,15 +53,11 @@ clean: rm -rf $(BUILDDIR)/* rm -rf source/config.rst -html: source/config.rst +html: $(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/html." -source/config.rst: - python3 autogen_config.py - @echo "Created docs for config options" - dirhtml: $(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml @echo @@ -176,7 +172,7 @@ linkcheck: @echo @echo "Link check complete; look for any errors in the above output " \ "or in $(BUILDDIR)/linkcheck/output.txt." - + spelling: $(SPHINXBUILD) -b spelling $(ALLSPHINXOPTS) $(BUILDDIR)/spelling @echo "Spell check complete; look for any errors in the above output " \ diff --git a/docs/autogen_config.py b/docs/autogen_config.py deleted file mode 100644 index f06efe9171..0000000000 --- a/docs/autogen_config.py +++ /dev/null @@ -1,45 +0,0 @@ -#!/usr/bin/env python - -import os -from notebook.notebookapp import NotebookApp - -header = """\ -.. _config: - - -Config file and command line options -==================================== - -The notebook server can be run with a variety of command line arguments. -A list of available options can be found below in the :ref:`options section -`. - -Defaults for these options can also be set by creating a file named -``jupyter_notebook_config.py`` in your Jupyter folder. The Jupyter -folder is in your home directory, ``~/.jupyter``. - -To create a ``jupyter_notebook_config.py`` file, with all the defaults -commented out, you can use the following command line:: - - $ jupyter notebook --generate-config - - -.. _options: - -Options -------- - -This list of options can be generated by running the following and hitting -enter:: - - $ jupyter notebook --help - -""" -try: - destination = os.path.join(os.path.dirname(__file__), 'source/config.rst') -except: - destination = os.path.join(os.getcwd(), 'config.rst') - -with open(destination, 'w') as f: - f.write(header) - f.write(NotebookApp().document_config_options()) diff --git a/docs/doc-requirements.txt b/docs/doc-requirements.txt index bb439ddcf2..5323a439ac 100644 --- a/docs/doc-requirements.txt +++ b/docs/doc-requirements.txt @@ -1,5 +1,5 @@ sphinx>=1.3.6 -sphinx-rtd-theme +pydata-sphinx-theme nbsphinx sphinxcontrib_github_alt myst_parser diff --git a/docs/environment.yml b/docs/environment.yml index 52ef4df581..5681ebe120 100644 --- a/docs/environment.yml +++ b/docs/environment.yml @@ -3,7 +3,7 @@ channels: - conda-forge dependencies: - python=3.8 -- sphinx_rtd_theme +- pydata-sphinx-theme - jinja2 - tornado - nbformat diff --git a/docs/jsdoc_config.json b/docs/jsdoc_config.json index 4da2e3d8b1..200630dc24 100644 --- a/docs/jsdoc_config.json +++ b/docs/jsdoc_config.json @@ -1,21 +1,16 @@ { - "markdown": { - "parser": "gfm" - }, - "plugins": [ - "plugins/markdown" , - "jsdoc_plugin.js" - ], - "source": { - "include": [ - "../notebook/static/notebook/js/notebook.js" - ] - }, - "tags": { - "allowUnknownTags": true - }, - "templates": { - "cleverLinks": false, - "monospaceLinks": false - } + "markdown": { + "parser": "gfm" + }, + "plugins": ["plugins/markdown", "jsdoc_plugin.js"], + "source": { + "include": ["../notebook/static/notebook/js/notebook.js"] + }, + "tags": { + "allowUnknownTags": true + }, + "templates": { + "cleverLinks": false, + "monospaceLinks": false + } } diff --git a/docs/jsdoc_plugin.js b/docs/jsdoc_plugin.js index 3fa3035020..19974022f9 100644 --- a/docs/jsdoc_plugin.js +++ b/docs/jsdoc_plugin.js @@ -1,12 +1,14 @@ exports.handlers = { - newDoclet: function(e) { - // e.doclet will refer to the newly created doclet - // you can read and modify properties of that doclet if you wish - if (typeof e.doclet.name === 'string') { - if (e.doclet.name[0] == '_') { - console.log('Private method "' + e.doclet.longname + '" not documented.'); - e.doclet.memberof = ''; - } - } + newDoclet: function(e) { + // e.doclet will refer to the newly created doclet + // you can read and modify properties of that doclet if you wish + if (typeof e.doclet.name === 'string') { + if (e.doclet.name[0] == '_') { + console.log( + 'Private method "' + e.doclet.longname + '" not documented.' + ); + e.doclet.memberof = ''; + } } -}; \ No newline at end of file + } +}; diff --git a/docs/resources/notebook_basics.png b/docs/resources/notebook_basics.png deleted file mode 100644 index d75ce11fea..0000000000 Binary files a/docs/resources/notebook_basics.png and /dev/null differ diff --git a/docs/resources/running_code.png b/docs/resources/running_code.png deleted file mode 100644 index c74ee403fd..0000000000 Binary files a/docs/resources/running_code.png and /dev/null differ diff --git a/docs/resources/running_code_med.png b/docs/resources/running_code_med.png index 6f80194745..d45a3fb7bf 100644 Binary files a/docs/resources/running_code_med.png and b/docs/resources/running_code_med.png differ diff --git a/docs/source/_static/images/notebook-running-code.png b/docs/source/_static/images/notebook-running-code.png new file mode 100644 index 0000000000..d45a3fb7bf Binary files /dev/null and b/docs/source/_static/images/notebook-running-code.png differ diff --git a/docs/source/changelog.md b/docs/source/changelog.md new file mode 100644 index 0000000000..0fd7634f73 --- /dev/null +++ b/docs/source/changelog.md @@ -0,0 +1,1622 @@ +# Changelog + +A summary of changes in the Jupyter notebook. For more detailed +information, see [GitHub](https://github.com/jupyter/notebook). + +Use `pip install notebook --upgrade` or `conda upgrade notebook` to +upgrade to the latest release. + +We strongly recommend that you upgrade pip to version 9+ of pip before +upgrading `notebook`. + +Use `pip install pip --upgrade` to upgrade pip. Check pip version with +`pip --version`. + + + +## 6.4.8 + +([Full Changelog](https://github.com/jupyter/notebook/compare/v6.4.7...479902d83a691253e0cff8439a33577e82408317)) + +### Bugs fixed + +- Fix to remove potential memory leak on Jupyter Notebooks ZMQChannelHandler code [#6251](https://github.com/jupyter/notebook/pull/6251) ([@Vishwajeet0510](https://github.com/Vishwajeet0510)) + +### Contributors to this release + +([GitHub contributors page for this release](https://github.com/jupyter/notebook/graphs/contributors?from=2022-01-12&to=2022-01-25&type=c)) + +[@Vishwajeet0510](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3AVishwajeet0510+updated%3A2022-01-12..2022-01-25&type=Issues) + + + +## 6.4.7 + +([Full Changelog](https://github.com/jupyter/notebook/compare/v6.4.6...b77b5e38b8fa1a20150d7fa4d735dbf1c4f00418)) + +### Bugs fixed + +- Fix Chinese punctuation [#6268](https://github.com/jupyter/notebook/pull/6268) ([@LiHua-Official](https://github.com/LiHua-Official)) +- Add date field to kernel message header [#6265](https://github.com/jupyter/notebook/pull/6265) ([@kevin-bates](https://github.com/kevin-bates)) +- Fix deprecation warning [#6253](https://github.com/jupyter/notebook/pull/6253) ([@tornaria](https://github.com/tornaria)) + +### Maintenance and upkeep improvements + +- Enforce labels on PRs [#6235](https://github.com/jupyter/notebook/pull/6235) ([@blink1073](https://github.com/blink1073)) +- Fix: CI error for python 3.6 & macOS [#6215](https://github.com/jupyter/notebook/pull/6215) ([@penguinolog](https://github.com/penguinolog)) + +### Other merged PRs + +- handle KeyError when get session [#6245](https://github.com/jupyter/notebook/pull/6245) ([@ccw630](https://github.com/ccw630)) +- Updated doc for passwd [#6209](https://github.com/jupyter/notebook/pull/6209) ([@antoinecarme](https://github.com/antoinecarme)) + +### Contributors to this release + +([GitHub contributors page for this release](https://github.com/jupyter/notebook/graphs/contributors?from=2021-11-16&to=2022-01-12&type=c)) + +[@antoinecarme](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Aantoinecarme+updated%3A2021-11-16..2022-01-12&type=Issues) | [@blink1073](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Ablink1073+updated%3A2021-11-16..2022-01-12&type=Issues) | [@ccw630](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Accw630+updated%3A2021-11-16..2022-01-12&type=Issues) | [@kevin-bates](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Akevin-bates+updated%3A2021-11-16..2022-01-12&type=Issues) | [@LiHua-Official](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3ALiHua-Official+updated%3A2021-11-16..2022-01-12&type=Issues) | [@penguinolog](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Apenguinolog+updated%3A2021-11-16..2022-01-12&type=Issues) | [@tornaria](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Atornaria+updated%3A2021-11-16..2022-01-12&type=Issues) + +## 6.4.6 + +([Full Changelog](https://github.com/jupyter/notebook/compare/v6.4.5...160c27d3c23dafe8b42240571db21b0d5cbae2fe)) + +### Bugs fixed + +- Fix `asyncio` error when opening notebooks [#6221](https://github.com/jupyter/notebook/pull/6221) ([@dleen](https://github.com/dleen)) +- Change to use a universal Chinese translation on certain words [#6218](https://github.com/jupyter/notebook/pull/6218) ([@jackexu](https://github.com/jackexu)) +- Fix Chinese translation typo [#6211](https://github.com/jupyter/notebook/pull/6211) ([@maliubiao](https://github.com/maliubiao) +- Fix `send2trash` tests failing on Windows [#6127](https://github.com/jupyter/notebook/pull/6127) ([@dolfinus](https://github.com/dolfinus)) + +### Maintenance and upkeep improvements + +- TST: don't look in user site for serverextensions [#6233](https://github.com/jupyter/notebook/pull/6233) ([@bnavigator](https://github.com/bnavigator)) +- Enable terminal tests as `pywinpty` is ported for python 3.9 [#6228](https://github.com/jupyter/notebook/pull/6228) ([@nsait-linaro](https://github.com/nsait-linaro)) + +### Contributors to this release + +([GitHub contributors page for this release](https://github.com/jupyter/notebook/graphs/contributors?from=2021-10-19&to=2021-11-16&type=c)) + +[@bnavigator](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Abnavigator+updated%3A2021-10-19..2021-11-16&type=Issues) | [@dleen](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Adleen+updated%3A2021-10-19..2021-11-16&type=Issues) | [@dolfinus](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Adolfinus+updated%3A2021-10-19..2021-11-16&type=Issues) | [@jackexu](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Ajackexu+updated%3A2021-10-19..2021-11-16&type=Issues) | [@kevin-bates](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Akevin-bates+updated%3A2021-10-19..2021-11-16&type=Issues) | [@maliubiao](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Amaliubiao+updated%3A2021-10-19..2021-11-16&type=Issues) | [@nsait-linaro](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Ansait-linaro+updated%3A2021-10-19..2021-11-16&type=Issues) | [@takluyver](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Atakluyver+updated%3A2021-10-19..2021-11-16&type=Issues) | [@Zsailer](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3AZsailer+updated%3A2021-10-19..2021-11-16&type=Issues) + +## 6.4.5 + +([Full Changelog](https://github.com/jupyter/notebook/compare/v6.4.4...ccd9665571107e02a325a738b8baebd6532b2d3d)) + +### Bug fixes + +- Recover from failure to render mimetype [#6181](https://github.com/jupyter/notebook/pull/6181) ([@martinRenou](https://github.com/martinRenou)) + +### Maintenance and upkeep improvements + +- Fix crypto handling [#6197](https://github.com/jupyter/notebook/pull/6197) ([@blink1073](https://github.com/blink1073)) +- Fix `jupyter_client` warning [#6178](https://github.com/jupyter/notebook/pull/6178) ([@martinRenou](https://github.com/martinRenou)) + +### Documentation improvements + +- Fix nbsphinx settings [#6200](https://github.com/jupyter/notebook/pull/6200) ([@mgeier](https://github.com/mgeier)) +- Fully revert the pinning of `nbsphinx` to 0.8.6 [#6201](https://github.com/jupyter/notebook/pull/6201) ([@kevin-bates](https://github.com/kevin-bates)) +- Pin `nbsphinx` to 0.8.6, clean up orphaned resources [#6194](https://github.com/jupyter/notebook/pull/6194) ([@kevin-bates](https://github.com/kevin-bates)) +- Fix typo in docstring [#6188](https://github.com/jupyter/notebook/pull/6188) ([@jgarte](https://github.com/jgarte)) + +### Contributors to this release + +([GitHub contributors page for this release](https://github.com/jupyter/notebook/graphs/contributors?from=2021-09-03&to=2021-10-19&type=c)) + +[@blink1073](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Ablink1073+updated%3A2021-09-03..2021-10-19&type=Issues) | [@jgarte](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Ajgarte+updated%3A2021-09-03..2021-10-19&type=Issues) | [@kevin-bates](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Akevin-bates+updated%3A2021-09-03..2021-10-19&type=Issues) | [@martinRenou](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3AmartinRenou+updated%3A2021-09-03..2021-10-19&type=Issues) | [@mgeier](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Amgeier+updated%3A2021-09-03..2021-10-19&type=Issues) + +## 6.4.4 + +([Full Changelog](https://github.com/jupyter/notebook/compare/v6.4.3...c06c340574e1d2207940c5bd1190eb73d82ab945)) + +### Documentation improvements + +- Update Manual Release Instructions [#6152](https://github.com/jupyter/notebook/pull/6152) ([@blink1073](https://github.com/blink1073)) + +### Other merged PRs + +- Use default JupyterLab CSS sanitizer options for Markdown [#6160](https://github.com/jupyter/notebook/pull/6160) ([@krassowski](https://github.com/krassowski)) +- Fix syntax highlight [#6128](https://github.com/jupyter/notebook/pull/6128) ([@massongit](https://github.com/massongit)) + +### Contributors to this release + +([GitHub contributors page for this release](https://github.com/jupyter/notebook/graphs/contributors?from=2021-08-11&to=2021-09-03&type=c)) + +[@blink1073](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Ablink1073+updated%3A2021-08-11..2021-09-03&type=Issues) | [@kevin-bates](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Akevin-bates+updated%3A2021-08-11..2021-09-03&type=Issues) | [@krassowski](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Akrassowski+updated%3A2021-08-11..2021-09-03&type=Issues) | [@massongit](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Amassongit+updated%3A2021-08-11..2021-09-03&type=Issues) | [@minrk](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Aminrk+updated%3A2021-08-11..2021-09-03&type=Issues) | [@Zsailer](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3AZsailer+updated%3A2021-08-11..2021-09-03&type=Issues) + +## 6.4.3 + +([Full Changelog](https://github.com/jupyter/notebook/compare/v6.4.2...c373bd89adaaddffbb71747ebbcfe8a749cae0a8)) + +### Bugs fixed + +- Add @babel/core dependency [#6133](https://github.com/jupyter/notebook/pull/6133) ([@afshin](https://github.com/afshin)) +- Switch webpack to production mode [#6131](https://github.com/jupyter/notebook/pull/6131) ([@afshin](https://github.com/afshin)) + +### Maintenance and upkeep improvements + +- Clean up link checking [#6130](https://github.com/jupyter/notebook/pull/6130) ([@blink1073](https://github.com/blink1073)) + +### Contributors to this release + +([GitHub contributors page for this release](https://github.com/jupyter/notebook/graphs/contributors?from=2021-08-06&to=2021-08-10&type=c)) + +[@afshin](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Aafshin+updated%3A2021-08-06..2021-08-10&type=Issues) | [@blink1073](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Ablink1073+updated%3A2021-08-06..2021-08-10&type=Issues) | [@Zsailer](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3AZsailer+updated%3A2021-08-06..2021-08-10&type=Issues) + +## 6.4.2 + +([Full Changelog](https://github.com/jupyter/notebook/compare/v6.4.0...999e8322bcd24e0ed62b180c19ec13db3f48165b)) + +### Bugs fixed + +- Add missing file to manifest [#6122](https://github.com/jupyter/notebook/pull/6122) ([@afshin](https://github.com/afshin)) +- Fix issue #3218 [#6108](https://github.com/jupyter/notebook/pull/6108) ([@Nazeeh21](https://github.com/Nazeeh21)) +- Fix version of jupyter-packaging in pyproject.toml [#6101](https://github.com/jupyter/notebook/pull/6101) ([@frenzymadness](https://github.com/frenzymadness)) +- "#element".tooltip is not a function on home page fixed. [#6070](https://github.com/jupyter/notebook/pull/6070) ([@ilayh123](https://github.com/ilayh123)) + +### Maintenance and upkeep improvements + +- Enhancements to the desktop entry [#6099](https://github.com/jupyter/notebook/pull/6099) ([@Amr-Ibra](https://github.com/Amr-Ibra)) +- Add missing spaces to help messages in config file [#6085](https://github.com/jupyter/notebook/pull/6085) ([@saiwing-yeung](https://github.com/saiwing-yeung)) + +### Contributors to this release + +([GitHub contributors page for this release](https://github.com/jupyter/notebook/graphs/contributors?from=2021-05-17&to=2021-08-06&type=c)) + +[@afshin](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Aafshin+updated%3A2021-05-17..2021-08-06&type=Issues) | [@Amr-Ibra](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3AAmr-Ibra+updated%3A2021-05-17..2021-08-06&type=Issues) | [@frenzymadness](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Afrenzymadness+updated%3A2021-05-17..2021-08-06&type=Issues) | [@ilayh123](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Ailayh123+updated%3A2021-05-17..2021-08-06&type=Issues) | [@kevin-bates](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Akevin-bates+updated%3A2021-05-17..2021-08-06&type=Issues) | [@Nazeeh21](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3ANazeeh21+updated%3A2021-05-17..2021-08-06&type=Issues) | [@saiwing-yeung](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Asaiwing-yeung+updated%3A2021-05-17..2021-08-06&type=Issues) + +## 6.4.0 + +([Full Changelog](https://github.com/jupyter/notebook/compare/6.3.0...80eb286f316838afc76a9a84b06f54e7dccb6c86)) + +### Bugs fixed + +- Fix Handling of Encoded Paths in Save As Dialog [#6030](https://github.com/jupyter/notebook/pull/6030) ([@afshin](https://github.com/afshin)) +- Fix: split_cell doesn't always split cell [#6017](https://github.com/jupyter/notebook/pull/6017) ([@gamestrRUS](https://github.com/gamestrRUS)) +- Correct 'Content-Type' headers [#6026](https://github.com/jupyter/notebook/pull/6026) ([@faucct](https://github.com/faucct)) +- Fix skipped tests & remove deprecation warnings [#6018](https://github.com/jupyter/notebook/pull/6018) ([@befeleme](https://github.com/befeleme)) +- [Gateway] Track only this server's kernels [#5980](https://github.com/jupyter/notebook/pull/5980) ([@kevin-bates](https://github.com/kevin-bates)) +- Bind the HTTPServer in start [#6061](https://github.com/jupyter/notebook/pull/6061) + +### Maintenance and upkeep improvements + +- Revert "do not apply asyncio patch for tornado >=6.1" [#6052](https://github.com/jupyter/notebook/pull/6052) ([@minrk](https://github.com/minrk)) +- Use Jupyter Releaser [#6048](https://github.com/jupyter/notebook/pull/6048) ([@afshin](https://github.com/afshin)) +- Add Workflow Permissions for Lock Bot [#6042](https://github.com/jupyter/notebook/pull/6042) ([@jtpio](https://github.com/jtpio)) +- Fixes related to the recent changes in the documentation [#6021](https://github.com/jupyter/notebook/pull/6021) ([@frenzymadness](https://github.com/frenzymadness)) +- Add maths checks in CSS reference test [#6035](https://github.com/jupyter/notebook/pull/6035) ([@stef4k](https://github.com/stef4k)) +- Add Issue Lock and Answered Bots [#6019](https://github.com/jupyter/notebook/pull/6019) ([@afshin](https://github.com/afshin)) + +### Documentation improvements + +- Spelling correction [#6045](https://github.com/jupyter/notebook/pull/6045) ([@wggillen](https://github.com/wggillen)) +- Minor typographical and comment changes [#6025](https://github.com/jupyter/notebook/pull/6025) ([@misterhay](https://github.com/misterhay)) +- Fixes related to the recent changes in the documentation [#6021](https://github.com/jupyter/notebook/pull/6021) ([@frenzymadness](https://github.com/frenzymadness)) +- Fix readthedocs environment [#6020](https://github.com/jupyter/notebook/pull/6020) ([@blink1073](https://github.com/blink1073)) + +### Contributors to this release + +([GitHub contributors page for this release](https://github.com/jupyter/notebook/graphs/contributors?from=2021-03-22&to=2021-05-12&type=c)) + +[@afshin](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Aafshin+updated%3A2021-03-22..2021-05-12&type=Issues) | [@befeleme](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Abefeleme+updated%3A2021-03-22..2021-05-12&type=Issues) | [@blink1073](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Ablink1073+updated%3A2021-03-22..2021-05-12&type=Issues) | [@faucct](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Afaucct+updated%3A2021-03-22..2021-05-12&type=Issues) | [@frenzymadness](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Afrenzymadness+updated%3A2021-03-22..2021-05-12&type=Issues) | [@gamestrRUS](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3AgamestrRUS+updated%3A2021-03-22..2021-05-12&type=Issues) | [@jtpio](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Ajtpio+updated%3A2021-03-22..2021-05-12&type=Issues) | [@kevin-bates](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Akevin-bates+updated%3A2021-03-22..2021-05-12&type=Issues) | [@minrk](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Aminrk+updated%3A2021-03-22..2021-05-12&type=Issues) | [@misterhay](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Amisterhay+updated%3A2021-03-22..2021-05-12&type=Issues) | [@stef4k](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Astef4k+updated%3A2021-03-22..2021-05-12&type=Issues) | [@wggillen](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Awggillen+updated%3A2021-03-22..2021-05-12&type=Issues) + +## 6.3.0 + +### Merged PRs + +- Add square logo and desktop entry files [#6010](https://github.com/jupyter/notebook/pull/6010) ([@befeleme](https://github.com/befeleme)) +- Modernize Changelog [#6008](https://github.com/jupyter/notebook/pull/6008) ([@afshin](https://github.com/afshin)) +- Add missing "import inspect" [#5999](https://github.com/jupyter/notebook/pull/5999) ([@mgeier](https://github.com/mgeier)) +- Add Codecov badge to README [#5989](https://github.com/jupyter/notebook/pull/5989) ([@thomasrockhu](https://github.com/thomasrockhu)) +- Remove configuration for nosetests from setup.cfg [#5986](https://github.com/jupyter/notebook/pull/5986) ([@frenzymadness](https://github.com/frenzymadness)) +- Update security.rst [#5978](https://github.com/jupyter/notebook/pull/5978) ([@dlrice](https://github.com/dlrice)) +- Docs-Translations: Updated Hindi and Chinese Readme.md [#5976](https://github.com/jupyter/notebook/pull/5976) ([@rjn01](https://github.com/rjn01)) +- Allow /metrics by default if auth is off [#5974](https://github.com/jupyter/notebook/pull/5974) ([@blairdrummond](https://github.com/blairdrummond)) +- Skip terminal tests on Windows 3.9+ (temporary) [#5968](https://github.com/jupyter/notebook/pull/5968) ([@kevin-bates](https://github.com/kevin-bates)) +- Update GatewayKernelManager to derive from AsyncMappingKernelManager [#5966](https://github.com/jupyter/notebook/pull/5966) ([@kevin-bates](https://github.com/kevin-bates)) +- Drop use of deprecated pyzmq.ioloop [#5965](https://github.com/jupyter/notebook/pull/5965) ([@kevin-bates](https://github.com/kevin-bates)) +- Drop support for Python 3.5 [#5962](https://github.com/jupyter/notebook/pull/5962) ([@kevin-bates](https://github.com/kevin-bates)) +- Allow jupyter_server-based contents managers in notebook [#5957](https://github.com/jupyter/notebook/pull/5957) ([@afshin](https://github.com/afshin)) +- Russian translation fixes [#5954](https://github.com/jupyter/notebook/pull/5954) ([@insolor](https://github.com/insolor)) +- Increase culling test idle timeout [#5952](https://github.com/jupyter/notebook/pull/5952) ([@kevin-bates](https://github.com/kevin-bates)) +- Re-enable support for answer_yes flag [#5941](https://github.com/jupyter/notebook/pull/5941) ([@afshin](https://github.com/afshin)) +- Replace Travis and Appveyor with Github Actions [#5938](https://github.com/jupyter/notebook/pull/5938) ([@kevin-bates](https://github.com/kevin-bates)) +- DOC: Server extension, extra docs on configuration/authentication. [#5937](https://github.com/jupyter/notebook/pull/5937) ([@Carreau](https://github.com/Carreau)) + +### Contributors to this release + +([GitHub contributors page for this release](https://github.com/jupyter/notebook/graphs/contributors?from=2021-01-13&to=2021-03-18&type=c)) + +[@abielhammonds](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Aabielhammonds+updated%3A2021-01-13..2021-03-18&type=Issues) | [@afshin](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Aafshin+updated%3A2021-01-13..2021-03-18&type=Issues) | [@ajharry](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Aajharry+updated%3A2021-01-13..2021-03-18&type=Issues) | [@Alokrar](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3AAlokrar+updated%3A2021-01-13..2021-03-18&type=Issues) | [@befeleme](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Abefeleme+updated%3A2021-01-13..2021-03-18&type=Issues) | [@blairdrummond](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Ablairdrummond+updated%3A2021-01-13..2021-03-18&type=Issues) | [@blink1073](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Ablink1073+updated%3A2021-01-13..2021-03-18&type=Issues) | [@bollwyvl](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Abollwyvl+updated%3A2021-01-13..2021-03-18&type=Issues) | [@Carreau](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3ACarreau+updated%3A2021-01-13..2021-03-18&type=Issues) | [@ChenChenDS](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3AChenChenDS+updated%3A2021-01-13..2021-03-18&type=Issues) | [@cosmoscalibur](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Acosmoscalibur+updated%3A2021-01-13..2021-03-18&type=Issues) | [@dlrice](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Adlrice+updated%3A2021-01-13..2021-03-18&type=Issues) | [@dwanneruchi](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Adwanneruchi+updated%3A2021-01-13..2021-03-18&type=Issues) | [@ElisonSherton](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3AElisonSherton+updated%3A2021-01-13..2021-03-18&type=Issues) | [@FazeelUsmani](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3AFazeelUsmani+updated%3A2021-01-13..2021-03-18&type=Issues) | [@frenzymadness](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Afrenzymadness+updated%3A2021-01-13..2021-03-18&type=Issues) | [@goerz](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Agoerz+updated%3A2021-01-13..2021-03-18&type=Issues) | [@insolor](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Ainsolor+updated%3A2021-01-13..2021-03-18&type=Issues) | [@jasongrout](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Ajasongrout+updated%3A2021-01-13..2021-03-18&type=Issues) | [@JianghuiDu](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3AJianghuiDu+updated%3A2021-01-13..2021-03-18&type=Issues) | [@JuzerShakir](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3AJuzerShakir+updated%3A2021-01-13..2021-03-18&type=Issues) | [@kevin-bates](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Akevin-bates+updated%3A2021-01-13..2021-03-18&type=Issues) | [@Khalilsqu](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3AKhalilsqu+updated%3A2021-01-13..2021-03-18&type=Issues) | [@meeseeksdev](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Ameeseeksdev+updated%3A2021-01-13..2021-03-18&type=Issues) | [@mgeier](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Amgeier+updated%3A2021-01-13..2021-03-18&type=Issues) | [@michaelpedota](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Amichaelpedota+updated%3A2021-01-13..2021-03-18&type=Issues) | [@mjbright](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Amjbright+updated%3A2021-01-13..2021-03-18&type=Issues) | [@MSeal](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3AMSeal+updated%3A2021-01-13..2021-03-18&type=Issues) | [@ncoughlin](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Ancoughlin+updated%3A2021-01-13..2021-03-18&type=Issues) | [@NTimmons](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3ANTimmons+updated%3A2021-01-13..2021-03-18&type=Issues) | [@ProsperousHeart](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3AProsperousHeart+updated%3A2021-01-13..2021-03-18&type=Issues) | [@rjn01](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Arjn01+updated%3A2021-01-13..2021-03-18&type=Issues) | [@slw07g](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Aslw07g+updated%3A2021-01-13..2021-03-18&type=Issues) | [@stenivan](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Astenivan+updated%3A2021-01-13..2021-03-18&type=Issues) | [@takluyver](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Atakluyver+updated%3A2021-01-13..2021-03-18&type=Issues) | [@thomasrockhu](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Athomasrockhu+updated%3A2021-01-13..2021-03-18&type=Issues) | [@wgilpin](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Awgilpin+updated%3A2021-01-13..2021-03-18&type=Issues) | [@wxtt522](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Awxtt522+updated%3A2021-01-13..2021-03-18&type=Issues) | [@yuvipanda](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3Ayuvipanda+updated%3A2021-01-13..2021-03-18&type=Issues) | [@Zsailer](https://github.com/search?q=repo%3Ajupyter%2Fnotebook+involves%3AZsailer+updated%3A2021-01-13..2021-03-18&type=Issues) + +## 6.2.0 + +## Merged PRs + +- Increase minimum tornado version ([5933](https://github.com/jupyter/notebook/pull/5933)) +- Adjust skip decorators to avoid remaining dependency on nose ([5932](https://github.com/jupyter/notebook/pull/5932)) +- Ensure that cell ids persist after save ([5928](https://github.com/jupyter/notebook/pull/5928)) +- Add reconnection to Gateway (form nb2kg) ([5924](https://github.com/jupyter/notebook/pull/5924)) +- Fix some typos ([5917](https://github.com/jupyter/notebook/pull/5917)) +- Handle TrashPermissionError, now that it exist ([5894](https://github.com/jupyter/notebook/pull/5894)) + +Thank you to all the contributors: + +- @kevin-bates +- @mishaschwartz +- @oyvsyo +- @user202729 +- @stefanor + +## 6.1.6 + +## Merged PRs + +- do not require nose for testing ([5826](https://github.com/jupyter/notebook/pull/5826)) +- [docs] Update Chinese and Hindi readme.md ([5823](https://github.com/jupyter/notebook/pull/5823)) +- Add support for creating terminals via GET ([5813](https://github.com/jupyter/notebook/pull/5813)) +- Made doc translations in Hindi and Chinese ([5787](https://github.com/jupyter/notebook/pull/5787)) + +Thank you to all the contributors: + +- @pgajdos +- @rjn01 +- @kevin-bates +- @virejdasani + +## 6.1.5 + +6.1.5 is a security release, fixing one vulnerability: + +- Fix open redirect vulnerability GHSA-c7vm-f5p4-8fqh (CVE to be assigned) + +## 6.1.4 + +- Fix broken links to jupyter documentation ([5686](https://github.com/jupyter/notebook/pull/5686)) +- Add additional entries to troubleshooting section ([5695](https://github.com/jupyter/notebook/pull/5695)) +- Revert change in page alignment ([5703](https://github.com/jupyter/notebook/pull/5703)) +- Bug fix: remove double encoding in download files ([5720](https://github.com/jupyter/notebook/pull/5720)) +- Fix typo for Check in zh_CN ([5730](https://github.com/jupyter/notebook/pull/5730)) +- Require a file name in the "Save As" dialog ([5733](https://github.com/jupyter/notebook/pull/5733)) + +Thank you to all the contributors: + +- bdbai +- Jaipreet Singh +- Kevin Bates +- Pavel Panchekha +- Zach Sailer + +## 6.1.3 + +- Title new buttons with label if action undefined ([5676](https://github.com/jupyter/notebook/pull/5676)) + +Thank you to all the contributors: + +- Kyle Kelley + +## 6.1.2 + +- Fix russian message format for delete/duplicate actions ([5662](https://github.com/jupyter/notebook/pull/5662)) +- Remove unnecessary import of bind_unix_socket ([5666](https://github.com/jupyter/notebook/pull/5666)) +- Tooltip style scope fix ([5672](https://github.com/jupyter/notebook/pull/5672)) + +Thank you to all the contributors: + +- Dmitry Akatov +- Kevin Bates +- Magda Stenius + +## 6.1.1 + +- Prevent inclusion of requests_unixsocket on Windows ([5650](https://github.com/jupyter/notebook/pull/5650)) + +Thank you to all the contributors: + +- Kevin Bates + +## 6.1.0 + +Please note that this repository is currently maintained by a skeleton +crew of maintainers from the Jupyter community. For our approach moving +forward, please see this +[notice](https://github.com/jupyter/notebook#notice) from the README. +Thank you. + +Here is an enumeration of changes made since the last release and +included in 6.1.0. + +- Remove deprecated encoding parameter for Python 3.9 compatibility. ([5174](https://github.com/jupyter/notebook/pull/5174)) +- Add support for async kernel management ([4479](https://github.com/jupyter/notebook/pull/4479)) +- Fix typo in password_required help message ([5320](https://github.com/jupyter/notebook/pull/5320)) +- Gateway only: Ensure launch and request timeouts are in sync ([5317](https://github.com/jupyter/notebook/pull/5317)) +- Update Markdown Cells example to HTML5 video tag ([5411](https://github.com/jupyter/notebook/pull/5411)) +- Integrated LoginWidget into edit to enable users to logout from the t... ([5406](https://github.com/jupyter/notebook/pull/5406)) +- Update message about minimum Tornado version ([5222](https://github.com/jupyter/notebook/pull/5222)) +- Logged notebook type ([5425](https://github.com/jupyter/notebook/pull/5425)) +- Added nl language ([5354](https://github.com/jupyter/notebook/pull/5354)) +- Add UNIX socket support to notebook server. ([4835](https://github.com/jupyter/notebook/pull/4835)) +- Update CodeMirror dependency ([5198](https://github.com/jupyter/notebook/pull/5198)) +- Tree added download multiple files ([5351](https://github.com/jupyter/notebook/pull/5351)) +- Toolbar buttons tooltip: show help instead of label ([5107](https://github.com/jupyter/notebook/pull/5107)) +- Remove unnecessary import of requests_unixsocket ([5451](https://github.com/jupyter/notebook/pull/5451)) +- Add ability to cull terminals and track last activity ([5372](https://github.com/jupyter/notebook/pull/5372)) +- Code refactoring notebook.js ([5352](https://github.com/jupyter/notebook/pull/5352)) +- Install terminado for docs build ([5462](https://github.com/jupyter/notebook/pull/5462)) +- Convert notifications JS test to selenium ([5455](https://github.com/jupyter/notebook/pull/5455)) +- Add cell attachments to markdown example ([5412](https://github.com/jupyter/notebook/pull/5412)) +- Add Japanese document ([5231](https://github.com/jupyter/notebook/pull/5231)) +- Migrate Move multiselection test to selenium ([5158](https://github.com/jupyter/notebook/pull/5158)) +- Use `cmdtrl-enter` to run a cell ([5120](https://github.com/jupyter/notebook/pull/5120)) +- Fix broken "Raw cell MIME type" dialog ([5385](https://github.com/jupyter/notebook/pull/5385)) +- Make a notebook writable after successful save-as ([5296](https://github.com/jupyter/notebook/pull/5296)) +- Add actual watch script ([4738](https://github.com/jupyter/notebook/pull/4738)) +- Added `--autoreload` flag to `NotebookApp` ([4795](https://github.com/jupyter/notebook/pull/4795)) +- Enable check_origin on gateway websocket communication ([5471](https://github.com/jupyter/notebook/pull/5471)) +- Restore detection of missing terminado package ([5465](https://github.com/jupyter/notebook/pull/5465)) +- Culling: ensure `last_activity` attr exists before use ([5355](https://github.com/jupyter/notebook/pull/5355)) +- Added functionality to allow filter kernels by Jupyter Enterprise Gat... ([5484](https://github.com/jupyter/notebook/pull/5484)) +- 'Play' icon for run-cell toolbar button ([2922](https://github.com/jupyter/notebook/pull/2922)) +- Bump minimum version of jQuery to 3.5.0 ([5491](https://github.com/jupyter/notebook/pull/5491)) +- Remove old JS markdown tests, add a new one in selenium ([5497](https://github.com/jupyter/notebook/pull/5497)) +- Add support for more RTL languages ([5036](https://github.com/jupyter/notebook/pull/5036)) +- Make markdown cells stay RTL in edit mode ([5037](https://github.com/jupyter/notebook/pull/5037)) +- Unforce RTL output display ([5039](https://github.com/jupyter/notebook/pull/5039)) +- Fixed multicursor backspacing ([4880](https://github.com/jupyter/notebook/pull/4880)) +- Implemented Split Cell for multicursor ([4824](https://github.com/jupyter/notebook/pull/4824)) +- Alignment issue \[FIXED\] ([3173](https://github.com/jupyter/notebook/pull/3173)) +- MathJax: Support for `\gdef` ([4407](https://github.com/jupyter/notebook/pull/4407)) +- Another (Minor) Duplicate Code Reduction ([5316](https://github.com/jupyter/notebook/pull/5316)) +- Update readme regarding maintenance ([5500](https://github.com/jupyter/notebook/pull/5500)) +- Document contents chunks ([5508](https://github.com/jupyter/notebook/pull/5508)) +- Backspace deletes empty line ([5516](https://github.com/jupyter/notebook/pull/5516)) +- The dropdown submenu at notebook page is not keyboard accessible ([4732](https://github.com/jupyter/notebook/pull/4732)) +- Tooltips visible through keyboard navigation for specified buttons ([4729](https://github.com/jupyter/notebook/pull/4729)) +- Fix for recursive symlink ([4670](https://github.com/jupyter/notebook/pull/4670)) +- Fix for the terminal shutdown issue ([4180](https://github.com/jupyter/notebook/pull/4180)) +- Add japanese translation files ([4490](https://github.com/jupyter/notebook/pull/4490)) +- Workaround for socket permission errors on Cygwin ([4584](https://github.com/jupyter/notebook/pull/4584)) +- Implement optional markdown header and footer files ([4043](https://github.com/jupyter/notebook/pull/4043)) +- Remove double link when using `custom_display_url` ([5544](https://github.com/jupyter/notebook/pull/5544)) +- Respect `cell.is_editable` during find-and-replace ([5545](https://github.com/jupyter/notebook/pull/5545)) +- Fix exception causes all over the codebase ([5556](https://github.com/jupyter/notebook/pull/5556) +- Improve login shell heuristics ([5588](https://github.com/jupyter/notebook/pull/5588)) +- Added support for `JUPYTER_TOKEN_FILE` ([5587](https://github.com/jupyter/notebook/pull/5587)) +- Kill notebook itself when server cull idle kernel ([5593](https://github.com/jupyter/notebook/pull/5593)) +- Implement password hashing with bcrypt ([3793](https://github.com/jupyter/notebook/pull/3793)) +- Fix broken links ([5600](https://github.com/jupyter/notebook/pull/5600)) +- Russian internationalization support ([5571](https://github.com/jupyter/notebook/pull/5571)) +- Add a metadata tag to override notebook direction (ltr/rtl) ([5052](https://github.com/jupyter/notebook/pull/5052)) +- Paste two images from clipboard in markdown cell ([5598](https://github.com/jupyter/notebook/pull/5598)) +- Add keyboard shortcuts to menu dropdowns ([5525](https://github.com/jupyter/notebook/pull/5525)) +- Update codemirror to `5.56.0+components1` ([5637](https://github.com/jupyter/notebook/pull/5637)) + +Thank you to all the contributors: + +- Aaron Myatt +- Adam Blake +- Afshin Taylor Darian +- Aman Bansal +- Ben Thayer +- berendjan +- Bruno P. Kinoshita +- bzinberg +- Christophe Cadilhac +- Daiki Katsuragawa +- David Lukes +- Dmitriy Q +- dmpe +- dylanzjy +- dSchurch +- E. M. Bray +- ErwinRussel +- Felix Mönckemeyer +- Grant Nestor +- Jarrad Whitaker +- Jesus Panales Castillo +- Joshua Zeltser +- Karthikeyan Singaravelan +- Kenichi Ito +- Kevin Bates +- Koki Nishihara +- Kris Wilson +- Kyle Kelley +- Laura Merlo +- levinxo +- Luciano Resende +- Luis Cabezon Manchado +- Madhusudhan Srinivasa +- Matthias Geier +- mattn +- Max Klein +- Min RK +- Mingxuan Lin +- Mohammad Mostafa Farzan +- Niko Felger +- Norah Abanumay +- Onno Broekmans +- PierreMB +- pinarkavak +- Ram Rachum +- Reece Hart +- Remi Rampin +- Rohit Sanjay +- Shane Canon +- Simon Li +- Steinar Sturlaugsson +- Steven Silvester +- taohan16 +- Thew Dhanat +- Thomas Kluyver +- Toon Baeyens +- Vidar Tonaas Fauske +- Zachary Sailer + +## 6.0.3 + +- Dependency updates to fix startup issues on Windows platform +- Add support for nbconvert 6.x +- Creation of recent tab + +Thanks for all the contributors: + +- Luciano Resende +- Kevin Bates +- ahangsleben +- Zachary Sailer +- Pallavi Bharadwaj +- Thomas Kluyver +- Min RK +- forest0 +- Bibo Hao +- Michal Charemza +- Sergey Shevelev +- Shuichiro MAKIGAKI +- krinsman +- TPartida +- Landen McDonald +- Tres DuBiel + +## 6.0.2 + +- Update JQuery dependency to version 3.4.1 to fix security vulnerability (CVE-2019-11358) +- Update CodeMirror to version 5.48.4 to fix Python formatting issues +- Continue removing obsolete Python 2.x code/dependencies +- Multiple documentation updates + +Thanks for all the contributors: + +- David Robles +- Jason Grout +- Kerwin Sun +- Kevin Bates +- Kyle Kelley +- Luciano Resende +- Marcus D Sherman +- Sasaki Takeru +- Tom Jarosz +- Vidar Tonaas Fauske +- Wes Turner +- Zachary Sailer + +## 6.0.1 + +- Attempt to re-establish websocket connection to Gateway ([4777](https://github.com/jupyter/notebook/pull/4777)) +- Add missing react-dom js to package data ([4772](https://github.com/jupyter/notebook/pull/4772)) + +Thanks for all the contributors: + +- Eunsoo Park +- Min RK + +## 6.0 + +This is the first major release of the Jupyter Notebook since version +5.0 (March 2017). + +We encourage users to start trying JupyterLab, which has just announced +it's 1.0 release in preparation for a future transition. + +- Remove Python 2.x support in favor of Python 3.5 and higher. +- Multiple accessibility enhancements and bug-fixes. +- Multiple translation enhancements and bug-fixes. +- Remove deprecated ANSI CSS styles. +- Native support to forward requests to Jupyter Gateway(s) (Embedded + NB2KG). +- Use JavaScript to redirect users to notebook homepage. +- Enhanced SSL/TLS security by using PROTOCOL_TLS which selects the + highest ssl/tls protocol version available that both the client and + server support. When PROTOCOL_TLS is not available use + PROTOCOL_SSLv23. +- Add `?no_track_activity=1` argument to allow API requests. to not be + registered as activity (e.g. API calls by external activity + monitors). +- Kernels shutting down due to an idle timeout is no longer considered + an activity-updating event. +- Further improve compatibility with tornado 6 with improved checks + for when websockets are closed. +- Launch the browser with a local file which redirects to the server + address including the authentication token. This prevents another + logged-in user from stealing the token from command line arguments + and authenticating to the server. The single-use token previously + used to mitigate this has been removed. Thanks to Dr. Owain Kenway + for suggesting the local file approach. +- Respect nbconvert entrypoints as sources for exporters +- Update to CodeMirror to 5.37, which includes f-string syntax for + Python 3.6. +- Update jquery-ui to 1.12 +- Execute cells by clicking icon in input prompt. +- New "Save as" menu option. +- When serving on a loopback interface, protect against DNS rebinding + by checking the `Host` header from the browser. This check can be + disabled if necessary by setting `NotebookApp.allow_remote_access`. (Disabled by default while we work out some Mac issues in + [3754](https://github.com/jupyter/notebook/issues/3754)). +- Add kernel_info_timeout traitlet to enable restarting slow kernels. +- Add `custom_display_host` config option to override displayed URL. +- Add /metrics endpoint for Prometheus Metrics. +- Optimize large file uploads. +- Allow access control headers to be overriden in + jupyter_notebook_config.py to support greater CORS and proxy + configuration flexibility. +- Add support for terminals on windows. +- Add a "restart and run all" button to the toolbar. +- Frontend/extension-config: allow default json files in a .d + directory. +- Allow setting token via jupyter_token env. +- Cull idle kernels using `--MappingKernelManager.cull_idle_timeout`. +- Allow read-only notebooks to be trusted. +- Convert JS tests to Selenium. + +Security Fixes included in previous minor releases of Jupyter Notebook +and also included in version 6.0. + +- Fix Open Redirect vulnerability (CVE-2019-10255) where certain + malicious URLs could redirect from the Jupyter login page to a + malicious site after a successful login. +- Contains a security fix for a cross-site inclusion (XSSI) + vulnerability (CVE-2019--9644), where files at a known URL could be + included in a page from an unauthorized website if the user is + logged into a Jupyter server. The fix involves setting the + `X-Content-Type-Options: nosniff` header, and applying CSRF checks + previously on all non-GET API requests to GET requests to API + endpoints and the /files/ endpoint. +- Check Host header to more securely protect localhost deployments + from DNS rebinding. This is a pre-emptive measure, not fixing a + known vulnerability. Use `.NotebookApp.allow_remote_access` and + `.NotebookApp.local_hostnames` to configure access. +- Upgrade bootstrap to 3.4, fixing an XSS vulnerability, which has + been assigned + [CVE-2018-14041](https://nvd.nist.gov/vuln/detail/CVE-2018-14041). +- Contains a security fix preventing malicious directory names from + being able to execute javascript. +- Contains a security fix preventing nbconvert endpoints from + executing javascript with access to the server API. CVE request + pending. + +Thanks for all the contributors: + +- AAYUSH SINHA +- Aaron Hall, MBA +- Abhinav Sagar +- Adam Rule +- Adeel Ahmad +- Alex Rothberg +- Amy Skerry-Ryan +- Anastasis Germanidis +- Andrés Sánchez +- Arjun Radhakrishna +- Arovit Narula +- Benda Xu +- Björn Grüning +- Brian E. Granger +- Carol Willing +- Celina Kilcrease +- Chris Holdgraf +- Chris Miller +- Ciaran Langton +- Damian Avila +- Dana Lee +- Daniel Farrell +- Daniel Nicolai +- Darío Hereñú +- Dave Aitken +- Dave Foster +- Dave Hirschfeld +- Denis Ledoux +- Dmitry Mikushin +- Dominic Kuang +- Douglas Hanley +- Elliott Sales de Andrade +- Emilio Talamante Lugo +- Eric Perry +- Ethan T. Hendrix +- Evan Van Dam +- Francesco Franchina +- Frédéric Chapoton +- Félix-Antoine Fortin +- Gabriel +- Gabriel Nützi +- Gabriel Ruiz +- Gestalt LUR +- Grant Nestor +- Gustavo Efeiche +- Harsh Vardhan +- Heng GAO +- Hisham Elsheshtawy +- Hong Xu +- Ian Rose +- Ivan Ogasawara +- J Forde +- Jason Grout +- Jessica B. Hamrick +- Jiaqi Liu +- John Emmons +- Josh Barnes +- Karthik Balakrishnan +- Kevin Bates +- Kirit Thadaka +- Kristian Gregorius Hustad +- Kyle Kelley +- Leo Gallucci +- Lilian Besson +- Lucas Seiki Oshiro +- Luciano Resende +- Luis Angel Rodriguez Guerrero +- M Pacer +- Maarten Breddels +- Mac Knight +- Madicken Munk +- Maitiú Ó Ciaráin +- Marc Udoff +- Mathis HAMMEL +- Mathis Rosenhauer +- Matthias Bussonnier +- Matthias Geier +- Max Vovshin +- Maxime Mouchet +- Michael Chirico +- Michael Droettboom +- Michael Heilman +- Michael Scott Cuthbert +- Michal Charemza +- Mike Boyle +- Milos Miljkovic +- Min RK +- Miro Hrončok +- Nicholas Bollweg +- Nitesh Sawant +- Ondrej Jariabka +- Park Hae Jin +- Paul Ivanov +- Paul Masson +- Peter Parente +- Pierre Tholoniat +- Remco Verhoef +- Roland Weber +- Roman Kornev +- Rosa Swaby +- Roy Hyunjin Han +- Sally +- Sam Lau +- Samar Sultan +- Shiti Saxena +- Simon Biggs +- Spencer Park +- Stephen Ward +- Steve (Gadget) Barnes +- Steven Silvester +- Surya Prakash Susarla +- Syed Shah +- Sylvain Corlay +- Thomas Aarholt +- Thomas Kluyver +- Tim +- Tim Head +- Tim Klever +- Tim Metzler +- Todd +- Tom Jorquera +- Tyler Makaro +- Vaibhav Sagar +- Victor +- Vidar Tonaas Fauske +- Vu Minh Tam +- Vít Tuček +- Will Costello +- Will Starms +- William Hosford +- Xiaohan Li +- Yuvi Panda +- ashley teoh +- nullptr + +## 5.7.8 + +- Fix regression in restarting kernels in 5.7.5. The restart handler + would return before restart was completed. +- Further improve compatibility with tornado 6 with improved checks + for when websockets are closed. +- Fix regression in 5.7.6 on Windows where .js files could have the + wrong mime-type. +- Fix Open Redirect vulnerability (CVE-2019-10255) where certain + malicious URLs could redirect from the Jupyter login page to a + malicious site after a successful login. 5.7.7 contained only a + partial fix for this issue. + +## 5.7.6 + +5.7.6 contains a security fix for a cross-site inclusion (XSSI) +vulnerability (CVE-2019--9644), where files at a known URL could be +included in a page from an unauthorized website if the user is logged +into a Jupyter server. The fix involves setting the +`X-Content-Type-Options: nosniff` header, and applying CSRF checks +previously on all non-GET API requests to GET requests to API endpoints +and the /files/ endpoint. + +The attacking page is able to access some contents of files when using +Internet Explorer through script errors, but this has not been +demonstrated with other browsers. + +## 5.7.5 + +- Fix compatibility with tornado 6 ([4392](https://github.com/jupyter/notebook/pull/4392), [4449](https://github.com/jupyter/notebook/pull/4449)). +- Fix opening integer filedescriptor during startup on Python 2 ([4349](https://github.com/jupyter/notebook/pull/4349)) +- Fix compatibility with asynchronous + [KernelManager.restart_kernel]{.title-ref} methods ([4412](https://github.com/jupyter/notebook/pull/4412)) + +## 5.7.4 + +5.7.4 fixes a bug introduced in 5.7.3, in which the +`list_running_servers()` function attempts to parse HTML files as JSON, +and consequently crashes ([4284](https://github.com/jupyter/notebook/pull/4284)). + +## 5.7.3 + +5.7.3 contains one security improvement and one security fix: + +- Launch the browser with a local file which redirects to the server + address including the authentication token ([4260](https://github.com/jupyter/notebook/pull/4260)). This prevents another logged-in user from stealing + the token from command line arguments and authenticating to the + server. The single-use token previously used to mitigate this has + been removed. Thanks to Dr. Owain Kenway for suggesting the local + file approach. +- Upgrade bootstrap to 3.4, fixing an XSS vulnerability, which has + been assigned + [CVE-2018-14041](https://nvd.nist.gov/vuln/detail/CVE-2018-14041) ([4271](https://github.com/jupyter/notebook/pull/4271)). + +## 5.7.2 + +5.7.2 contains a security fix preventing malicious directory names from +being able to execute javascript. CVE request pending. + +## 5.7.1 + +5.7.1 contains a security fix preventing nbconvert endpoints from +executing javascript with access to the server API. CVE request pending. + +## 5.7.0 + +New features: + +- Update to CodeMirror to 5.37, which includes f-string syntax for + Python 3.6 ([3816](https://github.com/jupyter/notebook/pull/3816)) +- Update jquery-ui to 1.12 ([3836](https://github.com/jupyter/notebook/pull/3836)) +- Check Host header to more securely protect localhost deployments + from DNS rebinding. This is a pre-emptive measure, not fixing a + known vulnerability ([3766](https://github.com/jupyter/notebook/pull/3766)). Use + `.NotebookApp.allow_remote_access` and + `.NotebookApp.local_hostnames` to configure access. +- Allow access-control-allow-headers to be overridden ([3886](https://github.com/jupyter/notebook/pull/3886)) +- Allow configuring max_body_size and max_buffer_size ([3829](https://github.com/jupyter/notebook/pull/3829)) +- Allow configuring get_secure_cookie keyword-args ([3778](https://github.com/jupyter/notebook/pull/3778)) +- Respect nbconvert entrypoints as sources for exporters ([3879](https://github.com/jupyter/notebook/pull/3879)) +- Include translation sources in source distributions ([3925](https://github.com/jupyter/notebook/pull/3925), [3931](https://github.com/jupyter/notebook/pull/3931)) +- Various improvements to documentation ([3799](https://github.com/jupyter/notebook/pull/3799), [3800](https://github.com/jupyter/notebook/pull/3800), + [3806](https://github.com/jupyter/notebook/pull/3806), [3883](https://github.com/jupyter/notebook/pull/3883), [3908](https://github.com/jupyter/notebook/pull/3908)) + +Fixing problems: + +- Fix breadcrumb link when running with a base url ([3905](https://github.com/jupyter/notebook/pull/3905)) +- Fix possible type error when closing activity stream ([3907](https://github.com/jupyter/notebook/pull/3907)) +- Disable metadata editing for non-editable cells ([3744](https://github.com/jupyter/notebook/pull/3744)) +- Fix some styling and alignment of prompts caused by regressions in + 5.6.0. +- Enter causing page reload in shortcuts editor ([3871](https://github.com/jupyter/notebook/pull/3871)) +- Fix uploading to the same file twice ([3712](https://github.com/jupyter/notebook/pull/3712)) + +See the 5.7 milestone on GitHub for a complete list of [pull +requests](https://github.com/jupyter/notebook/pulls?utf8=%E2%9C%93&q=is%3Apr%20milestone%3A5.7) +involved in this release. + +Thanks to the following contributors: + +- Aaron Hall +- Benjamin Ragan-Kelley +- Bill Major +- bxy007 +- Dave Aitken +- Denis Ledoux +- Félix-Antoine Fortin +- Gabriel +- Grant Nestor +- Kevin Bates +- Kristian Gregorius Hustad +- M Pacer +- Madicken Munk +- Maitiu O Ciarain +- Matthias Bussonnier +- Michael Boyle +- Michael Chirico +- Mokkapati, Praneet(ES) +- Peter Parente +- Sally Wilsak +- Steven Silvester +- Thomas Kluyver +- Walter Martin + +## 5.6.0 + +New features: + +- Execute cells by clicking icon in input prompt ([3535](https://github.com/jupyter/notebook/pull/3535), [3687](https://github.com/jupyter/notebook/pull/3687)) +- New "Save as" menu option ([3289](https://github.com/jupyter/notebook/pull/3289)) +- When serving on a loopback interface, protect against DNS rebinding + by checking the `Host` header from the browser ([3714](https://github.com/jupyter/notebook/pull/3714)). This check can be + disabled if necessary by setting `NotebookApp.allow_remote_access`. (Disabled by default while we work out some Mac issues in + [3754](https://github.com/jupyter/notebook/issues/3754)). +- Add kernel_info_timeout traitlet to enable restarting slow kernels ([3665](https://github.com/jupyter/notebook/pull/3665)) +- Add `custom_display_host` config option to override displayed URL ([3668](https://github.com/jupyter/notebook/pull/3668)) +- Add /metrics endpoint for Prometheus Metrics ([3490](https://github.com/jupyter/notebook/pull/3490)) +- Update to MathJax 2.7.4 ([3751](https://github.com/jupyter/notebook/pull/3751)) +- Update to jQuery 3.3 ([3655](https://github.com/jupyter/notebook/pull/3655)) +- Update marked to 0.4 ([3686](https://github.com/jupyter/notebook/pull/3686)) + +Fixing problems: + +- Don't duplicate token in displayed URL ([3656](https://github.com/jupyter/notebook/pull/3656)) +- Clarify displayed URL when listening on all interfaces ([3703](https://github.com/jupyter/notebook/pull/3703)) +- Don't trash non-empty directories on Windows ([3673](https://github.com/jupyter/notebook/pull/3673)) +- Include LICENSE file in wheels ([3671](https://github.com/jupyter/notebook/pull/3671)) +- Don't show "0 active kernels" when starting the notebook ([3696](https://github.com/jupyter/notebook/pull/3696)) + +Testing: + +- Add find replace test ([3630](https://github.com/jupyter/notebook/pull/3630)) +- Selenium test for deleting all cells ([3601](https://github.com/jupyter/notebook/pull/3601)) +- Make creating a new notebook more robust ([3726](https://github.com/jupyter/notebook/pull/3726)) + +Thanks to the following contributors: + +- Arovit Narula ([arovit](https://github.com/arovit)) +- lucasoshiro ([lucasoshiro](https://github.com/lucasoshiro)) +- M Pacer ([mpacer](https://github.com/mpacer)) +- Thomas Kluyver ([takluyver](https://github.com/takluyver)) +- Todd ([toddrme2178](https://github.com/toddrme2178)) +- Yuvi Panda ([yuvipanda](https://github.com/yuvipanda)) + +See the 5.6 milestone on GitHub for a complete list of [pull +requests](https://github.com/jupyter/notebook/pulls?utf8=%E2%9C%93&q=is%3Apr%20milestone%3A5.6) +involved in this release. + +## 5.5.0 + +New features: + +- The files list now shows file sizes ([3539](https://github.com/jupyter/notebook/pull/3539)) +- Add a quit button in the dashboard ([3004](https://github.com/jupyter/notebook/pull/3004)) +- Display hostname in the terminal when running remotely ([3356](https://github.com/jupyter/notebook/pull/3356), [3593](https://github.com/jupyter/notebook/pull/3593)) +- Add slides exportation/download to the menu ([3287](https://github.com/jupyter/notebook/pull/3287)) +- Add any extra installed nbconvert exporters to the "Download as" + menu ([3323](https://github.com/jupyter/notebook/pull/3323)) +- Editor: warning when overwriting a file that is modified on disk ([2783](https://github.com/jupyter/notebook/pull/2783)) +- Display a warning message if cookies are not enabled ([3511](https://github.com/jupyter/notebook/pull/3511)) +- Basic `__version__` reporting for extensions ([3541](https://github.com/jupyter/notebook/pull/3541)) +- Add `NotebookApp.terminals_enabled` config option ([3478](https://github.com/jupyter/notebook/pull/3478)) +- Make buffer time between last modified on disk and last modified on + last save configurable ([3273](https://github.com/jupyter/notebook/pull/3273)) +- Allow binding custom shortcuts for 'close and halt' ([3314](https://github.com/jupyter/notebook/pull/3314)) +- Add description for 'Trusted' notification ([3386](https://github.com/jupyter/notebook/pull/3386)) +- Add `settings['activity_sources']` ([3401](https://github.com/jupyter/notebook/pull/3401)) +- Add an `output_updated.OutputArea` event ([3560](https://github.com/jupyter/notebook/pull/3560)) + +Fixing problems: + +- Fixes to improve web accessibility ([3507](https://github.com/jupyter/notebook/pull/3507)) +- Fixed color contrast issue in tree.less ([3336](https://github.com/jupyter/notebook/pull/3336)) +- Allow cancelling upload of large files ([3373](https://github.com/jupyter/notebook/pull/3373)) +- Don't clear login cookie on requests without cookie ([3380](https://github.com/jupyter/notebook/pull/3380)) +- Don't trash files on different device to home dir on Linux ([3304](https://github.com/jupyter/notebook/pull/3304)) +- Clear waiting asterisks when restarting kernel ([3494](https://github.com/jupyter/notebook/pull/3494)) +- Fix output prompt when `execution_count` missing ([3236](https://github.com/jupyter/notebook/pull/3236)) +- Make the 'changed on disk' dialog work when displayed twice ([3589](https://github.com/jupyter/notebook/pull/3589)) +- Fix going back to root directory with history in notebook list ([3411](https://github.com/jupyter/notebook/pull/3411)) +- Allow defining keyboard shortcuts for missing actions ([3561](https://github.com/jupyter/notebook/pull/3561)) +- Prevent default on pageup/pagedown when completer is active ([3500](https://github.com/jupyter/notebook/pull/3500)) +- Prevent default event handling on new terminal ([3497](https://github.com/jupyter/notebook/pull/3497)) +- ConfigManager should not write out default values found in the .d + directory ([3485](https://github.com/jupyter/notebook/pull/3485)) +- Fix leak of iopub object in activity monitoring ([3424](https://github.com/jupyter/notebook/pull/3424)) +- Javascript lint in notebooklist.js ([3409](https://github.com/jupyter/notebook/pull/3409)) +- Some Javascript syntax fixes ([3294](https://github.com/jupyter/notebook/pull/3294)) +- Convert native for loop to `Array.forEach()` ([3477](https://github.com/jupyter/notebook/pull/3477)) +- Disable cache when downloading nbconvert output ([3484](https://github.com/jupyter/notebook/pull/3484)) +- Add missing digestmod arg to HMAC ([3399](https://github.com/jupyter/notebook/pull/3399)) +- Log OSErrors failing to create less-critical files during startup ([3384](https://github.com/jupyter/notebook/pull/3384)) +- Use powershell on Windows ([3379](https://github.com/jupyter/notebook/pull/3379)) +- API spec improvements, API handler improvements ([3368](https://github.com/jupyter/notebook/pull/3368)) +- Set notebook to dirty state after change to kernel metadata ([3350](https://github.com/jupyter/notebook/pull/3350)) +- Use CSP header to treat served files as belonging to a separate + origin ([3341](https://github.com/jupyter/notebook/pull/3341)) +- Don't install gettext into builtins ([3330](https://github.com/jupyter/notebook/pull/3330)) +- Add missing `import _` ([3316](https://github.com/jupyter/notebook/pull/3316), + [3326](https://github.com/jupyter/notebook/pull/3326)) +- Write `notebook.json` file atomically ([3305](https://github.com/jupyter/notebook/pull/3305)) +- Fix clicking with modifiers, page title updates ([3282](https://github.com/jupyter/notebook/pull/3282)) +- Upgrade jQuery to version 2.2 ([3428](https://github.com/jupyter/notebook/pull/3428)) +- Upgrade xterm.js to 3.1.0 ([3189](https://github.com/jupyter/notebook/pull/3189)) +- Upgrade moment.js to 2.19.3 ([3562](https://github.com/jupyter/notebook/pull/3562)) +- Upgrade CodeMirror to 5.35 ([3372](https://github.com/jupyter/notebook/pull/3372)) +- "Require" pyzmq\>=17 ([3586](https://github.com/jupyter/notebook/pull/3586)) + +Documentation: + +- Documentation updates and organisation ([3584](https://github.com/jupyter/notebook/pull/3584)) +- Add section in docs about privacy ([3571](https://github.com/jupyter/notebook/pull/3571)) +- Add explanation on how to change the type of a cell to Markdown ([3377](https://github.com/jupyter/notebook/pull/3377)) +- Update docs with confd implementation details ([3520](https://github.com/jupyter/notebook/pull/3520)) +- Add more information for where `jupyter_notebook_config.py` is + located ([3346](https://github.com/jupyter/notebook/pull/3346)) +- Document options to enable nbextensions in specific sections ([3525](https://github.com/jupyter/notebook/pull/3525)) +- jQuery attribute selector value MUST be surrounded by quotes ([3527](https://github.com/jupyter/notebook/pull/3527)) +- Do not execute special notebooks with nbsphinx ([3360](https://github.com/jupyter/notebook/pull/3360)) +- Other minor fixes in [3288](https://github.com/jupyter/notebook/pull/3288), + [3528](https://github.com/jupyter/notebook/pull/3528), [3293](https://github.com/jupyter/notebook/pull/3293), [3367](https://github.com/jupyter/notebook/pull/3367) + +Testing: + +- Testing with Selenium & Sauce labs ([3321](https://github.com/jupyter/notebook/pull/3321)) +- Selenium utils + markdown rendering tests ([3458](https://github.com/jupyter/notebook/pull/3458)) +- Convert insert cell tests to Selenium ([3508](https://github.com/jupyter/notebook/pull/3508)) +- Convert prompt numbers tests to Selenium ([3554](https://github.com/jupyter/notebook/pull/3554)) +- Convert delete cells tests to Selenium ([3465](https://github.com/jupyter/notebook/pull/3465)) +- Convert undelete cell tests to Selenium ([3475](https://github.com/jupyter/notebook/pull/3475)) +- More selenium testing utilities ([3412](https://github.com/jupyter/notebook/pull/3412)) +- Only check links when build is trigger by Travis Cron job ([3493](https://github.com/jupyter/notebook/pull/3493)) +- Fix Appveyor build errors ([3430](https://github.com/jupyter/notebook/pull/3430)) +- Undo patches in teardown before attempting to delete files ([3459](https://github.com/jupyter/notebook/pull/3459)) +- Get tests running with tornado 5 ([3398](https://github.com/jupyter/notebook/pull/3398)) +- Unpin ipykernel version on Travis ([3223](https://github.com/jupyter/notebook/pull/3223)) + +Thanks to the following contributors: + +- Arovit Narula ([arovit](https://github.com/arovit)) +- Ashley Teoh ([ashleytqy](https://github.com/ashleytqy)) +- Nicholas Bollweg ([bollwyvl](https://github.com/bollwyvl)) +- Alex Rothberg ([cancan101](https://github.com/cancan101)) +- Celina Kilcrease ([ckilcrease](https://github.com/ckilcrease)) +- dabuside ([dabuside](https://github.com/dabuside)) +- Damian Avila ([damianavila](https://github.com/damianavila)) +- Dana Lee ([danagilliann](https://github.com/danagilliann)) +- Dave Hirschfeld ([dhirschfeld](https://github.com/dhirschfeld)) +- Heng GAO ([ehengao](https://github.com/ehengao)) +- Leo Gallucci ([elgalu](https://github.com/elgalu)) +- Evan Van Dam ([evandam](https://github.com/evandam)) +- forbxy ([forbxy](https://github.com/forbxy)) +- Grant Nestor ([gnestor](https://github.com/gnestor)) +- Ethan T. Hendrix ([hendrixet](https://github.com/hendrixet)) +- Miro Hrončok ([hroncok](https://github.com/hroncok)) +- Paul Ivanov ([ivanov](https://github.com/ivanov)) +- Darío Hereñú ([kant](https://github.com/kant)) +- Kevin Bates ([kevin-bates](https://github.com/kevin-bates)) +- Maarten Breddels ([maartenbreddels](https://github.com/maartenbreddels)) +- Michael Droettboom ([mdboom](https://github.com/mdboom)) +- Min RK ([minrk](https://github.com/minrk)) +- M Pacer ([mpacer](https://github.com/mpacer)) +- Peter Parente ([parente](https://github.com/parente)) +- Paul Masson ([paulmasson](https://github.com/paulmasson)) +- Philipp Rudiger ([philippjfr](https://github.com/philippjfr)) +- Mac Knight ([Shels1909](https://github.com/Shels1909)) +- Hisham Elsheshtawy ([Sheshtawy](https://github.com/Sheshtawy)) +- Simon Biggs ([SimonBiggs](https://github.com/SimonBiggs)) +- Sunil Hari (`@sunilhari`) +- Thomas Kluyver ([takluyver](https://github.com/takluyver)) +- Tim Klever ([tklever](https://github.com/tklever)) +- Gabriel Ruiz ([unnamedplay-r](https://github.com/unnamedplay-r)) +- Vaibhav Sagar ([vaibhavsagar](https://github.com/vaibhavsagar)) +- William Hosford ([whosford](https://github.com/whosford)) +- Hong ([xuhdev](https://github.com/xuhdev)) + +See the 5.5 milestone on GitHub for a complete list of [pull +requests](https://github.com/jupyter/notebook/pulls?utf8=%E2%9C%93&q=is%3Apr%20milestone%3A5.5) +involved in this release. + +## 5.4.1 + +A security release to fix [CVE-2018-8768](http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-8768). + +Thanks to [Alex](https://hackerone.com/pisarenko) for identifying this +bug, and Jonathan Kamens and Scott Sanderson at Quantopian for verifying +it and bringing it to our attention. + +## 5.4.0 + +- Fix creating files and folders after navigating directories in the + dashboard ([3264](https://github.com/jupyter/notebook/pull/3264)). +- Enable printing notebooks in colour, removing the CSS that made + everything black and white ([3212](https://github.com/jupyter/notebook/pull/3212)). +- Limit the completion options displayed in the notebook to 1000, to + avoid performance issues with very long lists ([3195](https://github.com/jupyter/notebook/pull/3195)). +- Accessibility improvements in `tree.html` ([3271](https://github.com/jupyter/notebook/pull/3271)). +- Added alt-text to the kernel logo image in the notebook UI ([3228](https://github.com/jupyter/notebook/pull/3228)). +- Added a test on Travis CI to flag if symlinks are accidentally + introduced in the future. This should prevent the issue that + necessitated `release-5.3.1`{.interpreted-text role="ref"} ([3227](https://github.com/jupyter/notebook/pull/3227)). +- Use lowercase letters for random IDs generated in our Javascript ([3264](https://github.com/jupyter/notebook/pull/3264)). +- Removed duplicate code setting `TextCell.notebook` ([3256](https://github.com/jupyter/notebook/pull/3256)). + +Thanks to the following contributors: + +- Alex Soderman ([asoderman](https://github.com/asoderman)) +- Matthias Bussonnier ([Carreau](https://github.com/Carreau)) +- Min RK ([minrk](https://github.com/minrk)) +- Nitesh Sawant ([ns23](https://github.com/ns23)) +- Thomas Kluyver ([takluyver](https://github.com/takluyver)) +- Yuvi Panda ([yuvipanda](https://github.com/yuvipanda)) + +See the 5.4 milestone on GitHub for a complete list of [pull +requests](https://github.com/jupyter/notebook/pulls?utf8=%E2%9C%93&q=is%3Apr%20milestone%3A5.4) +involved in this release. + +## 5.3.1 + +Replaced a symlink in the repository with a copy, to fix issues +installing on Windows ([3220](https://github.com/jupyter/notebook/pull/3220)). + +## 5.3.0 + +This release introduces a couple noteable improvements, such as terminal +support for Windows and support for OS trash (files deleted from the +notebook dashboard are moved to the OS trash vs. deleted permanently). + +- Add support for terminals on windows ([3087](https://github.com/jupyter/notebook/pull/3087)). +- Add a "restart and run all" button to the toolbar ([2965](https://github.com/jupyter/notebook/pull/2965)). +- Send files to os trash mechanism on delete ([1968](https://github.com/jupyter/notebook/pull/1968)). +- Allow programmatic copy to clipboard ([3088](https://github.com/jupyter/notebook/pull/3088)). +- Use DOM History API for navigating between directories in the file + browser ([3115](https://github.com/jupyter/notebook/pull/3115)). +- Add translated files to folder(docs-translations) ([3065](https://github.com/jupyter/notebook/pull/3065)). +- Allow non empty dirs to be deleted ([3108](https://github.com/jupyter/notebook/pull/3108)). +- Set cookie on base_url ([2959](https://github.com/jupyter/notebook/pull/2959)). +- Allow token-authenticated requests cross-origin by default ([2920](https://github.com/jupyter/notebook/pull/2920)). +- Change cull_idle_timeout_minimum to 1 from 300 ([2910](https://github.com/jupyter/notebook/pull/2910)). +- Config option to shut down server after n seconds with no kernels ([2963](https://github.com/jupyter/notebook/pull/2963)). +- Display a "close" button on load notebook error ([3176](https://github.com/jupyter/notebook/pull/3176)). +- Add action to command pallette to run CodeMirror's "indentAuto" + on selection ([3175](https://github.com/jupyter/notebook/pull/3175)). +- Add option to specify extra services ([3158](https://github.com/jupyter/notebook/pull/3158)). +- Warn_bad_name should not use global name ([3160](https://github.com/jupyter/notebook/pull/3160)). +- Avoid overflow of hidden form ([3148](https://github.com/jupyter/notebook/pull/3148)). +- Fix shutdown trans loss ([3147](https://github.com/jupyter/notebook/pull/3147)). +- Find available kernelspecs more efficiently ([3136](https://github.com/jupyter/notebook/pull/3136)). +- Don't try to translate missing help strings ([3122](https://github.com/jupyter/notebook/pull/3122)). +- Frontend/extension-config: allow default json files in a .d + directory ([3116](https://github.com/jupyter/notebook/pull/3116)). +- Use [requirejs]{.title-ref} vs. [require]{.title-ref} ([3097](https://github.com/jupyter/notebook/pull/3097)). +- Fixes some ui bugs in firefox \#3044 ([3058](https://github.com/jupyter/notebook/pull/3058)). +- Compare non-specific language code when choosing to use arabic + numerals ([3055](https://github.com/jupyter/notebook/pull/3055)). +- Fix save-script deprecation ([3053](https://github.com/jupyter/notebook/pull/3053)). +- Include moment locales in package_data ([3051](https://github.com/jupyter/notebook/pull/3051)). +- Fix moment locale loading in bidi support ([3048](https://github.com/jupyter/notebook/pull/3048)). +- Tornado 5: periodiccallback loop arg will be removed ([3034](https://github.com/jupyter/notebook/pull/3034)). +- Use [/files]{.title-ref} prefix for pdf-like files ([3031](https://github.com/jupyter/notebook/pull/3031)). +- Add folder for document translation ([3022](https://github.com/jupyter/notebook/pull/3022)). +- When login-in via token, let a chance for user to set the password ([3008](https://github.com/jupyter/notebook/pull/3008)). +- Switch to jupyter_core implementation of ensure_dir_exists ([3002](https://github.com/jupyter/notebook/pull/3002)). +- Send http shutdown request on 'stop' subcommand ([3000](https://github.com/jupyter/notebook/pull/3000)). +- Work on loading ui translations ([2969](https://github.com/jupyter/notebook/pull/2969)). +- Fix ansi inverse ([2967](https://github.com/jupyter/notebook/pull/2967)). +- Add send2trash to requirements for building docs ([2964](https://github.com/jupyter/notebook/pull/2964)). +- I18n readme.md improvement ([2962](https://github.com/jupyter/notebook/pull/2962)). +- Add 'reason' field to json error responses ([2958](https://github.com/jupyter/notebook/pull/2958)). +- Add some padding for stream outputs ([3194](https://github.com/jupyter/notebook/pull/3194)). +- Always use setuptools in `setup.py` ([3206](https://github.com/jupyter/notebook/pull/3206)). +- Fix clearing cookies on logout when `base_url` is configured ([3207](https://github.com/jupyter/notebook/pull/3207)). + +Thanks to the following contributors: + +- bacboc ([bacboc](https://github.com/bacboc)) +- Steven Silvester ([blink1073](https://github.com/blink1073)) +- Matthias Bussonnier ([Carreau](https://github.com/Carreau)) +- ChungJooHo ([ChungJooHo](https://github.com/ChungJooHo)) +- edida ([edida](https://github.com/edida)) +- Francesco Franchina (`ferdas`) +- forbxy ([forbxy](https://github.com/forbxy)) +- Grant Nestor ([gnestor](https://github.com/gnestor)) +- Josh Barnes ([jcb91](https://github.com/jcb91)) +- JocelynDelalande ([JocelynDelalande](https://github.com/JocelynDelalande)) +- Karthik Balakrishnan ([karthikb351](https://github.com/karthikb351)) +- Kevin Bates ([kevin-bates](https://github.com/kevin-bates)) +- Kirit Thadaka ([kirit93](https://github.com/kirit93)) +- Lilian Besson ([Naereen](https://github.com/Naereen)) +- Maarten Breddels ([maartenbreddels](https://github.com/maartenbreddels)) +- Madhu94 ([Madhu94](https://github.com/Madhu94)) +- Matthias Geier ([mgeier](https://github.com/mgeier)) +- Michael Heilman ([mheilman](https://github.com/mheilman)) +- Min RK ([minrk](https://github.com/minrk)) +- PHaeJin ([PHaeJin](https://github.com/PHaeJin)) +- Sukneet ([Sukneet](https://github.com/Sukneet)) +- Thomas Kluyver ([takluyver](https://github.com/takluyver)) + +See the 5.3 milestone on GitHub for a complete list of [pull +requests](https://github.com/jupyter/notebook/pulls?utf8=%E2%9C%93&q=is%3Apr%20milestone%3A5.3) +involved in this release. + +## 5.2.1 + +- Fix invisible CodeMirror cursor at specific browser zoom levels ([2983](https://github.com/jupyter/notebook/pull/2983)). +- Fix nbconvert handler causing broken export to PDF ([2981](https://github.com/jupyter/notebook/pull/2981)). +- Fix the prompt_area argument of the output area constructor. ([2961](https://github.com/jupyter/notebook/pull/2961)). +- Handle a compound extension in new_untitled ([2949](https://github.com/jupyter/notebook/pull/2949)). +- Allow disabling offline message buffering ([2916](https://github.com/jupyter/notebook/pull/2916)). + +Thanks to the following contributors: + +- Steven Silvester ([blink1073](https://github.com/blink1073)) +- Grant Nestor ([gnestor](https://github.com/gnestor)) +- Jason Grout ([jasongrout](https://github.com/jasongrout)) +- Min RK ([minrk](https://github.com/minrk)) +- M Pacer ([mpacer](https://github.com/mpacer)) + +See the 5.2.1 milestone on GitHub for a complete list of [pull +requests](https://github.com/jupyter/notebook/pulls?utf8=%E2%9C%93&q=is%3Apr%20milestone%3A5.2.1) +involved in this release. + +## 5.2.0 + +- Allow setting token via jupyter_token env ([2921](https://github.com/jupyter/notebook/pull/2921)). +- Fix some errors caused by raising 403 in get_current_user ([2919](https://github.com/jupyter/notebook/pull/2919)). +- Register contents_manager.files_handler_class directly ([2917](https://github.com/jupyter/notebook/pull/2917)). +- Update viewable_extensions ([2913](https://github.com/jupyter/notebook/pull/2913)). +- Show edit shortcuts modal after shortcuts modal is hidden ([2912](https://github.com/jupyter/notebook/pull/2912)). +- Improve edit/view behavior ([2911](https://github.com/jupyter/notebook/pull/2911)). +- The root directory of the notebook server should never be hidden ([2907](https://github.com/jupyter/notebook/pull/2907)). +- Fix notebook require config to match tools/build-main ([2888](https://github.com/jupyter/notebook/pull/2888)). +- Give page constructor default arguments ([2887](https://github.com/jupyter/notebook/pull/2887)). +- Fix codemirror.less to match codemirror's expected padding layout ([2880](https://github.com/jupyter/notebook/pull/2880)). +- Add x-xsrftoken to access-control-allow-headers ([2876](https://github.com/jupyter/notebook/pull/2876)). +- Buffer messages when websocket connection is interrupted ([2871](https://github.com/jupyter/notebook/pull/2871)). +- Load locale dynamically only when not en-us ([2866](https://github.com/jupyter/notebook/pull/2866)). +- Changed key strength to 2048 bits ([2861](https://github.com/jupyter/notebook/pull/2861)). +- Resync jsversion with python version ([2860](https://github.com/jupyter/notebook/pull/2860)). +- Allow copy operation on modified, read-only notebook ([2854](https://github.com/jupyter/notebook/pull/2854)). +- Update error handling on apihandlers ([2853](https://github.com/jupyter/notebook/pull/2853)). +- Test python 3.6 on travis, drop 3.3 ([2852](https://github.com/jupyter/notebook/pull/2852)). +- Avoid base64-literals in image tests ([2851](https://github.com/jupyter/notebook/pull/2851)). +- Upgrade xterm.js to 2.9.2 ([2849](https://github.com/jupyter/notebook/pull/2849)). +- Changed all python variables named file to file_name to not override + built_in file ([2830](https://github.com/jupyter/notebook/pull/2830)). +- Add more doc tests ([2823](https://github.com/jupyter/notebook/pull/2823)). +- Typos fix ([2815](https://github.com/jupyter/notebook/pull/2815)). +- Rename and update license \[ci skip\] ([2810](https://github.com/jupyter/notebook/pull/2810)). +- Travis builds doc ([2808](https://github.com/jupyter/notebook/pull/2808)). +- Pull request i18n ([2804](https://github.com/jupyter/notebook/pull/2804)). +- Factor out output_prompt_function, as is done with input prompt ([2774](https://github.com/jupyter/notebook/pull/2774)). +- Use rfc5987 encoding for filenames ([2767](https://github.com/jupyter/notebook/pull/2767)). +- Added path to the resources metadata, the same as in + from_filename(...) in nbconvert.exporters.py ([2753](https://github.com/jupyter/notebook/pull/2753)). +- Make "extrakeys" consistent for notebook and editor ([2745](https://github.com/jupyter/notebook/pull/2745)). +- Bidi support ([2357](https://github.com/jupyter/notebook/pull/2357)). + +Special thanks to [samarsultan](https://github.com/samarsultan) and the +Arabic Competence and Globalization Center Team at IBM Egypt for adding +RTL (right-to-left) support to the notebook! + +See the 5.2 milestone on GitHub for a complete list of +[issues](https://github.com/jupyter/notebook/issues?utf8=%E2%9C%93&q=is%3Aissue%20milestone%3A5.2) +and [pull +requests](https://github.com/jupyter/notebook/pulls?utf8=%E2%9C%93&q=is%3Apr%20milestone%3A5.2) +involved in this release. + +## 5.1.0 + +- Preliminary i18n implementation ([2140](https://github.com/jupyter/notebook/pull/2140)). +- Expose URL with auth token in notebook UI ([2666](https://github.com/jupyter/notebook/pull/2666)). +- Fix search background style ([2387](https://github.com/jupyter/notebook/pull/2387)). +- List running notebooks without requiring `--allow-root` ([2421](https://github.com/jupyter/notebook/pull/2421)). +- Allow session of type other than notebook ([2559](https://github.com/jupyter/notebook/pull/2559)). +- Fix search background style ([2387](https://github.com/jupyter/notebook/pull/2387)). +- Fix some Markdown styling issues ([2571](https://github.com/jupyter/notebook/pull/2571)), ([2691](https://github.com/jupyter/notebook/pull/2691)) and ([2534](https://github.com/jupyter/notebook/pull/2534)). +- Remove keymaps that conflict with non-English keyboards ([2535](https://github.com/jupyter/notebook/pull/2535)). +- Add session-specific favicons (notebook, terminal, file) ([2452](https://github.com/jupyter/notebook/pull/2452)). +- Add /api/shutdown handler ([2507](https://github.com/jupyter/notebook/pull/2507)). +- Include metadata when copying a cell ([2349](https://github.com/jupyter/notebook/pull/2349)). +- Stop notebook server from command line ([2388](https://github.com/jupyter/notebook/pull/2388)). +- Improve "View" and "Edit" file handling in dashboard ([2449](https://github.com/jupyter/notebook/pull/2449)) and ([2402](https://github.com/jupyter/notebook/pull/2402)). +- Provide a promise to replace use of the + `app_initialized.NotebookApp` event ([2710](https://github.com/jupyter/notebook/pull/2710)). +- Fix disabled collapse/expand output button ([2681](https://github.com/jupyter/notebook/pull/2681)). +- Cull idle kernels using `--MappingKernelManager.cull_idle_timeout` ([2215](https://github.com/jupyter/notebook/pull/2215)). +- Allow read-only notebooks to be trusted ([2718](https://github.com/jupyter/notebook/pull/2718)). + +See the 5.1 milestone on GitHub for a complete list of +[issues](https://github.com/jupyter/notebook/issues?utf8=%E2%9C%93&q=is%3Aissue%20milestone%3A5.1) +and [pull +requests](https://github.com/jupyter/notebook/pulls?utf8=%E2%9C%93&q=is%3Apr%20milestone%3A5.1) +involved in this release. + +## 5.0.0 + +This is the first major release of the Jupyter Notebook since version +4.0 was created by the "Big Split" of IPython and Jupyter. + +We encourage users to start trying JupyterLab in preparation for a +future transition. + +We have merged more than 300 pull requests since 4.0. Some of the major +user-facing changes are described here. + +### File sorting in the dashboard + +Files in the dashboard may now be sorted by last modified date or name +([943](https://github.com/jupyter/notebook/pull/943)): + +![image](/_static/images/dashboard-sort.png) + +### Cell tags + +There is a new cell toolbar for adding _cell tags_ +([2048](https://github.com/jupyter/notebook/pull/2048)): + +![image](/_static/images/cell-tags-toolbar.png) + +Cell tags are a lightweight way to customise the behaviour of tools +working with notebooks; we're working on building support for them into +tools like [nbconvert](https://nbconvert.readthedocs.io/en/latest/) and +[nbval](https://github.com/computationalmodelling/nbval). To start using +tags, select `Tags` in the `View > Cell Toolbar` menu in a notebook. + +The UI for editing cell tags is basic for now; we hope to improve it in +future releases. + +### Table style + +The default styling for tables in the notebook has been updated +([1776](https://github.com/jupyter/notebook/pull/1776)). + +Before: + +![image](/_static/images/table-style-before.png) + +After: + +![image](/_static/images/table-style-after.png) + +### Customise keyboard shortcuts + +You can now edit keyboard shortcuts for _Command Mode_ within the UI +([1347](https://github.com/jupyter/notebook/pull/1347)): + +![image](/_static/images/shortcut-editor.png) + +See the `Help > Edit Keyboard Shortcuts` menu item and follow the +instructions. + +### Other additions + +- You can copy and paste cells between notebooks, using + `Ctrl-C`{.interpreted-text role="kbd"} and + `Ctrl-V`{.interpreted-text role="kbd"} (`Cmd-C`{.interpreted-text + role="kbd"} and `Cmd-V`{.interpreted-text role="kbd"} on Mac). +- It's easier to configure a password for the notebook with the new + `jupyter notebook password` command ([2007](https://github.com/jupyter/notebook/pull/2007)). +- The file list can now be ordered by _last modified_ or by _name_ ([943](https://github.com/jupyter/notebook/pull/943)). +- Markdown cells now support attachments. Simply drag and drop an + image from your desktop to a markdown cell to add it. Unlike + relative links that you enter manually, attachments are embedded in + the notebook itself. An unreferenced attachment will be + automatically scrubbed from the notebook on save ([621](https://github.com/jupyter/notebook/pull/621)). +- Undoing cell deletion now supports undeleting multiple cells. Cells + may not be in the same order as before their deletion, depending on + the actions you did on the meantime, but this should should help + reduce the impact of accidentally deleting code. +- The file browser now has _Edit_ and _View_ buttons. +- The file browser now supports moving multiple files at once ([1088](https://github.com/jupyter/notebook/pull/1088)). +- The Notebook will refuse to run as root unless the `--allow-root` + flag is given ([1115](https://github.com/jupyter/notebook/pull/1115)). +- Keyboard shortcuts are now declarative ([1234](https://github.com/jupyter/notebook/pull/1234)). +- Toggling line numbers can now affect all cells ([1312](https://github.com/jupyter/notebook/pull/1312)). +- Add more visible _Trusted_ and _Untrusted_ notifications ([1658](https://github.com/jupyter/notebook/pull/1658)). +- The favicon (browser shortcut icon) now changes to indicate when the + kernel is busy ([1837](https://github.com/jupyter/notebook/pull/1837)). +- Header and toolbar visibility is now persisted in nbconfig and + across sessions ([1769](https://github.com/jupyter/notebook/pull/1769)). +- Load server extensions with ConfigManager so that merge happens + recursively, unlike normal config values, to make it load more + consistently with frontend extensions([2108](https://github.com/jupyter/notebook/pull/2108)). +- The notebook server now supports the [bundler + API](https://jupyter-notebook.readthedocs.io/en/latest/extending/bundler_extensions.html) + from the [jupyter_cms incubator + project](https://github.com/jupyter-incubator/contentmanagement) ([1579](https://github.com/jupyter/notebook/pull/1579)). +- The notebook server now provides information about kernel activity + in its kernel resource API ([1827](https://github.com/jupyter/notebook/pull/1827)). + +Remember that upgrading `notebook` only affects the user interface. +Upgrading kernels and libraries may also provide new features, better +stability and integration with the notebook interface. + +## 4.4.0 + +- Allow override of output callbacks to redirect output messages. This + is used to implement the ipywidgets Output widget, for example. +- Fix an async bug in message handling by allowing comm message + handlers to return a promise which halts message processing until + the promise resolves. + +See the 4.4 milestone on GitHub for a complete list of +[issues](https://github.com/jupyter/notebook/issues?utf8=%E2%9C%93&q=is%3Aissue%20milestone%3A4.4) +and [pull +requests](https://github.com/jupyter/notebook/pulls?utf8=%E2%9C%93&q=is%3Apr%20milestone%3A4.4) +involved in this release. + +## 4.3.2 + +4.3.2 is a patch release with a bug fix for CodeMirror and improved +handling of the "editable" cell metadata field. + +- Monkey-patch for CodeMirror that resolves + [\#2037](https://github.com/jupyter/notebook/issues/2037) without + breaking [\#1967](https://github.com/jupyter/notebook/issues/1967) +- Read-only (`"editable": false`) cells can be executed but cannot be + split, merged, or deleted + +See the 4.3.2 milestone on GitHub for a complete list of +[issues](https://github.com/jupyter/notebook/issues?utf8=%E2%9C%93&q=is%3Aissue%20milestone%3A4.3.2) +and [pull +requests](https://github.com/jupyter/notebook/pulls?utf8=%E2%9C%93&q=is%3Apr%20milestone%3A4.3.2) +involved in this release. + +## 4.3.1 + +4.3.1 is a patch release with a security patch, a couple bug fixes, and +improvements to the newly-released token authentication. + +**Security fix**: + +- CVE-2016-9971. Fix CSRF vulnerability, where malicious forms could + create untitled files and start kernels (no remote execution or + modification of existing files) for users of certain browsers (Firefox, Internet Explorer / Edge). All previous notebook releases + are affected. + +Bug fixes: + +- Fix carriage return handling +- Make the font size more robust against fickle browsers +- Ignore resize events that bubbled up and didn't come from window +- Add Authorization to allowed CORS headers +- Downgrade CodeMirror to 5.16 while we figure out issues in Safari + +Other improvements: + +- Better docs for token-based authentication +- Further highlight token info in log output when autogenerated + +See the 4.3.1 milestone on GitHub for a complete list of +[issues](https://github.com/jupyter/notebook/issues?utf8=%E2%9C%93&q=is%3Aissue%20milestone%3A4.3.1) +and [pull +requests](https://github.com/jupyter/notebook/pulls?utf8=%E2%9C%93&q=is%3Apr%20milestone%3A4.3.1) +involved in this release. + +## 4.3.0 + +4.3 is a minor release with many bug fixes and improvements. The biggest +user-facing change is the addition of token authentication, which is +enabled by default. A token is generated and used when your browser is +opened automatically, so you shouldn't have to enter anything in the +default circumstances. If you see a login page (e.g. by switching +browsers, or launching on a new port with `--no-browser`), you get a +login URL with the token from the command `jupyter notebook list`, which +you can paste into your browser. + +Highlights: + +- API for creating mime-type based renderer extensions using + `OutputArea.register_mime_type` and `Notebook.render_cell_output` + methods. See + [mimerender-cookiecutter](https://github.com/jupyterlab/mimerender-cookiecutter) + for reference implementations and cookiecutter. +- Enable token authentication by default. See + `server_security`{.interpreted-text role="ref"} for more details. +- Update security docs to reflect new signature system +- Switched from term.js to xterm.js + +Bug fixes: + +- Ensure variable is set if exc_info is falsey +- Catch and log handler exceptions in `events.trigger` +- Add debug log for static file paths +- Don't check origin on token-authenticated requests +- Remove leftover print statement +- Fix highlighting of Python code blocks +- `json_errors` should be outermost decorator on API handlers +- Fix remove old nbserver info files +- Fix notebook mime type on download links +- Fix carriage symbol behavior +- Fix terminal styles +- Update dead links in docs +- If kernel is broken, start a new session +- Include cross-origin check when allowing login URL redirects + +Other improvements: + +- Allow JSON output data with mime type `application/*+json` +- Allow kernelspecs to have spaces in them for backward compat +- Allow websocket connections from scripts +- Allow `None` for post_save_hook +- Upgrade CodeMirror to 5.21 +- Upgrade xterm to 2.1.0 +- Docs for using comms +- Set `dirty` flag when output arrives +- Set `ws-url` data attribute when accessing a notebook terminal +- Add base aliases for nbextensions +- Include `@` operator in CodeMirror IPython mode +- Extend mathjax_url docstring +- Load nbextension in predictable order +- Improve the error messages for nbextensions +- Include cross-origin check when allowing login URL redirects + +See the 4.3 milestone on GitHub for a complete list of +[issues](https://github.com/jupyter/notebook/issues?utf8=%E2%9C%93&q=is%3Aissue%20milestone%3A4.3%20) +and [pull +requests](https://github.com/jupyter/notebook/pulls?utf8=%E2%9C%93&q=is%3Apr%20milestone%3A4.3%20) +involved in this release. + +## 4.2.3 + +4.2.3 is a small bugfix release on 4.2. + +> Highlights: + +- Fix regression in 4.2.2 that delayed loading custom.js until after + `notebook_loaded` and `app_initialized` events have fired. +- Fix some outdated docs and links. + +## 4.2.2 + +4.2.2 is a small bugfix release on 4.2, with an important security fix. +All users are strongly encouraged to upgrade to 4.2.2. + +> Highlights: + +- **Security fix**: CVE-2016-6524, where untrusted latex output could + be added to the page in a way that could execute javascript. +- Fix missing POST in OPTIONS responses. +- Fix for downloading non-ascii filenames. +- Avoid clobbering ssl_options, so that users can specify more + detailed SSL configuration. +- Fix inverted load order in nbconfig, so user config has highest + priority. +- Improved error messages here and there. + +## 4.2.1 + +4.2.1 is a small bugfix release on 4.2. Highlights: + +- Compatibility fixes for some versions of ipywidgets +- Fix for ignored CSS on Windows +- Fix specifying destination when installing nbextensions + +## 4.2.0 + +Release 4.2 adds a new API for enabling and installing extensions. +Extensions can now be enabled at the system-level, rather than just +per-user. An API is defined for installing directly from a Python +package, as well. + +Highlighted changes: + +- Upgrade MathJax to 2.6 to fix vertical-bar appearing on some + equations. +- Restore ability for notebook directory to be root (4.1 regression) +- Large outputs are now throttled, reducing the ability of output + floods to kill the browser. +- Fix the notebook ignoring cell executions while a kernel is starting + by queueing the messages. +- Fix handling of url prefixes (e.g. JupyterHub) in terminal and edit + pages. +- Support nested SVGs in output. + +And various other fixes and improvements. + +## 4.1.0 + +Bug fixes: + +- Properly reap zombie subprocesses +- Fix cross-origin problems +- Fix double-escaping of the base URL prefix +- Handle invalid unicode filenames more gracefully +- Fix ANSI color-processing +- Send keepalive messages for web terminals +- Fix bugs in the notebook tour + +UI changes: + +- Moved the cell toolbar selector into the _View_ menu. Added a button + that triggers a "hint" animation to the main toolbar so users can + find the new location. (Click here to see a + [screencast](https://cloud.githubusercontent.com/assets/335567/10711889/59665a5a-7a3e-11e5-970f-86b89592880c.gif) + ) + + > ![image](/_static/images/cell-toolbar-41.png) + +- Added _Restart & Run All_ to the _Kernel_ menu. Users can also bind + it to a keyboard shortcut on action + `restart-kernel-and-run-all-cells`. + +- Added multiple-cell selection. Users press `Shift-Up/Down` or + `Shift-K/J` to extend selection in command mode. Various actions + such as cut/copy/paste, execute, and cell type conversions apply to + all selected cells. + + ![image](/_static/images/multi-select-41.png) + +- Added a command palette for executing Jupyter actions by name. Users + press `Cmd/Ctrl-Shift-P` or click the new command palette icon on + the toolbar. + + ![image](/_static/images/command-palette-41.png) + +- Added a _Find and Replace_ dialog to the _Edit_ menu. Users can also + press `F` in command mode to show the dialog. + + ![image](/_static/images/find-replace-41.png) + +Other improvements: + +- Custom KernelManager methods can be Tornado coroutines, allowing + async operations. +- Make clearing output optional when rewriting input with + `set_next_input(replace=True)`. +- Added support for TLS client authentication via + `--NotebookApp.client-ca`. +- Added tags to `jupyter/notebook` releases on DockerHub. `latest` + continues to track the master branch. + +See the 4.1 milestone on GitHub for a complete list of +[issues](https://github.com/jupyter/notebook/issues?page=3&q=milestone%3A4.1+is%3Aclosed+is%3Aissue&utf8=%E2%9C%93) +and [pull +requests](https://github.com/jupyter/notebook/pulls?q=milestone%3A4.1+is%3Aclosed+is%3Apr) +handled. + +## 4.0.x + +### 4.0.6 + +- fix installation of mathjax support files +- fix some double-escape regressions in 4.0.5 +- fix a couple of cases where errors could prevent opening a notebook + +### 4.0.5 + +Security fixes for maliciously crafted files. + +- [CVE-2015-6938](http://www.openwall.com/lists/oss-security/2015/09/02/3): + malicious filenames +- [CVE-2015-7337](http://www.openwall.com/lists/oss-security/2015/09/16/3): + malicious binary files in text editor. + +Thanks to Jonathan Kamens at Quantopian and Juan Broullón for the +reports. + +### 4.0.4 + +- Fix inclusion of mathjax-safe extension + +### 4.0.2 + +- Fix launching the notebook on Windows +- Fix the path searched for frontend config + +### 4.0.0 + +First release of the notebook as a standalone package. diff --git a/docs/source/comms.rst b/docs/source/comms.rst deleted file mode 100644 index 7c292d78bd..0000000000 --- a/docs/source/comms.rst +++ /dev/null @@ -1,98 +0,0 @@ -Comms -===== - -*Comms* allow custom messages between the frontend and the kernel. They are used, -for instance, in `ipywidgets `__ to -update widget state. - -A comm consists of a pair of objects, in the kernel and the frontend, with an -automatically assigned unique ID. When one side sends a message, a callback on -the other side is triggered with that message data. Either side, the frontend -or kernel, can open or close the comm. - -.. seealso:: - - `Custom Messages `__ - The messaging specification section on comms - -Opening a comm from the kernel ------------------------------- - -First, the function to accept the comm must be available on the frontend. This -can either be specified in a `requirejs` module, or registered in a registry, for -example when an :doc:`extension ` is loaded. -This example shows a frontend comm target registered in a registry: - -.. code-block:: javascript - - Jupyter.notebook.kernel.comm_manager.register_target('my_comm_target', - function(comm, msg) { - // comm is the frontend comm instance - // msg is the comm_open message, which can carry data - - // Register handlers for later messages: - comm.on_msg(function(msg) {...}); - comm.on_close(function(msg) {...}); - comm.send({'foo': 0}); - }); - -Now that the frontend comm is registered, you can open the comm from the kernel: - -.. code-block:: python - - from ipykernel.comm import Comm - - # Use comm to send a message from the kernel - my_comm = Comm(target_name='my_comm_target', data={'foo': 1}) - my_comm.send({'foo': 2}) - - # Add a callback for received messages. - @my_comm.on_msg - def _recv(msg): - # Use msg['content']['data'] for the data in the message - - -This example uses the IPython kernel; it's up to each language kernel what API, -if any, it offers for using comms. - -Opening a comm from the frontend --------------------------------- - -This is very similar to above, but in reverse. First, a comm target must be -registered in the kernel. For instance, this may be done by code displaying -output: it will register a target in the kernel, and then display output -containing Javascript to connect to it. - -.. code-block:: python - - def target_func(comm, open_msg): - # comm is the kernel Comm instance - # msg is the comm_open message - - # Register handler for later messages - @comm.on_msg - def _recv(msg): - # Use msg['content']['data'] for the data in the message - comm.send({'echo': msg['content']['data']}) - - # Send data to the frontend on creation - comm.send({'foo': 5}) - - get_ipython().kernel.comm_manager.register_target('my_comm_target', target_func) - -This example uses the IPython kernel again; this example will be different in -other kernels that support comms. Refer to the specific language kernel's -documentation for comms support. - -And then open the comm from the frontend: - -.. code-block:: javascript - - const comm = Jupyter.notebook.kernel.comm_manager.new_comm('my_comm_target', {'foo': 6}) - // Send data - comm.send({'foo': 7}) - - // Register a handler - comm.on_msg(function(msg) { - console.log(msg.content.data.foo); - }); diff --git a/docs/source/conf.py b/docs/source/conf.py index 1aa7613b42..2907cfab2a 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -14,7 +14,6 @@ import sys import os -import shlex import shutil # If extensions (or modules to document with autodoc) are in another directory, @@ -46,16 +45,6 @@ for item in sys.path: print(item) -# Check if docs are being built by ReadTheDocs -# If so, generate a config.rst file and populate it with documentation about -# configuration options - -if os.environ.get('READTHEDOCS', ''): - # Readthedocs doesn't run our Makefile, so we do this to force it to generate - # the config docs. - with open('../autogen_config.py') as f: - exec(compile(f.read(), '../autogen_config.py', 'exec'), {}) - # -- General configuration ------------------------------------------------ # If your documentation needs a minimal Sphinx version, state it here. @@ -161,7 +150,7 @@ # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. -html_theme = 'sphinx_rtd_theme' +html_theme = "pydata_sphinx_theme" # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the @@ -180,7 +169,7 @@ # The name of an image file (relative to this directory) to place at the top # of the sidebar. -#html_logo = None +html_logo = "examples/images/jupyter_logo.png" # The name of an image file (within the static path) to use as favicon of the # docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 @@ -355,6 +344,3 @@ spelling_lang='en_US' spelling_word_list_filename='spelling_wordlist.txt' - -# import before any doc is built, so _ is guaranteed to be injected -import notebook.transutils diff --git a/docs/source/config_overview.rst b/docs/source/config_overview.rst index ccb64a2751..7bafb9ba96 100644 --- a/docs/source/config_overview.rst +++ b/docs/source/config_overview.rst @@ -8,8 +8,7 @@ options to suit your workflow. Here are areas that are commonly configured when using Jupyter Notebook: - :ref:`Jupyter's common configuration system ` - - :ref:`Notebook server ` - - :ref:`Notebook front-end client ` + - :ref:`Jupyter Server ` - :ref:`Notebook extensions ` Let's look at highlights of each area. @@ -28,48 +27,37 @@ and editing settings is similar for all the Jupyter applications. - `traitlets `_ provide a low-level architecture for configuration. -.. _configure_nbserver: +.. _configure_jupyter_server: -Notebook server +Jupyter server --------------- -The Notebook server runs the language kernel and communicates with the + +The Jupyter Server runs the language kernel and communicates with the front-end Notebook client (i.e. the familiar notebook interface). - - Configuring the Notebook server + - Configuring the Jupyter Server - To create a ``jupyter_notebook_config.py`` file in the ``.jupyter`` + To create a ``jupyter_server_config.py`` file in the ``.jupyter`` directory, with all the defaults commented out, use the following command:: - $ jupyter notebook --generate-config - - :ref:`Command line arguments for configuration ` settings are - documented in the configuration file and the user documentation. + $ jupyter server --generate-config - - :ref:`Running a Notebook server ` + - `Running a Jupyter Server `_ - Related: `Configuring a language kernel `_ - to run in the Notebook server enables your server to run other languages, like R or Julia. - -.. _configure_nbclient: - -Notebook front-end client -------------------------- - -.. toctree:: - :maxdepth: 2 - - frontend_config + to run in the Jupyter Server enables your server to run other languages, like R or Julia. .. _configure_nbextensions: Notebook extensions ------------------- -- `Distributing Jupyter Extensions as Python Packages `_ -- `Extending the Notebook `_ +The Notebook frontend can be extending with JupyterLab extensions. + +See the :ref:`Frontend Extension Guide ` for more information. -:ref:`Security in Jupyter notebooks: ` Since security -policies vary from organization to organization, we encourage you to +`Security in Jupyter notebooks: `_ +Since security policies vary from organization to organization, we encourage you to consult with your security team on settings that would be best for your use cases. Our documentation offers some responsible security practices, and we recommend becoming familiar with the practices. diff --git a/docs/source/configuration.rst b/docs/source/configuration.rst new file mode 100644 index 0000000000..b2d02f9ce3 --- /dev/null +++ b/docs/source/configuration.rst @@ -0,0 +1,12 @@ +============= +Configuration +============= + +.. toctree:: + :maxdepth: 1 + :caption: Configuration + + config_overview + config + Security + extending/index.rst diff --git a/docs/source/contributor.rst b/docs/source/contributor.rst new file mode 100644 index 0000000000..844dbc5d2e --- /dev/null +++ b/docs/source/contributor.rst @@ -0,0 +1,10 @@ +========================= +Contributor Documentation +========================= + +.. toctree:: + :maxdepth: 1 + :caption: Contributor Documentation + + contributing + development_faq \ No newline at end of file diff --git a/docs/source/examples/Notebook/Custom Keyboard Shortcuts.ipynb b/docs/source/examples/Notebook/Custom Keyboard Shortcuts.ipynb index 64576268d2..9d26279408 100644 --- a/docs/source/examples/Notebook/Custom Keyboard Shortcuts.ipynb +++ b/docs/source/examples/Notebook/Custom Keyboard Shortcuts.ipynb @@ -11,129 +11,17 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Starting with Jupyter Notebook 5.0, you can customize the `command` mode shortcuts from within the Notebook Application itself. \n", + "You can customize the `command` mode shortcuts from within the Notebook Application itself. \n", "\n", - "Head to the **`Help`** menu and select the **`Edit keyboard Shortcuts`** item.\n", + "Head to the **Settings** menu and select the **Settings Editor** item.\n", "A dialog will guide you through the process of adding custom keyboard shortcuts.\n", "\n", "Keyboard shortcut set from within the Notebook Application will be persisted to your configuration file. \n", "A single action may have several shortcuts attached to it." ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Keyboard Shortcut Customization (Pre Notebook 5.0)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Starting with IPython 2.0 keyboard shortcuts in command and edit mode are fully customizable. These customizations are made using the Jupyter JavaScript API. Here is an example that makes the `r` key available for running a cell:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "%%javascript\n", - "\n", - "Jupyter.keyboard_manager.command_shortcuts.add_shortcut('r', {\n", - " help : 'run cell',\n", - " help_index : 'zz',\n", - " handler : function (event) {\n", - " IPython.notebook.execute_cell();\n", - " return false;\n", - " }}\n", - ");" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\"By default the keypress `r`, while in command mode, changes the type of the selected cell to `raw`. This shortcut is overridden by the code in the previous cell, and thus the action no longer be available via the keypress `r`.\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "There are a couple of points to mention about this API:\n", - "\n", - "* The `help_index` field is used to sort the shortcuts in the Keyboard Shortcuts help dialog. It defaults to `zz`.\n", - "* When a handler returns `false` it indicates that the event should stop propagating and the default action should not be performed. For further details about the `event` object or event handling, see the jQuery docs.\n", - "* If you don't need a `help` or `help_index` field, you can simply pass a function as the second argument to `add_shortcut`." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "%%javascript\n", - "\n", - "Jupyter.keyboard_manager.command_shortcuts.add_shortcut('r', function (event) {\n", - " IPython.notebook.execute_cell();\n", - " return false;\n", - "});" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Likewise, to remove a shortcut, use `remove_shortcut`:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "%%javascript\n", - "\n", - "Jupyter.keyboard_manager.command_shortcuts.remove_shortcut('r');" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "If you want your keyboard shortcuts to be active for all of your notebooks, put the above API calls into your `custom.js` file." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "collapsed": true - }, - "source": [ - "Of course we provide name for majority of existing action so that you do not have to re-write everything, here is for example how to bind `r` back to it's initial behavior:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "%%javascript\n", - "\n", - "Jupyter.keyboard_manager.command_shortcuts.add_shortcut('r', 'jupyter-notebook:change-cell-to-raw');" - ] } ], "metadata": { - "nbsphinx": { - "execute": "never" - }, "kernelspec": { "display_name": "Python 3", "language": "python", @@ -150,6 +38,9 @@ "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.5.2" + }, + "nbsphinx": { + "execute": "never" } }, "nbformat": 4, diff --git a/docs/source/examples/Notebook/JavaScript Notebook Extensions.ipynb b/docs/source/examples/Notebook/JavaScript Notebook Extensions.ipynb deleted file mode 100644 index 8d44100b6b..0000000000 --- a/docs/source/examples/Notebook/JavaScript Notebook Extensions.ipynb +++ /dev/null @@ -1,603 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Embracing web standards" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "One of the main reasons why we developed the current notebook web application \n", - "was to embrace the web technology. \n", - "\n", - "By being a pure web application using HTML, JavaScript, and CSS, the Notebook can get \n", - "all the web technology improvement for free. Thus, as browser support for different \n", - "media extend, the notebook web app should be able to be compatible without modification. \n", - "\n", - "This is also true with performance of the User Interface as the speed of JavaScript VM increases. " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The other advantage of using only web technology is that the code of the interface is fully accessible to the end user and is modifiable live.\n", - "Even if this task is not always easy, we strive to keep our code as accessible and reusable as possible.\n", - "This should allow us - with minimum effort - development of small extensions that customize the behavior of the web interface. " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Tampering with the Notebook application" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The first tool that is available to you and that you should be aware of are browser \"developers tool\". The exact naming can change across browser and might require the installation of extensions. But basically they can allow you to inspect/modify the DOM, and interact with the JavaScript code that runs the frontend.\n", - "\n", - " - In Chrome and Safari, Developer tools are in the menu `View > Developer > JavaScript Console` \n", - " - In Firefox you might need to install [Firebug](http://getfirebug.com/)\n", - " \n", - "Those will be your best friends to debug and try different approaches for your extensions." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Injecting JS" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Using magics" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The above tools can be tedious for editing edit long JavaScript files. Therefore we provide the `%%javascript` magic. This allows you to quickly inject JavaScript into the notebook. Still the JavaScript injected this way will not survive reloading. Hence, it is a good tool for testing and refining a script.\n", - "\n", - "You might see here and there people modifying css and injecting js into the notebook by reading file(s) and publishing them into the notebook.\n", - "Not only does this often break the flow of the notebook and make the re-execution of the notebook broken, but it also means that you need to execute those cells in the entire notebook every time you need to update the code.\n", - "\n", - "This can still be useful in some cases, like the `%autosave` magic that allows you to control the time between each save. But this can be replaced by a JavaScript dropdown menu to select the save interval." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "## you can inspect the autosave code to see what it does.\n", - "%autosave??" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### custom.js" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To inject JavaScript we provide an entry point: `custom.js` that allows the user to execute and load other resources into the notebook.\n", - "JavaScript code in `custom.js` will be executed when the notebook app starts and can then be used to customize almost anything in the UI and in the behavior of the notebook.\n", - "\n", - "`custom.js` can be found in the `~/.jupyter/custom/custom.js`. You can share your custom.js with others." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "##### Back to theory" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "from jupyter_core.paths import jupyter_config_dir\n", - "jupyter_dir = jupyter_config_dir()\n", - "jupyter_dir" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "and custom js is in " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "import os.path\n", - "custom_js_path = os.path.join(jupyter_dir, 'custom', 'custom.js')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "# my custom js\n", - "if os.path.isfile(custom_js_path):\n", - " with open(custom_js_path) as f:\n", - " print(f.read())\n", - "else:\n", - " print(\"You don't have a custom.js file\") " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that `custom.js` is meant to be modified by user. When writing a script, you can define it in a separate file and add a line of configuration into `custom.js` that will fetch and execute the file." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Warning** : even if modification of `custom.js` takes effect immediately after browser refresh (except if browser cache is aggressive), *creating* a file in `static/` directory needs a **server restart**." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise :" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - " - Create a `custom.js` in the right location with the following content:\n", - "```javascript\n", - "alert(\"hello world from custom.js\")\n", - "```\n", - "\n", - " - Restart your server and open any notebook.\n", - " - Be greeted by custom.js" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Have a look at [default custom.js](https://github.com/jupyter/notebook/blob/4.0.x/notebook/static/custom/custom.js), to see it's content and for more explanation." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### For the quick ones : " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We've seen above that you can change the autosave rate by using a magic. This is typically something I don't want to type every time, and that I don't like to embed into my workflow and documents. (readers don't care what my autosave time is). Let's build an extension that allows us to do it. " - ] - }, - { - "cell_type": "markdown", - "metadata": { - "foo": true - }, - "source": [ - "Create a dropdown element in the toolbar (DOM `Jupyter.toolbar.element`), you will need \n", - "\n", - "- `Jupyter.notebook.set_autosave_interval(milliseconds)`\n", - "- know that 1 min = 60 sec, and 1 sec = 1000 ms" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "```javascript\n", - "\n", - "var label = jQuery('