Provided by: python3-ipyparallel_7.1.0-5_all bug

NAME

       ipengine - start an IPython cluster engine

DESCRIPTION

       Start an IPython engine for parallel computing.

       IPython  engines  run  in  parallel  and  perform  computations  on behalf of a client and
       controller. A controller needs to be  started  before  the  engines.  The  engine  can  be
       configured  using  command line options or using a cluster directory.  Cluster directories
       contain config, log and security files and are usually located in your  ipython  directory
       and named as "profile_name". See the `profile` and `profile-dir` options for details.

       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'.

       --mpi

              enable MPI integration

       --log-to-file

              send log output to a file

       --debug

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

       --quiet

              set log level to logging.CRITICAL (minimize logging output)

       --init

       Initialize profile with default config files.
              This is equivalent

              to running `ipython profile create <profile>` prior to startup.

       --secure

              Use HMAC digests for authentication of messages.  Setting this flag will generate a
              new UUID to use as the HMAC key.

       --no-secure

              Don't authenticate messages.

       --file=<Unicode> (IPEngineApp.url_file)

              Default: '' The full location of the file containing the connection information for
              the controller. If this is not given, the file must be in the security directory of
              the  cluster  directory.   This  location  is  resolved  using  the  `profile`   or
              `profile_dir` options.

       -c <Unicode> (IPEngineApp.startup_command)

              Default: '' specify a command to be run at startup

       -s <Unicode> (IPEngineApp.startup_script)

              Default: '' specify a script to be run at startup

       --url=<Unicode> (EngineFactory.url)

              Default: '' The 0MQ url used for registration. This sets transport, ip, and port in
              one variable. For example: url='tcp://127.0.0.1:12345' or url='epgm://*:90210'

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

              Default: '' The SSH server to use for tunneling connections to the Controller.

       --sshkey=<Unicode> (EngineFactory.sshkey)

              Default: '' The SSH private key file to  use  when  tunneling  connections  to  the
              Controller.

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

              Default:  '' The IP address for registration.  This is generally either '127.0.0.1'
              for loopback only or '*' for all interfaces.

       --transport=<Unicode> (EngineFactory.transport)

              Default: 'tcp' The 0MQ transport for  communications.   This  will  likely  be  the
              default of 'tcp', but other values include 'ipc', 'epgm', 'inproc'.

       --port=<Int> (EngineFactory.regport)

              Default: 0 The port on which the Hub listens for registration.

       --location=<Unicode> (EngineFactory.location)

              Default:  ''  The  location  (an  IP  address) of the controller.  This is used for
              disambiguating URLs, to determine whether loopback should be used to connect or the
              public address.

       --timeout=<Float> (EngineFactory.timeout)

              Default:  5.0  The  time  (in  seconds)  to  wait  for the Controller to respond to
              registration requests before giving up.

       --profile-dir=<Unicode> (ProfileDir.location)

              Default: '' Set the profile location directly. This overrides the logic used by the
              `profile` option.

       --profile=<Unicode> (BaseIPythonApplication.profile)

              Default: 'default' The IPython profile to use.

       --ipython-dir=<Unicode> (BaseIPythonApplication.ipython_dir)

              Default:  ''  The name of the IPython directory. This directory is used for logging
              configuration (through profiles), history storage,  etc.  The  default  is  usually
              $HOME/.ipython.  This option can also be specified through the environment variable
              IPYTHONDIR.

       --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.

       --config=<Unicode> (BaseIPythonApplication.extra_config_file)

              Default:  ''  Path to an extra config file to load.  If specified, load this config
              file in addition to any other IPython config.

       --work-dir=<Unicode> (BaseParallelApplication.work_dir)

              Default: '/home/joe' Set the working dir for the process.

       --log-to-file=<Bool> (BaseParallelApplication.log_to_file)

              Default: False whether to log to a file

       --clean-logs=<Bool> (BaseParallelApplication.clean_logs)

              Default: False whether to cleanup old logfiles before starting

       --log-url=<Unicode> (BaseParallelApplication.log_url)

              Default: '' The ZMQ URL of the iplogger to aggregate logging.

       --cluster-id=<Unicode> (BaseParallelApplication.cluster_id)

              Default: '' String id to add to runtime files,  to  prevent  name  collisions  when
              using multiple clusters with a single profile simultaneously.  When set, files will
              be named like: 'ipcontroller-<cluster_id>-engine.json' Since this is text  inserted
              into  filenames, typical recommendations apply: Simple character strings are ideal,
              and spaces are not recommended (but should generally work).

       --ident=<CUnicode> (Session.session)

              Default: '' The UUID identifying this session.

       --user=<Unicode> (Session.username)

              Default: 'joe' Username for the Session. Default is your system username.

       --keyfile=<Unicode> (Session.keyfile)

              Default: '' path to file containing execution key.

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

EXAMPLES

       ipengine --ip=192.168.0.1 --port=1000
              # connect to hub at ip and port

       ipengine --log-to-file --log-level=DEBUG
              # log to a file with DEBUG verbosity