Ubuntu Manpage: jupyter-qtconsole - manual page for jupyter-qtconsole 4.2.1

Provided by: jupyter-qtconsole_4.6.0-1_all

NAME

       jupyter-qtconsole - manual page for jupyter-qtconsole 4.2.1

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