JupyerLab CLI command overview

JupyterLab has three different modes of running:

  • Core mode (--core-mode): in this mode JupyterLab will run using the JavaScript assets contained in the installed jupyterlab Python package. In core mode, no extensions are enabled.

  • Dev mode (--dev-mode): uses the unpublished local JavaScript packages in the dev_mode folder. In this case JupyterLab will show a red stripe at the top of the page. It can only be used if JupyterLab is installed as pip install -e ..

  • App mode: JupyterLab allows multiple JupyterLab “applications” to be created by the user with different combinations of extensions. The --app-dir can be used to set a directory for different applications. The default application path can be found using jupyter lab path.

JupyterLab has a several CLI commands.

This sections gives an overview of all CLI commands present.

JupyterLab Subcommands

!jupyter-lab -h
/home/maikel/anaconda3/envs/mikedev/lib/python3.8/site-packages/jupyter_server/transutils.py:13: FutureWarning: The alias `_()` will be deprecated. Use `_i18n()` instead.
  warnings.warn(warn_msg, FutureWarning)
JupyterLab - An extensible computational environment for Jupyter.

This launches a Tornado based HTML Server that serves up an HTML5/Javascript
JupyterLab client.

JupyterLab has three different modes of running:

* Core mode (`--core-mode`): in this mode JupyterLab will run using the JavaScript
  assets contained in the installed `jupyterlab` Python package. In core mode, no
  extensions are enabled. This is the default in a stable JupyterLab release if you
  have no extensions installed.
* Dev mode (`--dev-mode`): uses the unpublished local JavaScript packages in the
  `dev_mode` folder.  In this case JupyterLab will show a red stripe at the top of
  the page.  It can only be used if JupyterLab is installed as `pip install -e .`.
* App mode: JupyterLab allows multiple JupyterLab "applications" to be
  created by the user with different combinations of extensions. The `--app-dir` can
  be used to set a directory for different applications. The default application
  path can be found using `jupyter lab path`.

Subcommands
===========
Subcommands are launched as `lab cmd [args]`. For information on using
subcommand 'cmd', do: `lab cmd -h`.

build
clean
path
paths
workspace
workspaces

Options
=======
The options below are convenience aliases to configurable class-options,
as listed in the "Equivalent to" description-line of the aliases.
To see all configurable class-options for some <cmd>, use:
    <cmd> --help-all

--debug
    Set debug level for the extension and underlying server applications.
    Equivalent to: [--ServerApp.log_level=DEBUG --ExtensionApp.log_level=DEBUG]
--generate-config
    generate default config file
    Equivalent to: [--JupyterApp.generate_config=True]
-y
    Answer yes to any questions instead of prompting.
    Equivalent to: [--JupyterApp.answer_yes=True]
--allow-root
    Allow the server to be run from root user.
    Equivalent to: [--ServerApp.allow_root=True]
--no-browser
    Prevent the opening of the default url in the browser.
    Equivalent to: [--ServerApp.open_browser=False --ExtensionApp.open_browser=False]
--autoreload
    Autoreload the webapp
        Enable reloading of the tornado webapp and all imported Python packages
        when any changes are made to any Python src files in server or
        extensions.
    Equivalent to: [--ServerApp.autoreload=True]
--script
    DEPRECATED, IGNORED
    Equivalent to: [--FileContentsManager.save_script=True]
--no-script
    DEPRECATED, IGNORED
    Equivalent to: [--FileContentsManager.save_script=False]
--core-mode
    Start the app in core mode.
    Equivalent to: [--LabApp.core_mode=True]
--dev-mode
    Start the app in dev mode for running from source.
    Equivalent to: [--LabApp.dev_mode=True]
--watch
    Start the app in watch mode.
    Equivalent to: [--LabApp.watch=True]
--expose-app-in-browser
    Expose the global app instance to browser via window.jupyterlab.
    Equivalent to: [--LabApp.expose_app_in_browser=True]
--extensions-in-dev-mode
    Load prebuilt extensions in dev-mode.
    Equivalent to: [--LabApp.extensions_in_dev_mode=True]
--log-level=<Enum>
    Set the log level by value or name.
    Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL']
    Default: 30
    Equivalent to: [--Application.log_level]
--config=<Unicode>
    Full path of a config file.
    Default: ''
    Equivalent to: [--JupyterApp.config_file]
--ip=<Unicode>
    The IP address the Jupyter server will listen on.
    Default: 'localhost'
    Equivalent to: [--ServerApp.ip]
--port=<Int>
    The port the Jupyter server will listen on.
    Default: 8888
    Equivalent to: [--ServerApp.port]
--port-retries=<Int>
    The number of additional ports to try if the specified port is not
    available.
    Default: 50
    Equivalent to: [--ServerApp.port_retries]
--keyfile=<Unicode>
    The full path to a private key file for usage with SSL/TLS.
    Default: ''
    Equivalent to: [--ServerApp.keyfile]
