docs: def init(self, advertise_addr=None, listen_addr='0.0.0.0:2377',
               force_new_cluster=False, default_addr_pool=None,
               subnet_size=None, **kwargs):
          """
          Initialize a new swarm on this Engine.
  
          Args:
              advertise_addr (str): Externally reachable address advertised to
                  other nodes. This can either be an address/port combination in
                  the form ``192.168.1.1:4567``, or an interface followed by a
                  port number, like ``eth0:4567``. If the port number is omitted,
                  the port number from the listen address is used.
  
                  If not specified, it will be automatically detected when
                  possible.
              listen_addr (str): Listen address used for inter-manager
                  communication, as well as determining the networking interface
                  used for the VXLAN Tunnel Endpoint (VTEP). This can either be
                  an address/port combination in the form ``192.168.1.1:4567``,
                  or an interface followed by a port number, like ``eth0:4567``.
                  If the port number is omitted, the default swarm listening port
                  is used. Default: ``0.0.0.0:2377``
              force_new_cluster (bool): Force creating a new Swarm, even if
                  already part of one. Default: False
              default_addr_pool (list of str): Default Address Pool specifies
                  default subnet pools for global scope networks. Each pool
                  should be specified as a CIDR block, like '10.0.0.0/8'.
                  Default: None
              subnet_size (int): SubnetSize specifies the subnet size of the
                  networks created from the default subnet pool. Default: None
              task_history_retention_limit (int): Maximum number of tasks
                  history stored.
              snapshot_interval (int): Number of logs entries between snapshot.
              keep_old_snapshots (int): Number of snapshots to keep beyond the
                  current snapshot.
              log_entries_for_slow_followers (int): Number of log entries to
                  keep around to sync up slow followers after a snapshot is
                  created.
              heartbeat_tick (int): Amount of ticks (in seconds) between each
                  heartbeat.
              election_tick (int): Amount of ticks (in seconds) needed without a
                  leader to trigger a new election.
              dispatcher_heartbeat_period (int):  The delay for an agent to send
                  a heartbeat to the dispatcher.
              node_cert_expiry (int): Automatic expiry for nodes certificates.
              external_ca (dict): Configuration for forwarding signing requests
                  to an external certificate authority. Use
                  ``docker.types.SwarmExternalCA``.
              name (string): Swarm's name
              labels (dict): User-defined key/value metadata.
              signing_ca_cert (str): The desired signing CA certificate for all
                  swarm node TLS leaf certificates, in PEM format.
              signing_ca_key (str): The desired signing CA key for all swarm
                  node TLS leaf certificates, in PEM format.
              ca_force_rotate (int): An integer whose purpose is to force swarm
                  to generate a new signing CA certificate and key, if none have
                  been specified.
              autolock_managers (boolean): If set, generate a key and use it to
                  lock data stored on the managers.
              log_driver (DriverConfig): The default log driver to use for tasks
                  created in the orchestrator.
  
          Returns:
              ``True`` if the request went through.
  
          Raises:
              :py:class:`docker.errors.APIError`
                  If the server returns an error.
  
          Example:
  
              >>> client.swarm.init(
                  advertise_addr='eth0', listen_addr='0.0.0.0:5000',
                  force_new_cluster=False, default_addr_pool=['10.20.0.0/16],
                  subnet_size=24, snapshot_interval=5000,
                  log_entries_for_slow_followers=1200
              )
  
          """
          init_kwargs = {
              'advertise_addr': advertise_addr,
              'listen_addr': listen_addr,
              'force_new_cluster': force_new_cluster,
              'default_addr_pool': default_addr_pool,
              'subnet_size': subnet_size
          }
          init_kwargs['swarm_spec'] = self.client.api.create_swarm_spec(**kwargs)
          self.client.api.init_swarm(**init_kwargs)
          self.reload()
          return True