docs: def unique_addresses(data=None, file_path=None):
      """
      The function to search an input string and/or file, extracting and
      counting IPv4/IPv6 addresses/networks. Summarizes ports with sub-counts.
      If both a string and file_path are provided, it will process them both.
  
      Args:
          data (:obj:`str`): The data to process.
          file_path (:obj:`str`): An optional file path to process.
  
      Returns:
          dict: The addresses/networks mapped to ports and counts:
  
          ::
  
              {
                  '1.2.3.4' (dict) - Each address or network found is a
                      dictionary:
                      {
                          'count' (int) - Total number of times seen.
                          'ports' (dict) - Mapping of port numbers as keys and
                              the number of times seen for this ip as values.
                      }
              }
  
      Raises:
          ValueError: Arguments provided are invalid.
      """
  
      if not data and not file_path:
  
          raise ValueError('No data or file path provided.')
  
      ret = {}
      base = {
          'count': 0,
          'ports': {}
      }
  
      file_data = None
      if file_path:
  
          log.debug('Opening file for unique address analysis: {0}'.format(
                  str(file_path)))
  
          f = open(str(file_path), 'r')
  
          # Read the file.
          file_data = f.read()
  
      pattern = re.compile(
          str(IP_REGEX),
          re.DOTALL
      )
  
      # Check if there is data.
      log.debug('Analyzing input/file data'.format(
                  str(file_path)))
      for input_data in [data, file_data]:
  
          if input_data:
  
              # Search for IPs.
              for match in pattern.finditer(input_data):
  
                  is_net = False
                  port = None
                  try:
  
                      found = match.group('ip')
  
                      if '.' in found and ':' in found:
  
                          split = found.split(':')
                          ip_or_net = split[0]
                          port = split[1]
  
                      elif '[' in found:
  
                          split = found.split(']:')
                          ip_or_net = split[0][1:]
                          port = split[1]
  
                      elif '/' in found:
  
                          is_net = True
                          ip_or_net = found
  
                      else:
  
                          ip_or_net = found
  
                      if is_net:
  
                          ip_obj = ip_network(ip_or_net)
  
                      else:
                          ip_obj = ip_address(ip_or_net)
  
                      obj_str = ip_obj.__str__()
  
                      if obj_str not in ret.keys():
  
                          ret[obj_str] = copy.deepcopy(base)
  
                      ret[obj_str]['count'] += 1
  
                      if port:
  
                          try:
  
                              ret[obj_str]['ports'][str(port)] += 1
  
                          except KeyError:
  
                              ret[obj_str]['ports'][str(port)] = 1
  
                  except (KeyError, ValueError):
  
                      continue
  
      return ret