docs: def create_host_config(self, *args, **kwargs):
          """
          Create a dictionary for the ``host_config`` argument to
          :py:meth:`create_container`.
  
          Args:
              auto_remove (bool): enable auto-removal of the container on daemon
                  side when the container's process exits.
              binds (dict): Volumes to bind. See :py:meth:`create_container`
                      for more information.
              blkio_weight_device: Block IO weight (relative device weight) in
                  the form of: ``[{"Path": "device_path", "Weight": weight}]``.
              blkio_weight: Block IO weight (relative weight), accepts a weight
                  value between 10 and 1000.
              cap_add (list of str): Add kernel capabilities. For example,
                  ``["SYS_ADMIN", "MKNOD"]``.
              cap_drop (list of str): Drop kernel capabilities.
              cpu_period (int): The length of a CPU period in microseconds.
              cpu_quota (int): Microseconds of CPU time that the container can
                  get in a CPU period.
              cpu_shares (int): CPU shares (relative weight).
              cpuset_cpus (str): CPUs in which to allow execution (``0-3``,
                  ``0,1``).
              cpuset_mems (str): Memory nodes (MEMs) in which to allow execution
                  (``0-3``, ``0,1``). Only effective on NUMA systems.
              device_cgroup_rules (:py:class:`list`): A list of cgroup rules to
                  apply to the container.
              device_read_bps: Limit read rate (bytes per second) from a device
                  in the form of: `[{"Path": "device_path", "Rate": rate}]`
              device_read_iops: Limit read rate (IO per second) from a device.
              device_write_bps: Limit write rate (bytes per second) from a
                  device.
              device_write_iops: Limit write rate (IO per second) from a device.
              devices (:py:class:`list`): Expose host devices to the container,
                  as a list of strings in the form
                  ``<path_on_host>:<path_in_container>:<cgroup_permissions>``.
  
                  For example, ``/dev/sda:/dev/xvda:rwm`` allows the container
                  to have read-write access to the host's ``/dev/sda`` via a
                  node named ``/dev/xvda`` inside the container.
              dns (:py:class:`list`): Set custom DNS servers.
              dns_opt (:py:class:`list`): Additional options to be added to the
                  container's ``resolv.conf`` file
              dns_search (:py:class:`list`): DNS search domains.
              extra_hosts (dict): Additional hostnames to resolve inside the
                  container, as a mapping of hostname to IP address.
              group_add (:py:class:`list`): List of additional group names and/or
                  IDs that the container process will run as.
              init (bool): Run an init inside the container that forwards
                  signals and reaps processes
              init_path (str): Path to the docker-init binary
              ipc_mode (str): Set the IPC mode for the container.
              isolation (str): Isolation technology to use. Default: ``None``.
              links (dict): Mapping of links using the
                  ``{'container': 'alias'}`` format. The alias is optional.
                  Containers declared in this dict will be linked to the new
                  container using the provided alias. Default: ``None``.
              log_config (LogConfig): Logging configuration
              lxc_conf (dict): LXC config.
              mem_limit (float or str): Memory limit. Accepts float values
                  (which represent the memory limit of the created container in
                  bytes) or a string with a units identification char
                  (``100000b``, ``1000k``, ``128m``, ``1g``). If a string is
                  specified without a units character, bytes are assumed as an
              mem_swappiness (int): Tune a container's memory swappiness
                  behavior. Accepts number between 0 and 100.
              memswap_limit (str or int): Maximum amount of memory + swap a
                  container is allowed to consume.
              mounts (:py:class:`list`): Specification for mounts to be added to
                  the container. More powerful alternative to ``binds``. Each
                  item in the list is expected to be a
                  :py:class:`docker.types.Mount` object.
              network_mode (str): One of:
  
                  - ``bridge`` Create a new network stack for the container on
                    the bridge network.
                  - ``none`` No networking for this container.
                  - ``container:<name|id>`` Reuse another container's network
                    stack.
                  - ``host`` Use the host network stack.
              oom_kill_disable (bool): Whether to disable OOM killer.
              oom_score_adj (int): An integer value containing the score given
                  to the container in order to tune OOM killer preferences.
              pid_mode (str): If set to ``host``, use the host PID namespace
                  inside the container.
              pids_limit (int): Tune a container's pids limit. Set ``-1`` for
                  unlimited.
              port_bindings (dict): See :py:meth:`create_container`
                      for more information.
              privileged (bool): Give extended privileges to this container.
              publish_all_ports (bool): Publish all ports to the host.
              read_only (bool): Mount the container's root filesystem as read
                  only.
              restart_policy (dict): Restart the container when it exits.
                  Configured as a dictionary with keys:
  
                  - ``Name`` One of ``on-failure``, or ``always``.
                  - ``MaximumRetryCount`` Number of times to restart the
                    container on failure.
              security_opt (:py:class:`list`): A list of string values to
                  customize labels for MLS systems, such as SELinux.
              shm_size (str or int): Size of /dev/shm (e.g. ``1G``).
              storage_opt (dict): Storage driver options per container as a
                  key-value mapping.
              sysctls (dict): Kernel parameters to set in the container.
              tmpfs (dict): Temporary filesystems to mount, as a dictionary
                  mapping a path inside the container to options for that path.
  
                  For example:
  
                  .. code-block:: python
  
                      {
                          '/mnt/vol2': '',
                          '/mnt/vol1': 'size=3G,uid=1000'
                      }
  
              ulimits (:py:class:`list`): Ulimits to set inside the container,
                  as a list of :py:class:`docker.types.Ulimit` instances.
              userns_mode (str): Sets the user namespace mode for the container
                  when user namespace remapping option is enabled. Supported
                  values are: ``host``
              uts_mode (str): Sets the UTS namespace mode for the container.
                  Supported values are: ``host``
              volumes_from (:py:class:`list`): List of container names or IDs to
                  get volumes from.
              runtime (str): Runtime to use with this container.
  
  
          Returns:
              (dict) A dictionary which can be passed to the ``host_config``
              argument to :py:meth:`create_container`.
  
          Example:
  
              >>> cli.create_host_config(privileged=True, cap_drop=['MKNOD'],
                                         volumes_from=['nostalgic_newton'])
              {'CapDrop': ['MKNOD'], 'LxcConf': None, 'Privileged': True,
               'VolumesFrom': ['nostalgic_newton'], 'PublishAllPorts': False}
  
  """
          if not kwargs:
              kwargs = {}
          if 'version' in kwargs:
              raise TypeError(
                  "create_host_config() got an unexpected "
                  "keyword argument 'version'"
              )
          kwargs['version'] = self._version
          return HostConfig(*args, **kwargs)