docs: def command(self, command, value=1, check=True,
                  allowable_errors=None, read_preference=ReadPreference.PRIMARY,
                  codec_options=DEFAULT_CODEC_OPTIONS, **kwargs):
          """Issue a MongoDB command.
  
          Send command `command` to the database and return the
          response. If `command` is an instance of :class:`basestring`
          (:class:`str` in python 3) then the command {`command`: `value`}
          will be sent. Otherwise, `command` must be an instance of
          :class:`dict` and will be sent as is.
  
          Any additional keyword arguments will be added to the final
          command document before it is sent.
  
          For example, a command like ``{buildinfo: 1}`` can be sent
          using:
  
          >>> db.command("buildinfo")
  
          For a command where the value matters, like ``{collstats:
          collection_name}`` we can do:
  
          >>> db.command("collstats", collection_name)
  
          For commands that take additional arguments we can use
          kwargs. So ``{filemd5: object_id, root: file_root}`` becomes:
  
          >>> db.command("filemd5", object_id, root=file_root)
  
          :Parameters:
            - `command`: document representing the command to be issued,
              or the name of the command (for simple commands only).
  
              .. note:: the order of keys in the `command` document is
                 significant (the "verb" must come first), so commands
                 which require multiple keys (e.g. `findandmodify`)
                 should use an instance of :class:`~bson.son.SON` or
                 a string and kwargs instead of a Python `dict`.
  
            - `value` (optional): value to use for the command verb when
              `command` is passed as a string
            - `check` (optional): check the response for errors, raising
              :class:`~pymongo.errors.OperationFailure` if there are any
            - `allowable_errors`: if `check` is ``True``, error messages
              in this list will be ignored by error-checking
            - `read_preference`: The read preference for this operation.
              See :mod:`~pymongo.read_preferences` for options.
            - `codec_options`: A :class:`~bson.codec_options.CodecOptions`
              instance.
            - `**kwargs` (optional): additional keyword arguments will
              be added to the command document before it is sent
  
          .. note:: :meth:`command` does **not** obey :attr:`read_preference`
             or :attr:`codec_options`. You must use the `read_preference` and
             `codec_options` parameters instead.
  
          .. versionchanged:: 3.0
             Removed the `as_class`, `fields`, `uuid_subtype`, `tag_sets`,
             and `secondary_acceptable_latency_ms` option.
             Removed `compile_re` option: PyMongo now always represents BSON
             regular expressions as :class:`~bson.regex.Regex` objects. Use
             :meth:`~bson.regex.Regex.try_compile` to attempt to convert from a
             BSON regular expression to a Python regular expression object.
             Added the `codec_options` parameter.
  
          .. versionchanged:: 2.7
             Added `compile_re` option. If set to False, PyMongo represented BSON
             regular expressions as :class:`~bson.regex.Regex` objects instead of
             attempting to compile BSON regular expressions as Python native
             regular expressions, thus preventing errors for some incompatible
             patterns, see `PYTHON-500`_.
  
          .. versionchanged:: 2.3
             Added `tag_sets` and `secondary_acceptable_latency_ms` options.
          .. versionchanged:: 2.2
             Added support for `as_class` - the class you want to use for
             the resulting documents
  
          .. _PYTHON-500: https://jira.mongodb.org/browse/PYTHON-500
  
          .. mongodoc:: commands
          """
          client = self.__client
          with client._socket_for_reads(read_preference) as (sock_info, slave_ok):
              return self._command(sock_info, command, slave_ok, value,
                                   check, allowable_errors, read_preference,
                                   codec_options, **kwargs)