--certfile=<Unicode>
    The full path to an SSL/TLS certificate file.
    Default: ''
    Equivalent to: [--ServerApp.certfile]
--client-ca=<Unicode>
    The full path to a certificate authority certificate for SSL/TLS client
    authentication.
    Default: ''
    Equivalent to: [--ServerApp.client_ca]
--notebook-dir=<Unicode>
    The directory to use for notebooks and kernels.
    Default: ''
    Equivalent to: [--ServerApp.root_dir]
--browser=<Unicode>
    Specify what command to use to invoke a web
                          browser when starting the server. If not specified, the
                          default browser will be determined by the `webbrowser`
                          standard library module, which allows setting of the
                          BROWSER environment variable to override it.
    Default: ''
    Equivalent to: [--ServerApp.browser]
--pylab=<Unicode>
    DISABLED: use %pylab or %matplotlib in the notebook to enable matplotlib.
    Default: 'disabled'
    Equivalent to: [--ServerApp.pylab]
--watch=<Bool>
    Whether to serve the app in watch mode
    Default: False
    Equivalent to: [--LabApp.watch]
--app-dir=<Unicode>
    The app directory to launch JupyterLab from.
    Default: None
    Equivalent to: [--LabApp.app_dir]

Examples
--------

    jupyter lab                       # start JupyterLab
            jupyter lab --dev-mode            # start JupyterLab in development mode, with no extensions
            jupyter lab --core-mode           # start JupyterLab in core mode, with no extensions
            jupyter lab --app-dir=~/myjupyterlabapp # start JupyterLab with a particular set of extensions
            jupyter lab --certfile=mycert.pem # use SSL/TLS certificate

To see all available configurables, use `--help-all`.

JupyterLab CLI commands with all options

!jupyter-lab --help-all 
/home/maikel/anaconda3/envs/mikedev/lib/python3.8/site-packages/jupyter_server/transutils.py:13: FutureWarning: The alias `_()` will be deprecated. Use `_i18n()` instead.
  warnings.warn(warn_msg, FutureWarning)
JupyterLab - An extensible computational environment for Jupyter.

This launches a Tornado based HTML Server that serves up an HTML5/Javascript
JupyterLab client.

JupyterLab has three different modes of running:

* Core mode (`--core-mode`): in this mode JupyterLab will run using the JavaScript
  assets contained in the installed `jupyterlab` Python package. In core mode, no
  extensions are enabled. This is the default in a stable JupyterLab release if you
  have no extensions installed.
* Dev mode (`--dev-mode`): uses the unpublished local JavaScript packages in the
  `dev_mode` folder.  In this case JupyterLab will show a red stripe at the top of
  the page.  It can only be used if JupyterLab is installed as `pip install -e .`.
* App mode: JupyterLab allows multiple JupyterLab "applications" to be
  created by the user with different combinations of extensions. The `--app-dir` can
  be used to set a directory for different applications. The default application
  path can be found using `jupyter lab path`.

Subcommands
===========
Subcommands are launched as `lab cmd [args]`. For information on using
subcommand 'cmd', do: `lab cmd -h`.

build
clean
path
paths
workspace
workspaces

Options
=======
The options below are convenience aliases to configurable class-options,
as listed in the "Equivalent to" description-line of the aliases.
To see all configurable class-options for some <cmd>, use:
    <cmd> --help-all

--debug
    Set debug level for the extension and underlying server applications.
    Equivalent to: [--ServerApp.log_level=DEBUG --ExtensionApp.log_level=DEBUG]
--generate-config
    generate default config file
    Equivalent to: [--JupyterApp.generate_config=True]
-y
    Answer yes to any questions instead of prompting.
    Equivalent to: [--JupyterApp.answer_yes=True]
--allow-root
    Allow the server to be run from root user.
    Equivalent to: [--ServerApp.allow_root=True]
--no-browser
    Prevent the opening of the default url in the browser.
    Equivalent to: [--ServerApp.open_browser=False --ExtensionApp.open_browser=False]
--autoreload
    Autoreload the webapp
        Enable reloading of the tornado webapp and all imported Python packages
        when any changes are made to any Python src files in server or
        extensions.
    Equivalent to: [--ServerApp.autoreload=True]
--script
    DEPRECATED, IGNORED
    Equivalent to: [--FileContentsManager.save_script=True]
--no-script
    DEPRECATED, IGNORED
    Equivalent to: [--FileContentsManager.save_script=False]
--core-mode
    Start the app in core mode.
    Equivalent to: [--LabApp.core_mode=True]
--dev-mode
    Start the app in dev mode for running from source.
    Equivalent to: [--LabApp.dev_mode=True]
--watch
    Start the app in watch mode.
    Equivalent to: [--LabApp.watch=True]
--expose-app-in-browser
    Expose the global app instance to browser via window.jupyterlab.
    Equivalent to: [--LabApp.expose_app_in_browser=True]
--extensions-in-dev-mode
    Load prebuilt extensions in dev-mode.
    Equivalent to: [--LabApp.extensions_in_dev_mode=True]
--log-level=<Enum>
    Set the log level by value or name.
    Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL']
    Default: 30
    Equivalent to: [--Application.log_level]
--config=<Unicode>
    Full path of a config file.
    Default: ''
    Equivalent to: [--JupyterApp.config_file]
--ip=<Unicode>
    The IP address the Jupyter server will listen on.
    Default: 'localhost'
    Equivalent to: [--ServerApp.ip]
--port=<Int>
    The port the Jupyter server will listen on.
    Default: 8888
    Equivalent to: [--ServerApp.port]
--port-retries=<Int>
    The number of additional ports to try if the specified port is not
    available.
    Default: 50
    Equivalent to: [--ServerApp.port_retries]
--keyfile=<Unicode>
    The full path to a private key file for usage with SSL/TLS.
    Default: ''
    Equivalent to: [--ServerApp.keyfile]
--certfile=<Unicode>
    The full path to an SSL/TLS certificate file.
    Default: ''
    Equivalent to: [--ServerApp.certfile]
--client-ca=<Unicode>
    The full path to a certificate authority certificate for SSL/TLS client
    authentication.
    Default: ''
    Equivalent to: [--ServerApp.client_ca]
--notebook-dir=<Unicode>
    The directory to use for notebooks and kernels.
    Default: ''
    Equivalent to: [--ServerApp.root_dir]
--browser=<Unicode>
    Specify what command to use to invoke a web
                          browser when starting the server. If not specified, the
                          default browser will be determined by the `webbrowser`
                          standard library module, which allows setting of the
                          BROWSER environment variable to override it.
    Default: ''
    Equivalent to: [--ServerApp.browser]
--pylab=<Unicode>
    DISABLED: use %pylab or %matplotlib in the notebook to enable matplotlib.
    Default: 'disabled'
    Equivalent to: [--ServerApp.pylab]
--watch=<Bool>
    Whether to serve the app in watch mode
    Default: False
    Equivalent to: [--LabApp.watch]
--app-dir=<Unicode>
    The app directory to launch JupyterLab from.
    Default: None
    Equivalent to: [--LabApp.app_dir]

Class options
=============
The command-line option below sets the respective configurable class-parameter:
    --Class.parameter=value
This line is evaluated in Python, so simple expressions are allowed.
For instance, to set `C.a=[0,1,2]`, you may type this:
    --C.a='range(3)'

Application(SingletonConfigurable) options
------------------------------------------
--Application.log_datefmt=<Unicode>
    The date format used by logging formatters for %(asctime)s
    Default: '%Y-%m-%d %H:%M:%S'
--Application.log_format=<Unicode>
    The Logging format template
    Default: '[%(name)s]%(highlevel)s %(message)s'
--Application.log_level=<Enum>
    Set the log level by value or name.
    Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL']
    Default: 30
--Application.show_config=<Bool>
    Instead of starting the Application, dump configuration to stdout
    Default: False
--Application.show_config_json=<Bool>
    Instead of starting the Application, dump configuration to stdout (as JSON)
    Default: False

JupyterApp(Application) options
-------------------------------
--JupyterApp.answer_yes=<Bool>
    Answer yes to any prompts.
    Default: False
--JupyterApp.config_file=<Unicode>
    Full path of a config file.
    Default: ''
--JupyterApp.config_file_name=<Unicode>
    Specify a config file to load.
    Default: ''
--JupyterApp.generate_config=<Bool>
    Generate default config file.
    Default: False
--JupyterApp.log_datefmt=<Unicode>
    The date format used by logging formatters for %(asctime)s
    Default: '%Y-%m-%d %H:%M:%S'
--JupyterApp.log_format=<Unicode>
    The Logging format template
    Default: '[%(name)s]%(highlevel)s %(message)s'
--JupyterApp.log_level=<Enum>
    Set the log level by value or name.
    Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL']
    Default: 30
--JupyterApp.show_config=<Bool>
    Instead of starting the Application, dump configuration to stdout
    Default: False
--JupyterApp.show_config_json=<Bool>
    Instead of starting the Application, dump configuration to stdout (as JSON)
    Default: False

ExtensionApp(JupyterApp) options
--------------------------------
--ExtensionApp.answer_yes=<Bool>
    Answer yes to any prompts.
    Default: False
--ExtensionApp.config_file=<Unicode>
    Full path of a config file.
    Default: ''
--ExtensionApp.config_file_name=<Unicode>
    Specify a config file to load.
    Default: ''
--ExtensionApp.default_url=<Unicode>
    Default: ''
--ExtensionApp.generate_config=<Bool>
    Generate default config file.
    Default: False
--ExtensionApp.handlers=<list-item-1>...
    Handlers appended to the server.
    Default: []
--ExtensionApp.log_datefmt=<Unicode>
    The date format used by logging formatters for %(asctime)s
    Default: '%Y-%m-%d %H:%M:%S'
--ExtensionApp.log_format=<Unicode>
    The Logging format template
    Default: '[%(name)s]%(highlevel)s %(message)s'
--ExtensionApp.log_level=<Enum>
    Set the log level by value or name.
    Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL']
    Default: 30
--ExtensionApp.open_browser=<Bool>
    Whether to open in a browser after starting.
            The specific browser used is platform dependent and
            determined by the python standard library `webbrowser`
            module, unless it is overridden using the --browser
            (ServerApp.browser) configuration option.
    Default: False
--ExtensionApp.settings=<key-1>=<value-1>...
    Settings that will passed to the server.
    Default: {}
--ExtensionApp.show_config=<Bool>
    Instead of starting the Application, dump configuration to stdout
    Default: False
--ExtensionApp.show_config_json=<Bool>
    Instead of starting the Application, dump configuration to stdout (as JSON)
    Default: False
--ExtensionApp.static_paths=<list-item-1>...
    paths to search for serving static files.
            This allows adding javascript/css to be available from the notebook server machine,
            or overriding individual files in the IPython
    Default: []
--ExtensionApp.static_url_prefix=<Unicode>
    Url where the static assets for the extension are served.
    Default: ''
--ExtensionApp.template_paths=<list-item-1>...
    Paths to search for serving jinja templates.
            Can be used to override templates from notebook.templates.
    Default: []

LabServerApp(ExtensionAppJinjaMixin, LabConfig, ExtensionApp) options
---------------------------------------------------------------------
--LabServerApp.allowed_extensions_uris=<Unicode>
    "A list of comma-separated URIs to get the allowed extensions list
    .. versionchanged:: 2.0.0
        `LabServerApp.whitetlist_uris` renamed to `allowed_extensions_uris`
    Default: ''
--LabServerApp.answer_yes=<Bool>
    Answer yes to any prompts.
    Default: False
--LabServerApp.blacklist_uris=<Unicode>
    Deprecated, use `LabServerApp.blocked_extensions_uris`
    Default: ''
--LabServerApp.blocked_extensions_uris=<Unicode>
    A list of comma-separated URIs to get the blocked extensions list
    .. versionchanged:: 2.0.0
        `LabServerApp.blacklist_uris` renamed to `blocked_extensions_uris`
    Default: ''
--LabServerApp.config_file=<Unicode>
    Full path of a config file.
    Default: ''
--LabServerApp.config_file_name=<Unicode>
    Specify a config file to load.
    Default: ''
--LabServerApp.generate_config=<Bool>
    Generate default config file.
    Default: False
--LabServerApp.handlers=<list-item-1>...
    Handlers appended to the server.
    Default: []
--LabServerApp.jinja2_options=<key-1>=<value-1>...
    Options to pass to the jinja2 environment for this
    Default: {}
--LabServerApp.listings_refresh_seconds=<Int>
    The interval delay in seconds to refresh the lists
    Default: 3600
--LabServerApp.listings_request_options=<key-1>=<value-1>...
    The optional kwargs to use for the listings HTTP requests             as
    described on https://2.python-requests.org/en/v2.7.0/api/#requests.request
    Default: {}
--LabServerApp.log_datefmt=<Unicode>
    The date format used by logging formatters for %(asctime)s
    Default: '%Y-%m-%d %H:%M:%S'
--LabServerApp.log_format=<Unicode>
    The Logging format template
    Default: '[%(name)s]%(highlevel)s %(message)s'
--LabServerApp.log_level=<Enum>
    Set the log level by value or name.
    Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL']
    Default: 30
--LabServerApp.open_browser=<Bool>
    Whether to open in a browser after starting.
            The specific browser used is platform dependent and
            determined by the python standard library `webbrowser`
            module, unless it is overridden using the --browser
            (ServerApp.browser) configuration option.
    Default: False
--LabServerApp.settings=<key-1>=<value-1>...
    Settings that will passed to the server.
    Default: {}
--LabServerApp.show_config=<Bool>
    Instead of starting the Application, dump configuration to stdout
    Default: False
--LabServerApp.show_config_json=<Bool>
    Instead of starting the Application, dump configuration to stdout (as JSON)
    Default: False
--LabServerApp.static_paths=<list-item-1>...
    paths to search for serving static files.
            This allows adding javascript/css to be available from the notebook server machine,
            or overriding individual files in the IPython
    Default: []
--LabServerApp.static_url_prefix=<Unicode>
    Url where the static assets for the extension are served.
    Default: ''
--LabServerApp.template_paths=<list-item-1>...
    Paths to search for serving jinja templates.
            Can be used to override templates from notebook.templates.
    Default: []
--LabServerApp.whitelist_uris=<Unicode>
    A list of comma-separated URIs to get the whitelist
    Default: ''

LabApp(NBClassicConfigShimMixin, LabServerApp) options
------------------------------------------------------
--LabApp.allowed_extensions_uris=<Unicode>
    "A list of comma-separated URIs to get the allowed extensions list
    .. versionchanged:: 2.0.0
        `LabServerApp.whitetlist_uris` renamed to `allowed_extensions_uris`
    Default: ''
--LabApp.answer_yes=<Bool>
    Answer yes to any prompts.
    Default: False
--LabApp.app_dir=<Unicode>
    The app directory to launch JupyterLab from.
    Default: None
--LabApp.blacklist_uris=<Unicode>
    Deprecated, use `LabServerApp.blocked_extensions_uris`
    Default: ''
--LabApp.blocked_extensions_uris=<Unicode>
    A list of comma-separated URIs to get the blocked extensions list
    .. versionchanged:: 2.0.0
        `LabServerApp.blacklist_uris` renamed to `blocked_extensions_uris`
    Default: ''
--LabApp.config_file=<Unicode>
    Full path of a config file.
    Default: ''
--LabApp.config_file_name=<Unicode>
    Specify a config file to load.
    Default: ''
--LabApp.core_mode=<Bool>
    Whether to start the app in core mode. In this mode, JupyterLab
            will run using the JavaScript assets that are within the installed
            JupyterLab Python package. In core mode, third party extensions are disabled.
            The `--dev-mode` flag is an alias to this to be used when the Python package
            itself is installed in development mode (`pip install -e .`).
    Default: False
--LabApp.default_url=<Unicode>
    The default URL to redirect to from `/`
    Default: '/lab'
--LabApp.dev_mode=<Bool>
    Whether to start the app in dev mode. Uses the unpublished local
            JavaScript packages in the `dev_mode` folder.  In this case JupyterLab will
            show a red stripe at the top of the page.  It can only be used if JupyterLab
            is installed as `pip install -e .`.
    Default: False
--LabApp.expose_app_in_browser=<Bool>
    Whether to expose the global app instance to browser via window.jupyterlab
    Default: False
--LabApp.extensions_in_dev_mode=<Bool>
    Whether to load prebuilt extensions in dev mode. This may be
            useful to run and test prebuilt extensions in development installs of
            JupyterLab. APIs in a JupyterLab development install may be
            incompatible with published packages, so prebuilt extensions compiled
            against published packages may not work correctly.
    Default: False
--LabApp.generate_config=<Bool>
    Generate default config file.
    Default: False
--LabApp.handlers=<list-item-1>...
    Handlers appended to the server.
    Default: []
--LabApp.jinja2_options=<key-1>=<value-1>...
    Options to pass to the jinja2 environment for this
    Default: {}
--LabApp.listings_refresh_seconds=<Int>
    The interval delay in seconds to refresh the lists
    Default: 3600
--LabApp.listings_request_options=<key-1>=<value-1>...
    The optional kwargs to use for the listings HTTP requests             as
    described on https://2.python-requests.org/en/v2.7.0/api/#requests.request
    Default: {}
--LabApp.log_datefmt=<Unicode>
    The date format used by logging formatters for %(asctime)s
    Default: '%Y-%m-%d %H:%M:%S'
--LabApp.log_format=<Unicode>
    The Logging format template
    Default: '[%(name)s]%(highlevel)s %(message)s'
--LabApp.log_level=<Enum>
    Set the log level by value or name.
    Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL']
    Default: 30
--LabApp.open_browser=<Bool>
    Whether to open in a browser after starting.
            The specific browser used is platform dependent and
            determined by the python standard library `webbrowser`
            module, unless it is overridden using the --browser
            (ServerApp.browser) configuration option.
    Default: False
--LabApp.override_static_url=<Unicode>
    The override url for static lab assets, typically a CDN.
    Default: ''
--LabApp.override_theme_url=<Unicode>
    The override url for static lab theme assets, typically a CDN.
    Default: ''
--LabApp.settings=<key-1>=<value-1>...
    Settings that will passed to the server.
    Default: {}
--LabApp.show_config=<Bool>
    Instead of starting the Application, dump configuration to stdout
    Default: False
--LabApp.show_config_json=<Bool>
    Instead of starting the Application, dump configuration to stdout (as JSON)
    Default: False
--LabApp.static_paths=<list-item-1>...
    paths to search for serving static files.
            This allows adding javascript/css to be available from the notebook server machine,
            or overriding individual files in the IPython
    Default: []
--LabApp.static_url_prefix=<Unicode>
    Url where the static assets for the extension are served.
    Default: ''
--LabApp.template_paths=<list-item-1>...
    Paths to search for serving jinja templates.
            Can be used to override templates from notebook.templates.
    Default: []
--LabApp.user_settings_dir=<Unicode>
    The directory for user settings.
    Default: '/home/maikel/.jupyter/lab/user-settings'
--LabApp.watch=<Bool>
    Whether to serve the app in watch mode
    Default: False
--LabApp.whitelist_uris=<Unicode>
    A list of comma-separated URIs to get the whitelist
    Default: ''
--LabApp.workspaces_dir=<Unicode>
    The directory for workspaces
    Default: '/home/maikel/.jupyter/lab/workspaces'

ServerApp(JupyterApp) options
-----------------------------
--ServerApp.allow_credentials=<Bool>
    Set the Access-Control-Allow-Credentials: true header
    Default: False
