code: def bind_sockets(
      port: int,
      address: Optional[str] = None,
      family: socket.AddressFamily = socket.AF_UNSPEC,
      backlog: int = _DEFAULT_BACKLOG,
      flags: Optional[int] = None,
      reuse_port: bool = False,
  ) -> List[socket.socket]:
      """Creates listening sockets bound to the given port and address.
  
      Returns a list of socket objects (multiple sockets are returned if
      the given address maps to multiple IP addresses, which is most common
      for mixed IPv4 and IPv6 use).
  
      Address may be either an IP address or hostname.  If it's a hostname,
      the server will listen on all IP addresses associated with the
      name.  Address may be an empty string or None to listen on all
      available interfaces.  Family may be set to either `socket.AF_INET`
      or `socket.AF_INET6` to restrict to IPv4 or IPv6 addresses, otherwise
      both will be used if available.
  
      The ``backlog`` argument has the same meaning as for
      `socket.listen() <socket.socket.listen>`.
  
      ``flags`` is a bitmask of AI_* flags to `~socket.getaddrinfo`, like
      ``socket.AI_PASSIVE | socket.AI_NUMERICHOST``.
  
      ``reuse_port`` option sets ``SO_REUSEPORT`` option for every socket
      in the list. If your platform doesn't support this option ValueError will
      be raised.
      """
      if reuse_port and not hasattr(socket, "SO_REUSEPORT"):
          raise ValueError("the platform doesn't support SO_REUSEPORT")
  
      sockets = []
      if address == "":
          address = None
      if not socket.has_ipv6 and family == socket.AF_UNSPEC:
          # Python can be compiled with --disable-ipv6, which causes
          # operations on AF_INET6 sockets to fail, but does not
          # automatically exclude those results from getaddrinfo
          # results.
          # http://bugs.python.org/issue16208
          family = socket.AF_INET
      if flags is None:
          flags = socket.AI_PASSIVE
      bound_port = None
      unique_addresses = set()  # type: set
      for res in sorted(
          socket.getaddrinfo(
              address, port, family, socket.SOCK_STREAM, 0, flags
          ),
          key=lambda x: x[0],
      ):
          if res in unique_addresses:
              continue
  
          unique_addresses.add(res)
  
          af, socktype, proto, canonname, sockaddr = res
          if (
              sys.platform == "darwin"
              and address == "localhost"
              and af == socket.AF_INET6
              and sockaddr[3] != 0  # type: ignore
          ):
              # Mac OS X includes a link-local address fe80::1%lo0 in the
              # getaddrinfo results for 'localhost'.  However, the firewall
              # doesn't understand that this is a local address and will
              # prompt for access (often repeatedly, due to an apparent
              # bug in its ability to remember granting access to an
              # application). Skip these addresses.
              continue
          try:
              sock = socket.socket(af, socktype, proto)
          except socket.error as e:
              if errno_from_exception(e) == errno.EAFNOSUPPORT:
                  continue
              raise
          if os.name != "nt":
              try:
                  sock.setsockopt(
                      socket.SOL_SOCKET, socket.SO_REUSEADDR, 1
                  )
              except socket.error as e:
                  if errno_from_exception(e) != errno.ENOPROTOOPT:
                      # Hurd doesn't support SO_REUSEADDR.
                      raise
          if reuse_port:
              sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
          if af == socket.AF_INET6:
              # On linux, ipv6 sockets accept ipv4 too by default,
              # but this makes it impossible to bind to both
              # 0.0.0.0 in ipv4 and :: in ipv6.  On other systems,
              # separate sockets *must* be used to listen for both ipv4
              # and ipv6.  For consistency, always disable ipv4 on our
              # ipv6 sockets and use a separate ipv4 socket when needed.
              #
              # Python 2.x on windows doesn't have IPPROTO_IPV6.
              if hasattr(socket, "IPPROTO_IPV6"):
                  sock.setsockopt(
                      socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 1
                  )
  
          # automatic port allocation with port=None
          # should bind on the same port on IPv4 and IPv6
          host, requested_port = sockaddr[:2]
          if requested_port == 0 and bound_port is not None:
              sockaddr = tuple([host, bound_port] + list(sockaddr[2:]))
  
          sock.setblocking(False)
          try:
              sock.bind(sockaddr)
          except OSError as e:
              if (
                  errno_from_exception(e) == errno.EADDRNOTAVAIL
                  and address == "localhost"
                  and sockaddr[0] == "::1"
              ):
                  # On some systems (most notably docker with default
                  # configurations), ipv6 is partially disabled:
                  # socket.has_ipv6 is true, we can create AF_INET6
                  # sockets, and getaddrinfo("localhost", ...,
                  # AF_PASSIVE) resolves to ::1, but we get an error
                  # when binding.
                  #
                  # Swallow the error, but only for this specific case.
                  # If EADDRNOTAVAIL occurs in other situations, it
                  # might be a real problem like a typo in a
                  # configuration.
                  sock.close()
                  continue
              else:
                  raise
          bound_port = sock.getsockname()[1]
          sock.listen(backlog)
          sockets.append(sock)
      return sockets
  
imports: import asyncio
  import concurrent.futures
  import errno
  import os
  import sys
  import socket
  import ssl
  import stat
  from tornado.concurrent import dummy_executor, run_on_executor
  from tornado.ioloop import IOLoop
  from tornado.util import Configurable, errno_from_exception
  from typing import List, Callable, Any, Type, Dict, Union, Tuple, Awaitable, Optional
label_desc: Use image node_id 1 for calling a global function with example usage: bind_sockets(port, address, family, backlog, flags, reuse_port) and returns: sockets