docs: def alternative_parser(self, family_file):
          """
          Parse alternative formatted family info
          
          This parses a information with more than six columns. 
          For alternative information header comlumn must exist and each row 
          must have the same amount of columns as the header. 
          First six columns must be the same as in the ped format.
          
          Arguments:
              family_info (iterator): An iterator with family info
          """
          
          alternative_header = None
          
          for line in family_file:
              if line.startswith('#'):
                  alternative_header = line[1:].rstrip().split('\t')
                  self.logger.info("Alternative header found: {0}".format(line))
              elif line.strip():
                  if not alternative_header:
                      raise WrongLineFormat(message="Alternative ped files must have "\
                                          "headers! Please add a header line.")
                  
                  splitted_line = line.rstrip().split('\t')
                  if len(splitted_line) < 6:
                      # Try to split the line on another symbol:
                      splitted_line = line.rstrip().split()
                  try:
                      self.check_line_length(splitted_line, len(alternative_header))
                  except SyntaxError as e:
                      self.logger.error('Number of entrys differ from header.')
                      self.logger.error("Header:\n{0}".format('\t'.join(alternative_header)))
                      self.logger.error("Ped Line:\n{0}".format('\t'.join(splitted_line)))
                      self.logger.error("Length of Header: {0}. Length of "\
                                        "Ped line: {1}".format(
                                            len(alternative_header), 
                                            len(splitted_line))
                                      )
                      raise e
                  
                  if len(line) > 1:
                      
                      sample_dict = dict(zip(self.header, splitted_line[:6]))
                      
                      family_id = sample_dict['family_id']
                      
                      all_info = dict(zip(alternative_header, splitted_line))
                      
                      if sample_dict['family_id'] not in self.families:
                          self.families[family_id] = Family(family_id, {})
                      
                      sample_dict['genetic_models'] = all_info.get('InheritanceModel', None)
                      # Try other header naming:
                      if not sample_dict['genetic_models']:
                          sample_dict['genetic_models'] = all_info.get('Inheritance_model', None)
                          
                      sample_dict['proband'] = all_info.get('Proband', '.')
                      sample_dict['consultand'] = all_info.get('Consultand', '.')
                      sample_dict['alive'] = all_info.get('Alive', '.')
                      
                      ind_object = self.get_individual(**sample_dict)
                      
                      self.individuals[ind_object.individual_id] = ind_object
                      self.families[ind_object.family].add_individual(ind_object)
                      
                      if sample_dict['genetic_models']:
                          for model in self.get_models(sample_dict['genetic_models']):
                              self.families[ind_object.family].models_of_inheritance.add(model)
                      
                      # If requested, we try is it is an id in the CMMS format:
                      sample_id_parts = ind_object.individual_id.split('-')
                      if self.cmms_check and (len(sample_id_parts) == 3):
                          # If the id follow the CMMS convention we can
                          # do a sanity check
                          if self.check_cmms_id(ind_object.individual_id):
                              self.logger.debug("Id follows CMMS convention: {0}".format(
                                  ind_object.individual_id
                              ))
                              self.logger.debug("Checking CMMS id affections status")
                              try:
                                  self.check_cmms_affection_status(ind_object)
                              except WrongAffectionStatus as e:
                                  self.logger.error("Wrong affection status for"\
                                  " {0}. Affection status can be in"\
                                  " {1}".format(e.cmms_id, e.valid_statuses))
                                  raise e
                              except WrongPhenotype as e:
                                  self.logger.error("Affection status for {0} "\
                                  "({1}) disagrees with phenotype ({2})".format(
                                      e.cmms_id, e.phenotype, e.affection_status
                                  ))
                                  raise e
                              
                              try:
                                  self.check_cmms_gender(ind_object)
                              except WrongGender as e:
                                  self.logger.error("Gender code for id {0}"\
                                  "({1}) disagrees with sex:{2}".format(
                                      e.cmms_id, e.sex_code, e.sex
                                  ))
                                  raise e
                                  
                      for i in range(6, len(splitted_line)):
                          ind_object.extra_info[alternative_header[i]] = splitted_line[i]