--ServerApp.allow_origin=<Unicode>
    Set the Access-Control-Allow-Origin header
            Use '*' to allow any origin to access your server.
            Takes precedence over allow_origin_pat.
    Default: ''
--ServerApp.allow_origin_pat=<Unicode>
    Use a regular expression for the Access-Control-Allow-Origin header
            Requests from an origin matching the expression will get replies
    with:
                Access-Control-Allow-Origin: origin
            where `origin` is the origin of the request.
            Ignored if allow_origin is set.
    Default: ''
--ServerApp.allow_password_change=<Bool>
    Allow password to be changed at login for the Jupyter server.
                        While loggin in with a token, the Jupyter server UI will give the opportunity to
                        the user to enter a new password at the same time that will replace
                        the token login mechanism.
                        This can be set to false to prevent changing password
    from the UI/API.
    Default: True
--ServerApp.allow_remote_access=<Bool>
    Allow requests where the Host header doesn't point to a local server
           By default, requests get a 403 forbidden response if the 'Host' header
           shows that the browser thinks it's on a non-local domain.
           Setting this option to True disables this check.
           This protects against 'DNS rebinding' attacks, where a remote web server
           serves you a page and then changes its DNS to send later requests to a
           local IP, bypassing same-origin checks.
           Local IP addresses (such as 127.0.0.1 and ::1) are allowed as local,
           along with hostnames configured in local_hostnames.
    Default: False
--ServerApp.allow_root=<Bool>
    Whether to allow the user to run the server as root.
    Default: False
--ServerApp.answer_yes=<Bool>
    Answer yes to any prompts.
    Default: False
--ServerApp.authenticate_prometheus=<Bool>
    "
            Require authentication to access prometheus metrics.
    Default: True
--ServerApp.autoreload=<Bool>
    Reload the webapp when changes are made to any Python src files.
    Default: False
--ServerApp.base_url=<Unicode>
    The base URL for the Jupyter server.
                           Leading and trailing slashes can be omitted,
                           and will automatically be added.
    Default: '/'
--ServerApp.browser=<Unicode>
    Specify what command to use to invoke a web
                          browser when starting the server. If not specified, the
                          default browser will be determined by the `webbrowser`
                          standard library module, which allows setting of the
                          BROWSER environment variable to override it.
    Default: ''
--ServerApp.certfile=<Unicode>
    The full path to an SSL/TLS certificate file.
    Default: ''
--ServerApp.client_ca=<Unicode>
    The full path to a certificate authority certificate for SSL/TLS client
    authentication.
    Default: ''
--ServerApp.config_file=<Unicode>
    Full path of a config file.
    Default: ''
--ServerApp.config_file_name=<Unicode>
    Specify a config file to load.
    Default: ''
--ServerApp.config_manager_class=<Type>
    The config manager class to use
    Default: 'jupyter_server.services.config.manager.ConfigManager'
--ServerApp.contents_manager_class=<TypeFromClasses>
    The content manager class to use.
    Default: 'jupyter_server.services.contents.largefilemanager.LargeFileM...
--ServerApp.cookie_options=<key-1>=<value-1>...
    Extra keyword arguments to pass to `set_secure_cookie`. See tornado's
    set_secure_cookie docs for details.
    Default: {}
--ServerApp.cookie_secret=<Bytes>
    The random bytes used to secure cookies.
            By default this is a new random number every time you start the server.
            Set it to a value in a config file to enable logins to persist across server sessions.
            Note: Cookie secrets should be kept private, do not share config files with
            cookie_secret stored in plaintext (you can read the value from a file).
    Default: b''
--ServerApp.cookie_secret_file=<Unicode>
    The file where the cookie secret is stored.
    Default: ''
--ServerApp.custom_display_url=<Unicode>
    Override URL shown to users.
            Replace actual URL, including protocol, address, port and base URL,
            with the given value when displaying URL to the users. Do not change
            the actual connection URL. If authentication token is enabled, the
            token is added to the custom URL automatically.
            This option is intended to be used when the URL to display to the user
            cannot be determined reliably by the Jupyter server (proxified
            or containerized setups for example).
    Default: ''
--ServerApp.default_url=<Unicode>
    The default URL to redirect to from `/`
    Default: '/'
--ServerApp.disable_check_xsrf=<Bool>
    Disable cross-site-request-forgery protection
            Jupyter notebook 4.3.1 introduces protection from cross-site request forgeries,
            requiring API requests to either:
            - originate from pages served by this server (validated with XSRF cookie and token), or
            - authenticate with a token
            Some anonymous compute resources still desire the ability to run code,
            completely without authentication.
            These services can disable all authentication and security checks,
            with the full knowledge of what that implies.
    Default: False
--ServerApp.extra_services=<list-item-1>...
    handlers that should be loaded at higher priority than the default services
    Default: []
--ServerApp.extra_static_paths=<list-item-1>...
    Extra paths to search for serving static files.
            This allows adding javascript/css to be available from the Jupyter server machine,
            or overriding individual files in the IPython
    Default: []
