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
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: