docs: def _process_ddg2p_annotations(self, limit):
          """
          The ddg2p annotations associate a gene symbol to an omim disease,
          along with some HPO ids and pubs. The gene symbols come from gencode,
          which in turn come from HGNC official gene symbols.  Therefore,
          we use the HGNC source class to get the id/symbol mapping for
          use in our annotations here.
  
          According to http://www.gencodegenes.org/faq.html,
          "Gene names are usually HGNC or MGI-approved gene symbols mapped
          to the GENCODE genes by the Ensembl xref pipeline. Sometimes,
          when there is no official gene symbol, the Havana clone-based
          name is used."
  
          The kind of variation that is linked to a disease is indicated
          (LOF, GOF, CNV, etc) in the source data.
          Here, we create an anonymous variant of the specified gene of
          the indicated type (mapped to the sequence ontology (SO)).
  
          :param limit:
          :return:
  
          """
  
          line_counter = 0
          if self.graph is not None:
              graph = self.graph
          else:
              graph = self.graph
  
          # in order for this to work, we need to map the HGNC id-symbol;
          hgnc = HGNC(self.graph_type, self.are_bnodes_skolemized)
          hgnc_symbol_id_map = hgnc.get_symbol_id_map()
  
          myzip = ZipFile(
              '/'.join((self.rawdir, self.files['annot']['file'])), 'r')
  
          # use the ddg2p.txt file
          fname = 'ddg2p.txt'
  
          unmapped_omim_counter = 0
          unmapped_gene_count = 0
          with myzip.open(fname, 'r') as f:
              f = io.TextIOWrapper(f)
              reader = csv.reader(f, delimiter='\t', quotechar='\"')
              # score_means_by_measure = {}
              # strain_scores_by_measure = {}   # TODO theseare unused
              for row in reader:
                  line_counter += 1
                  if re.match(r'#', row[0]):   # skip comments
                      continue
  
                  (gencode_gene_name, mode, category, consequence, disease, omim,
                   ddg2p_id, pubmed_ids, hpo_codes) = row
  
                  hgnc_id = hgnc_symbol_id_map.get(gencode_gene_name.strip())
                  if hgnc_id is None:
                      LOG.error(
                          "Couldn't map the gene symbol %s to HGNC.",
                          gencode_gene_name)
                      unmapped_gene_count += 1
                      continue
                  # add the gene
                  self.model.addClassToGraph(hgnc_id, gencode_gene_name)
  
                  # TODO make VSLC with the variation
                  #   to associate with the disorder
                  # TODO use the Inheritance and Mutation consequence
                  #   to classify the VSLCs
  
                  allele_id = self.make_allele_by_consequence(
                      consequence, hgnc_id, gencode_gene_name)
  
                  if omim.strip() != '':
                      omim_id = 'OMIM:'+str(omim.strip())
                      # assume this is declared elsewhere in ontology
                      self.model.addClassToGraph(omim_id, None)
  
                      # ??? rel is never used
                      # if category.strip() == 'Confirmed DD gene':
                      #     rel = self.self.globaltt['has phenotype']
                      # elif category.strip() == 'Probable DD gene':
                      #    rel = self.self.globaltt['has phenotype']
                      # elif category.strip() == 'Possible DD gene':
                      #    rel = self.self.globaltt['contributes to']
                      # elif category.strip() == 'Not DD gene':
                      #    # TODO negative annotation
                      #    continue
                      assoc = G2PAssoc(graph, self.name, allele_id, omim_id)
                      # TODO 'rel' is assigned to but never used
  
                      for p in re.split(r';', pubmed_ids):
                          p = p.strip()
                          if p != '':
                              pmid = 'PMID:' + str(p)
                              r = Reference(
                                  graph, pmid, self.globaltt['journal article'])
                              r.addRefToGraph()
                              assoc.add_source(pmid)
  
                      assoc.add_association_to_graph()
                  else:
                      # these are unmapped to a disease id.
                      # note that some match OMIM disease labels
                      # but the identifiers are just not included.
                      # TODO consider mapping to OMIM or DOIDs in other ways
                      LOG.warning(
                          "No omim id on line %d\n%s", line_counter, str(row))
                      unmapped_omim_counter += 1
  
                  # TODO hpo phenotypes
                  # since the DDG2P file is not documented,
                  # I don't know what the HPO annotations are actually about
                  # are they about the gene?  the omim disease?  something else?
                  # So, we wont create associations until this is clarified
  
                  if not self.test_mode and limit is not None and line_counter > limit:
                      break
  
          myzip.close()
          LOG.warning(
              "gene-disorder associations with no omim id: %d",
              unmapped_omim_counter)
          LOG.warning("unmapped gene count: %d", unmapped_gene_count)
  
          return