--ServerApp.extra_template_paths=<list-item-1>...
    Extra paths to search for serving jinja templates.
            Can be used to override templates from jupyter_server.templates.
    Default: []
--ServerApp.file_to_run=<Unicode>
    Open the named file when the application is launched.
    Default: ''
--ServerApp.file_url_prefix=<Unicode>
    The URL prefix where files are opened directly.
    Default: 'notebooks'
--ServerApp.generate_config=<Bool>
    Generate default config file.
    Default: False
--ServerApp.get_secure_cookie_kwargs=<key-1>=<value-1>...
    Extra keyword arguments to pass to `get_secure_cookie`. See tornado's
    get_secure_cookie docs for details.
    Default: {}
--ServerApp.iopub_data_rate_limit=<Float>
    (bytes/sec)
            Maximum rate at which stream output can be sent on iopub before they are
            limited.
    Default: 1000000
--ServerApp.iopub_msg_rate_limit=<Float>
    (msgs/sec)
            Maximum rate at which messages can be sent on iopub before they are
            limited.
    Default: 1000
--ServerApp.ip=<Unicode>
    The IP address the Jupyter server will listen on.
    Default: 'localhost'
--ServerApp.jinja_environment_options=<key-1>=<value-1>...
    Supply extra arguments that will be passed to Jinja environment.
    Default: {}
--ServerApp.jinja_template_vars=<key-1>=<value-1>...
    Extra variables to supply to jinja templates when rendering.
    Default: {}
--ServerApp.jpserver_extensions=<key-1>=<value-1>...
    Dict of Python modules to load as notebook server extensions.Entry values
    can be used to enable and disable the loading ofthe extensions. The
    extensions will be loaded in alphabetical order.
    Default: {}
--ServerApp.kernel_manager_class=<Type>
    The kernel manager class to use.
    Default: 'jupyter_server.services.kernels.kernelmanager.AsyncMappingKe...
--ServerApp.kernel_spec_manager_class=<Type>
    The kernel spec manager class to use. Should be a subclass of
    `jupyter_client.kernelspec.KernelSpecManager`.
    The Api of KernelSpecManager is provisional and might change without warning
    between this version of Jupyter and the next stable one.
    Default: 'jupyter_client.kernelspec.KernelSpecManager'
--ServerApp.keyfile=<Unicode>
    The full path to a private key file for usage with SSL/TLS.
    Default: ''
--ServerApp.local_hostnames=<list-item-1>...
    Hostnames to allow as local when allow_remote_access is False.
           Local IP addresses (such as 127.0.0.1 and ::1) are automatically accepted
           as local as well.
    Default: ['localhost']
--ServerApp.log_datefmt=<Unicode>
    The date format used by logging formatters for %(asctime)s
    Default: '%Y-%m-%d %H:%M:%S'
--ServerApp.log_format=<Unicode>
    The Logging format template
    Default: '[%(name)s]%(highlevel)s %(message)s'
--ServerApp.log_level=<Enum>
    Set the log level by value or name.
    Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL']
    Default: 30
--ServerApp.login_handler_class=<Type>
    The login handler class to use.
    Default: 'jupyter_server.auth.login.LoginHandler'
--ServerApp.logout_handler_class=<Type>
    The logout handler class to use.
    Default: 'jupyter_server.auth.logout.LogoutHandler'
--ServerApp.max_body_size=<Int>
    Sets the maximum allowed size of the client request body, specified in the
    Content-Length request header field. If the size in a request exceeds the
    configured value, a malformed HTTP message is returned to the client.
    Note: max_body_size is applied even in streaming mode.
    Default: 536870912
--ServerApp.max_buffer_size=<Int>
    Gets or sets the maximum amount of memory, in bytes, that is allocated for
    use by the buffer manager.
    Default: 536870912
--ServerApp.min_open_files_limit=<Int>
    Gets or sets a lower bound on the open file handles process resource limit.
    This may need to be increased if you run into an OSError: [Errno 24] Too
    many open files. This is not applicable when running on Windows.
    Default: 0
--ServerApp.notebook_dir=<Unicode>
    DEPRECATED, use root_dir.
    Default: ''
--ServerApp.open_browser=<Bool>
    Whether to open in a browser after starting.
                            The specific browser used is platform dependent and
                            determined by the python standard library `webbrowser`
                            module, unless it is overridden using the --browser
                            (ServerApp.browser) configuration option.
    Default: False
--ServerApp.password=<Unicode>
    Hashed password to use for web authentication.
                          To generate, type in a python/IPython shell:
                            from jupyter_server.auth import passwd; passwd()
                          The string should be of the form type:salt:hashed-
    password.
    Default: ''
--ServerApp.password_required=<Bool>
    Forces users to use a password for the Jupyter server.
                          This is useful in a multi user environment, for instance when
                          everybody in the LAN can access each other's machine through ssh.
                          In such a case, serving on localhost is not secure since
                          any user can connect to the Jupyter server via ssh.
    Default: False
