docs: def _process_morbidmap(self, limit):
          """
          This will process the morbidmap file to get the links between
          omim genes and diseases. Here, we create anonymous nodes for some
          variant loci that are variants of the gene that causes the disease.
          Triples created:
          <some_anonymous_variant_locus>
              is_allele_of
                      <omim_gene_id>
          <some_anonymous_variant_locus> causes condition <omim_disease_id>
          <assoc> hasSubject <some_anonymous_variant_locus>
          <assoc> hasObject <omim_disease_id>
          <assoc> hasPredicate <causes condition>
          <assoc> DC:evidence <eco_id>
          :param limit:
          :return:
          """
          if self.test_mode:
              graph = self.testgraph
          else:
              graph = self.graph
          line_counter = 0
          assoc_count = 0
          src_key = 'morbidmap'
          col = self.files[src_key]['columns']
          raw = '/'.join((self.rawdir, self.files[src_key]['file']))
          with open(raw) as reader:
              line = reader.readline()  # Copyright
              line = reader.readline()  # Generated: 2016-04-11
              line = reader.readline()  # EOF for field spec
              line = reader.readline().strip()  # columns header
              line_counter = 4
              row = line.split('\t')  # includes funky leading octothorpe
              if row != col:  # assert
                  LOG.error('Expected  %s to have columns: %s', raw, col)
                  LOG.error('But Found %s to have columns: %s', raw, row)
                  raise AssertionError('Incomming data headers have changed.')
  
              for line in reader:
                  line_counter += 1
                  line = line.strip()
                  # since there are comments at the end of the file as well,
                  if line[0] == '#':
                      continue
                  row = line.split('\t')
                  if len(row) != len(col):
                      LOG.warning(
                          'Unexpected input on line: %i  got: %s', line_counter, row)
                      continue
  
                  disorder = row[col.index('# Phenotype')]
                  gene_symbols = row[col.index('Gene Symbols')]
                  gene_num = row[col.index('MIM Number')]
                  # loc = row[col.index('Cyto Location')]
  
                  # LOG.info("morbidmap disorder:  %s", disorder)  # too verbose
  
                  # disorder = disorder label , number (mapping key)
                  # 3-M syndrome 1, 273750 (3)|CUL7, 3M1|609577|6p21.1
  
                  # but note that for those diseases where they are genomic loci
                  # (not genes though), the omim id is only listed as the gene
                  # Alopecia areata 1 (2)|AA1|104000|18p11.3-p11.2
                  # when there's a gene and disease
  
                  disorder_match = self.disorder_regex.match(disorder)
                  nogene_match = self.nogene_regex.match(disorder)
  
                  if disorder_match is not None:
                      disorder_parts = disorder_match.groups()
                      (disorder_label, disorder_num, phene_key) = disorder_parts
  
                      if self.test_mode and (
                              int(disorder_num) not in self.test_ids or
                              int(gene_num) not in self.test_ids):
                          continue
                      assoc_count += 1
                      gene_symbols = gene_symbols.split(', ')
                      gene_id = 'OMIM:' + str(gene_num)
                      self._make_pheno_assoc(
                          graph, gene_id, disorder_num, disorder_label, phene_key)
                  elif nogene_match is not None:
                      # this is a case where the disorder
                      # a blended gene/phenotype
                      # we lookup the NCBIGene feature and make the association
                      (disorder_label, phene_key) = nogene_match.groups()
                      disorder_num = gene_num
                      # make what's in the gene column the disease
                      disorder_id = 'OMIM:' + str(disorder_num)
                      if self.test_mode and int(disorder_num) not in self.test_ids:
                          continue
                      if disorder_id in self.omim_ncbigene_idmap:
                          # get the gene ids
                          gene_ids = self.omim_ncbigene_idmap[disorder_id]
                          if gene_ids is None:
                              continue
                          for gene_num in gene_ids:
                              # TODO add gene filter for testMode and NCBIGenes
                              gene_id = 'NCBIGene:' + str(gene_num).strip()
                              assoc_count += 1
                              self._make_pheno_assoc(
                                  graph, gene_id, disorder_num, disorder_label, phene_key)
                      else:
                          # we can create an anonymous feature
                          # to house this thing for example, 158900
                          feature_id = self._make_anonymous_feature(gene_num)
                          assoc_count += 1
                          self._make_pheno_assoc(
                              graph, feature_id, disorder_num, disorder_label, phene_key)
  
                          LOG.info(
                              "We don't have an NCBIGene feature id to link %s with %s",
                              disorder_id, disorder_label)
  
                      if self.test_mode and gene_num not in self.test_ids:
                          continue
  
                  else:
                      LOG.warning(
                          "There are misformatted rows %i:%s", line_counter, line)
                  if not self.test_mode and limit is not None and line_counter > limit:
                      break
              LOG.info("Added %d G2P associations", assoc_count)