docs: def _process_phenotype(self, limit):
          """
          Get the phenotypes, and declare the classes.
          If the "observable" is "unspecified", then we assign the phenotype to
          the "cvalue" id; otherwise we convert the phenotype into a
          uberpheno-style identifier, simply based on the anatomical part that's
          affected...that is listed as the observable_id, concatenated with
          the literal "PHENOTYPE"
  
          Note that some of the phenotypes no not have a dbxref to a FBcv;
          for these cases it will make a node with an anonymous node with an
          internal id like,  "_fbcvtermkey100920PHENOTYPE".  This is awkward,
          but not sure how else to construct identifiers.
          Maybe they should be fed back into Upheno and then leveraged by FB?
  
          Note that assay_id is the same for all current items,
          so we do nothing with this.
          :param limit:
          :return:
  
          """
  
          if self.test_mode:
              graph = self.testgraph
          else:
              graph = self.graph
          model = Model(graph)
          raw = '/'.join((self.rawdir, 'phenotype'))
          LOG.info("processing phenotype")
  
          line_counter = 0
  
          with open(raw, 'r') as f:
              filereader = csv.reader(f, delimiter='\t', quotechar='\"')
              f.readline()  # read the header row; skip
              for line in filereader:
                  (phenotype_id, uniquename, observable_id, attr_id, value,
                   cvalue_id, assay_id) = line
  
                  # 8505	unspecified
                  # 20142	mesothoracic leg disc | somatic clone 87719 60468  60468 60468
                  # 8507	sex comb | ectopic 88877 60468  60468 60468
                  # 8508	tarsal segment	83664 60468  60468 60468
                  # 18404	oocyte | oogenesis stage S9	86769 60468  60468 60468
                  # for now make these as phenotypic classes
                  # will need to dbxref at some point
                  phenotype_key = phenotype_id
                  phenotype_id = None
                  phenotype_internal_id = self._makeInternalIdentifier(
                      'phenotype', phenotype_key)
                  phenotype_label = None
                  self.label_hash[phenotype_internal_id] = uniquename
                  cvterm_id = None
                  if observable_id != '' and int(observable_id) == 60468:
                      # undefined - typically these are already phenotypes
                      if cvalue_id in self.idhash['cvterm']:
                          cvterm_id = self.idhash['cvterm'][cvalue_id]
                          phenotype_id = self.idhash['cvterm'][cvalue_id]
                  elif observable_id in self.idhash['cvterm']:
                      # observations to anatomical classes
                      cvterm_id = self.idhash['cvterm'][observable_id]
                      phenotype_id = self.idhash['cvterm'][observable_id] + 'PHENOTYPE'
                      if cvterm_id is not None and cvterm_id in self.label_hash:
                          phenotype_label = self.label_hash[cvterm_id]
                          phenotype_label += ' phenotype'
                          self.label_hash[phenotype_id] = phenotype_label
                      else:
                          LOG.info('cvtermid=%s not in label_hash', cvterm_id)
  
                  else:
                      LOG.info(
                          "No observable id or label for %s: %s",
                          phenotype_key, uniquename)
  
                  # TODO store this composite phenotype in some way
                  # as a proper class definition?
                  self.idhash['phenotype'][phenotype_key] = phenotype_id
  
                  # assay_id is currently only "undefined" key=60468
  
                  if not self.test_mode and\
                          limit is not None and line_counter > limit:
                      pass
                  else:
                      if phenotype_id is not None:
                          # assume that these fit into the phenotypic uberpheno
                          # elsewhere
                          model.addClassToGraph(phenotype_id, phenotype_label)
                          line_counter += 1
  
          return