Ubuntu Manpage: jupyter-qtconsole - Launch a Console-style application using Qt.

Provided by: jupyter-qtconsole_5.5.2-1_all

NAME

       jupyter-qtconsole - Launch a Console-style application using Qt.

DESCRIPTION

       The Jupyter QtConsole.

       This  launches  a  Console-style  application using Qt.  It is not a full console, in that
       launched terminal subprocesses will not be able to accept input.

       Options -------

       Arguments that take values are actually convenience aliases to full  Configurables,  whose
       aliases  are  listed  on  the  help  line. For more information on full configurables, see
       '--help-all'.

       --generate-config

              generate default config file

       --debug

              set log level to logging.DEBUG (maximize logging output)

       --confirm-exit

              Set to display confirmation dialog on exit. You can always use 'exit' or 'quit', to
              force  a  direct  exit without any confirmation. This can also be set in the config
              file by setting `c.JupyterConsoleApp.confirm_exit`.

       --plain

              Disable rich text support.

       -y

              Answer yes to any questions instead of prompting.

       --banner

              Display a banner upon starting the QtConsole.

       --no-banner

              Don't display a banner upon starting the QtConsole.

       --existing

              Connect to an existing kernel. If no argument specified, guess most recent

       --no-confirm-exit

              Don't prompt the user when exiting. This will terminate the kernel if it  is  owned
              by the frontend, and leave it alive if it is external.  This can also be set in the
              config file by setting `c.JupyterConsoleApp.confirm_exit`.

       --style=<Unicode> (JupyterWidget.syntax_style)

              Default: '' If  not  empty,  use  this  Pygments  style  for  syntax  highlighting.
              Otherwise, the style sheet is queried for Pygments style information.

       --shell=<Int> (JupyterConsoleApp.shell_port)

              Default: 0 set the shell (ROUTER) port [default: random]

       --log-level=<Enum> (Application.log_level)

              Default:  30  Choices:  (0,  10,  20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR',
              'CRITICAL') Set the log level by value or name.

       --kernel=<Unicode> (JupyterConsoleApp.kernel_name)

              Default: 'python' The name of the default kernel to start.

       --iopub=<Int> (JupyterConsoleApp.iopub_port)

              Default: 0 set the iopub (PUB) port [default: random]

       --gui-completion=<Enum> (ConsoleWidget.gui_completion)

              Default: 'ncurses' Choices: ['plain', 'droplist', 'ncurses'] The type of  completer
              to use. Valid values are: 'plain'   : Show the available completion as a text list

              Below the editing area.

              'droplist': Show the completion in a drop down list navigable

              by the arrow keys, and from which you can select completion by pressing Return.

              'ncurses' : Show the completion as a text list which is navigable by

              `tab` and arrow keys.

       --config=<Unicode> (JupyterApp.config_file)

              Default: '' Full path of a config file.

       -f <Unicode> (JupyterConsoleApp.connection_file)

              Default:   ''   JSON   file   in   which   to   store   connection  info  [default:
              kernel-<pid>.json] This file will contain the IP,  ports,  and  authentication  key
              needed  to connect clients to this kernel. By default, this file will be created in
              the security dir of the current profile, but can be specified by absolute path.

       --stylesheet=<Unicode> (JupyterQtConsoleApp.stylesheet)

              Default: '' path to a custom CSS stylesheet

       --hb=<Int> (JupyterConsoleApp.hb_port)

              Default: 0 set the heartbeat port [default: random]

       --ssh=<Unicode> (JupyterConsoleApp.sshserver)

              Default: '' The SSH server to use to connect to the kernel.

       --editor=<Unicode> (JupyterWidget.editor)

              Default: '' A command for invoking a system text editor. If the string  contains  a
              {filename}  format  specifier,  it  will  be  used. Otherwise, the filename will be
              appended to the end the command.

       --stdin=<Int> (JupyterConsoleApp.stdin_port)

              Default: 0 set the stdin (ROUTER) port [default: random]

       --ip=<Unicode> (JupyterConsoleApp.ip)

              Default: '' Set the kernel's IP address [default localhost]. If the IP  address  is
              something  other  than  localhost,  then Consoles on other machines will be able to
              connect to the Kernel, so be careful!

       --transport=<CaselessStrEnum> (JupyterConsoleApp.transport)

              Default: 'tcp' Choices: ['tcp', 'ipc']

       --existing=<CUnicode> (JupyterConsoleApp.existing)

              Default: '' Connect to an already running kernel

       --paging=<Enum> (ConsoleWidget.paging)

              Default: 'inside' Choices: ['inside', 'hsplit',  'vsplit',  'custom',  'none']  The
              type of paging to use. Valid values are: 'inside'

              The widget pages like a traditional terminal.

              'hsplit'

              When  paging  is requested, the widget is split horizontally. The top pane contains
              the console, and the bottom pane contains the paged text.

              'vsplit'

              Similar to 'hsplit', except that a vertical splitter is used.

              'custom'

              No action is taken by the widget  beyond  emitting  a  'custom_page_requested(str)'
              signal.

              'none'

              The text is written directly to the console.

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

       Examples --------

       jupyter qtconsole
              # start the qtconsole

NAME

DESCRIPTION

SEE ALSO