docs: def import_locations(self, baken_file):
          """Import baken data files.
  
          ``import_locations()`` returns a dictionary with keys containing the
          section title, and values consisting of a collection :class:`Baken`
          objects.
  
          It expects data files in the format used by the baken_ amateur radio
          package, which is Windows INI style files such as:
  
          .. code-block:: ini
  
              [Abeche, Chad]
              latitude=14.460000
              longitude=20.680000
              height=0.000000
  
              [GB3BUX]
              frequency=50.000
              locator=IO93BF
              power=25 TX
              antenna=2 x Turnstile
              height=460
              mode=A1A
  
          The reader uses the :mod:`configparser` module, so should be reasonably
          robust against encodings and such.  The above file processed by
          ``import_locations()`` will return the following ``dict`` object::
  
              {"Abeche, Chad": Baken(14.460, 20.680, None, None, None, 0.000,
                                     None, None, None, None, None),
               "GB3BUX": : Baken(None, None, "2 x Turnstile", None, 50.000,
                                 460.000, "IO93BF", "A1A", None, 25, None)}
  
          Args::
              baken_file (iter): Baken data to read
  
          Returns:
              dict: Named locations and their associated values
  
          .. _baken: http://www.qsl.net:80/g4klx/
          """
          self._baken_file = baken_file
          data = ConfigParser()
          if hasattr(baken_file, 'readlines'):
              data.readfp(baken_file)
          elif isinstance(baken_file, list):
              data.read(baken_file)
          elif isinstance(baken_file, basestring):
              data.readfp(open(baken_file))
          else:
              raise TypeError('Unable to handle data of type %r'
                              % type(baken_file))
          valid_locator = re.compile(r"[A-Z]{2}\d{2}[A-Z]{2}")
          for name in data.sections():
              elements = {}
              for item in ('latitude', 'longitude', 'antenna', 'direction',
                           'frequency', 'height', 'locator', 'mode', 'operator',
                           'power', 'qth'):
                  if data.has_option(name, item):
                      if item in ('antenna', 'locator', 'mode', 'power', 'qth'):
                          elements[item] = data.get(name, item)
                      elif item == 'operator':
                          elements[item] = elements[item].split(',')
                      elif item == 'direction':
                          elements[item] = data.get(name, item).split(',')
                      else:
                          try:
                              elements[item] = data.getfloat(name, item)
                          except ValueError:
                              logging.debug('Multiple frequency workaround for '
                                            '%r entry' % name)
                              elements[item] = \
                                  map(float, data.get(name, item).split(','))
                  else:
                      elements[item] = None
              if elements['latitude'] is None \
                 and not valid_locator.match(elements['locator']):
                  logging.info('Skipping %r entry, as it contains no location '
                               'data' % name)
                  continue
  
              self[name] = Baken(**elements)