docs: def get_docker(interfaces=None, cidrs=None, with_container_id=False):
      '''
      .. versionchanged:: 2017.7.8,2018.3.3
          When :conf_minion:`docker.update_mine` is set to ``False`` for a given
          minion, no mine data will be populated for that minion, and thus none
          will be returned for it.
      .. versionchanged:: 2019.2.0
          :conf_minion:`docker.update_mine` now defaults to ``False``
  
      Get all mine data for :py:func:`docker.ps <salt.modules.dockermod.ps_>` and
      run an aggregation routine. The ``interfaces`` parameter allows for
      specifying the network interfaces from which to select IP addresses. The
      ``cidrs`` parameter allows for specifying a list of subnets which the IP
      address must match.
  
      with_container_id
          Boolean, to expose container_id in the list of results
  
          .. versionadded:: 2015.8.2
  
  
      CLI Example:
  
      .. code-block:: bash
  
          salt '*' mine.get_docker
          salt '*' mine.get_docker interfaces='eth0'
          salt '*' mine.get_docker interfaces='["eth0", "eth1"]'
          salt '*' mine.get_docker cidrs='107.170.147.0/24'
          salt '*' mine.get_docker cidrs='["107.170.147.0/24", "172.17.42.0/24"]'
          salt '*' mine.get_docker interfaces='["eth0", "eth1"]' cidrs='["107.170.147.0/24", "172.17.42.0/24"]'
      '''
      # Enforce that interface and cidr are lists
      if interfaces:
          interface_ = []
          interface_.extend(interfaces if isinstance(interfaces, list) else [interfaces])
          interfaces = interface_
      if cidrs:
          cidr_ = []
          cidr_.extend(cidrs if isinstance(cidrs, list) else [cidrs])
          cidrs = cidr_
  
      # Get docker info
      cmd = 'docker.ps'
      docker_hosts = get('*', cmd)
  
      proxy_lists = {}
  
      # Process docker info
      for containers in six.itervalues(docker_hosts):
          host = containers.pop('host')
          host_ips = []
  
          # Prepare host_ips list
          if not interfaces:
              for info in six.itervalues(host['interfaces']):
                  if 'inet' in info:
                      for ip_ in info['inet']:
                          host_ips.append(ip_['address'])
          else:
              for interface in interfaces:
                  if interface in host['interfaces']:
                      if 'inet' in host['interfaces'][interface]:
                          for item in host['interfaces'][interface]['inet']:
                              host_ips.append(item['address'])
          host_ips = list(set(host_ips))
  
          # Filter out ips from host_ips with cidrs
          if cidrs:
              good_ips = []
              for cidr in cidrs:
                  for ip_ in host_ips:
                      if salt.utils.network.in_subnet(cidr, [ip_]):
                          good_ips.append(ip_)
              host_ips = list(set(good_ips))
  
          # Process each container
          for container in six.itervalues(containers):
              container_id = container['Info']['Id']
              if container['Image'] not in proxy_lists:
                  proxy_lists[container['Image']] = {}
              for dock_port in container['Ports']:
                  # IP exists only if port is exposed
                  ip_address = dock_port.get('IP')
                  # If port is 0.0.0.0, then we must get the docker host IP
                  if ip_address == '0.0.0.0':
                      for ip_ in host_ips:
                          containers = proxy_lists[container['Image']].setdefault('ipv4', {}).setdefault(dock_port['PrivatePort'], [])
                          container_network_footprint = '{0}:{1}'.format(ip_, dock_port['PublicPort'])
                          if with_container_id:
                              value = (container_network_footprint, container_id)
                          else:
                              value = container_network_footprint
                          if value not in containers:
                              containers.append(value)
                  elif ip_address:
                      containers = proxy_lists[container['Image']].setdefault('ipv4', {}).setdefault(dock_port['PrivatePort'], [])
                      container_network_footprint = '{0}:{1}'.format(dock_port['IP'], dock_port['PublicPort'])
                      if with_container_id:
                          value = (container_network_footprint, container_id)
                      else:
                          value = container_network_footprint
                      if value not in containers:
                          containers.append(value)
  
      return proxy_lists