docs: def cmd(self,
              tgt,
              fun,
              arg=(),
              timeout=None,
              tgt_type='glob',
              ret='',
              jid='',
              full_return=False,
              kwarg=None,
              **kwargs):
          '''
          Synchronously execute a command on targeted minions
  
          The cmd method will execute and wait for the timeout period for all
          minions to reply, then it will return all minion data at once.
  
          .. code-block:: python
  
              >>> import salt.client
              >>> local = salt.client.LocalClient()
              >>> local.cmd('*', 'cmd.run', ['whoami'])
              {'jerry': 'root'}
  
          With extra keyword arguments for the command function to be run:
  
          .. code-block:: python
  
              local.cmd('*', 'test.arg', ['arg1', 'arg2'], kwarg={'foo': 'bar'})
  
          Compound commands can be used for multiple executions in a single
          publish. Function names and function arguments are provided in separate
          lists but the index values must correlate and an empty list must be
          used if no arguments are required.
  
          .. code-block:: python
  
              >>> local.cmd('*', [
                      'grains.items',
                      'sys.doc',
                      'cmd.run',
                  ],
                  [
                      [],
                      [],
                      ['uptime'],
                  ])
  
          :param tgt: Which minions to target for the execution. Default is shell
              glob. Modified by the ``tgt_type`` option.
          :type tgt: string or list
  
          :param fun: The module and function to call on the specified minions of
              the form ``module.function``. For example ``test.ping`` or
              ``grains.items``.
  
              Compound commands
                  Multiple functions may be called in a single publish by
                  passing a list of commands. This can dramatically lower
                  overhead and speed up the application communicating with Salt.
  
                  This requires that the ``arg`` param is a list of lists. The
                  ``fun`` list and the ``arg`` list must correlate by index
                  meaning a function that does not take arguments must still have
                  a corresponding empty list at the expected index.
          :type fun: string or list of strings
  
          :param arg: A list of arguments to pass to the remote function. If the
              function takes no arguments ``arg`` may be omitted except when
              executing a compound command.
          :type arg: list or list-of-lists
  
          :param timeout: Seconds to wait after the last minion returns but
              before all minions return.
  
          :param tgt_type: The type of ``tgt``. Allowed values:
  
              * ``glob`` - Bash glob completion - Default
              * ``pcre`` - Perl style regular expression
              * ``list`` - Python list of hosts
              * ``grain`` - Match based on a grain comparison
              * ``grain_pcre`` - Grain comparison with a regex
              * ``pillar`` - Pillar data comparison
              * ``pillar_pcre`` - Pillar data comparison with a regex
              * ``nodegroup`` - Match on nodegroup
              * ``range`` - Use a Range server for matching
              * ``compound`` - Pass a compound match string
              * ``ipcidr`` - Match based on Subnet (CIDR notation) or IPv4 address.
  
              .. versionchanged:: 2017.7.0
                  Renamed from ``expr_form`` to ``tgt_type``
  
          :param ret: The returner to use. The value passed can be single
              returner, or a comma delimited list of returners to call in order
              on the minions
  
          :param kwarg: A dictionary with keyword arguments for the function.
  
          :param full_return: Output the job return only (default) or the full
              return including exit code and other job metadata.
  
          :param kwargs: Optional keyword arguments.
              Authentication credentials may be passed when using
              :conf_master:`external_auth`.
  
              For example: ``local.cmd('*', 'test.ping', username='saltdev',
              password='saltdev', eauth='pam')``.
              Or: ``local.cmd('*', 'test.ping',
              token='5871821ea51754fdcea8153c1c745433')``
  
          :returns: A dictionary with the result of the execution, keyed by
              minion ID. A compound command will return a sub-dictionary keyed by
              function name.
          '''
          was_listening = self.event.cpub
  
          try:
              pub_data = self.run_job(tgt,
                                      fun,
                                      arg,
                                      tgt_type,
                                      ret,
                                      timeout,
                                      jid,
                                      kwarg=kwarg,
                                      listen=True,
                                      **kwargs)
  
              if not pub_data:
                  return pub_data
  
              ret = {}
              for fn_ret in self.get_cli_event_returns(
                      pub_data['jid'],
                      pub_data['minions'],
                      self._get_timeout(timeout),
                      tgt,
                      tgt_type,
                      **kwargs):
  
                  if fn_ret:
                      for mid, data in six.iteritems(fn_ret):
                          ret[mid] = (data if full_return
                                  else data.get('ret', {}))
  
              for failed in list(set(pub_data['minions']) - set(ret)):
                  ret[failed] = False
              return ret
          finally:
              if not was_listening:
                  self.event.close_pub()