--ServerApp.port=<Int>
    The port the Jupyter server will listen on.
    Default: 8888
--ServerApp.port_retries=<Int>
    The number of additional ports to try if the specified port is not
    available.
    Default: 50
--ServerApp.pylab=<Unicode>
    DISABLED: use %pylab or %matplotlib in the notebook to enable matplotlib.
    Default: 'disabled'
--ServerApp.quit_button=<Bool>
    If True, display controls to shut down the Jupyter server, such as menu
    items or buttons.
    Default: True
--ServerApp.rate_limit_window=<Float>
    (sec) Time window used to
            check the message and data rate limits.
    Default: 3
--ServerApp.reraise_server_extension_failures=<Bool>
    Reraise exceptions encountered loading server extensions?
    Default: False
--ServerApp.root_dir=<Unicode>
    The directory to use for notebooks and kernels.
    Default: ''
--ServerApp.session_manager_class=<Type>
    The session manager class to use.
    Default: 'jupyter_server.services.sessions.sessionmanager.SessionManager'
--ServerApp.show_config=<Bool>
    Instead of starting the Application, dump configuration to stdout
    Default: False
--ServerApp.show_config_json=<Bool>
    Instead of starting the Application, dump configuration to stdout (as JSON)
    Default: False
--ServerApp.shutdown_no_activity_timeout=<Int>
    Shut down the server after N seconds with no kernels or terminals running
    and no activity. This can be used together with culling idle kernels
    (MappingKernelManager.cull_idle_timeout) to shutdown the Jupyter server when
    it's not in use. This is not precisely timed: it may shut down up to a
    minute later. 0 (the default) disables this automatic shutdown.
    Default: 0
--ServerApp.ssl_options=<key-1>=<value-1>...
    Supply SSL options for the tornado HTTPServer.
                See the tornado docs for details.
    Default: {}
--ServerApp.terminado_settings=<key-1>=<value-1>...
    Supply overrides for terminado. Currently only supports "shell_command".
    Default: {}
--ServerApp.terminals_enabled=<Bool>
    Set to False to disable terminals.
             This does *not* make the server more secure by itself.
             Anything the user can in a terminal, they can also do in a notebook.
             Terminals may also be automatically disabled if the terminado package
             is not available.
    Default: True
--ServerApp.token=<Unicode>
    Token used for authenticating first-time connections to the server.
            When no password is enabled,
            the default is to generate a new, random token.
            Setting to an empty string disables authentication altogether, which
    is NOT RECOMMENDED.
    Default: '<generated>'
--ServerApp.tornado_settings=<key-1>=<value-1>...
    Supply overrides for the tornado.web.Application that the Jupyter server
    uses.
    Default: {}
--ServerApp.trust_xheaders=<Bool>
    Whether to trust or not X-Scheme/X-Forwarded-Proto and X-Real-
    Ip/X-Forwarded-For headerssent by the upstream reverse proxy. Necessary if
    the proxy handles SSL
    Default: False
--ServerApp.use_redirect_file=<Bool>
    Disable launching browser by redirect file
         For versions of notebook > 5.7.2, a security feature measure was added that
         prevented the authentication token used to launch the browser from being visible.
         This feature makes it difficult for other users on a multi-user system from
         running code in your Jupyter session as you.
         However, some environments (like Windows Subsystem for Linux (WSL) and Chromebooks),
         launching a browser using a redirect file can lead the browser failing to load.
         This is because of the difference in file structures/paths between the runtime and
         the browser.
         Disabling this setting to False will disable this behavior, allowing the browser
         to launch by using a URL and visible token (as before).
    Default: True
--ServerApp.webbrowser_open_new=<Int>
    Specify where to open the server on startup. This is the
            `new` argument passed to the standard library method `webbrowser.open`.
            The behaviour is not guaranteed, but depends on browser support. Valid
            values are:
             - 2 opens a new tab,
             - 1 opens a new window,
             - 0 opens in an existing window.
            See the `webbrowser.open` documentation for details.
    Default: 2
--ServerApp.websocket_compression_options=<Any>
    Set the tornado compression options for websocket connections.
    This value will be returned from
    :meth:`WebSocketHandler.get_compression_options`. None (default) will
    disable compression. A dict (even an empty one) will enable compression.
    See the tornado docs for WebSocketHandler.get_compression_options for
    details.
    Default: None
--ServerApp.websocket_url=<Unicode>
    The base URL for websockets,
            if it differs from the HTTP server (hint: it almost certainly doesn't).
            Should be in the form of an HTTP origin: ws[s]://hostname[:port]
    Default: ''

Examples
--------

    jupyter lab                       # start JupyterLab
            jupyter lab --dev-mode            # start JupyterLab in development mode, with no extensions
            jupyter lab --core-mode           # start JupyterLab in core mode, with no extensions
            jupyter lab --app-dir=~/myjupyterlabapp # start JupyterLab with a particular set of extensions
            jupyter lab --certfile=mycert.pem # use SSL/TLS certificate