@classmethod
def from_DataFrame(cls, df, name, description, refgen, rawtype=None,
    normalize=True, norm_method=None, quantile=False, quality_control=True,
    **kwargs):
    """ 
            Creates an Expr instance from a pandas DataFrame. Expects that the
            DataFrame index is gene names and the column names are accessions
            (i.e. experiments).  This is the preferred method for creating an
            Expr instance, in other words, other classmethods transform their
            data so they can call this method.

            Parameters
            ----------
            df : pandas.DataFrame
                a DataFrame containing expression data. Assumes index is the
                genes and columns is the accessions (experiment names)
            name : str
                A short name to refer to from the camoco dataset API.
            description : str
                A short description for the dataset
            refgen : camoco.RefGen
                A Camoco refgen object which describes the reference
                genome referred to by the genes in the dataset. This
                is cross references during import so we can pull information
                about genes we are interested in during analysis.
            rawtype : str (one of: 'RNASEQ' or 'MICROARRAY')
                Specifies the fundamental datatype used to measure expression.
                During importation of the raw expression data, this value is
                used to make decisions in converting data to log-space.
            normalize : bool (Default: True)
                Specifies whether or not to normalize the data so raw
                expression values lie within a log space. This is best
                practices for generating interpretable expression analyses. See
                Expr._normalize method for more information.  info.
            norm_method : None OR python function
                If rawtype is NOT RNASEQ or MICROARRY AND normalize is still
                True, the normalization method for the raw expression values
                needs to be passed in. This is for extreme customization
                situations.
            quantile : bool (Default : False)
                Specifies whether or not to perform quantile normalization on
                import.
            quality_control : bool (Default: True)
                A flag which specifies whether or not to perform QC. Parameters
                for QC are passed in using the **kwargs arguments. For default
                parameters and options see Expr._quality_control.
            **kwargs : key value pairs
                additional parameters passed to subsequent methods.
                See arguments for Expr._normalize(), Expr._quality_control()

            Returns
            -------
            An Expr instance

        """
    self = cls.create(name, description, refgen)
    self._reset(raw=True)
    if rawtype is None:
        raise TypeError("raw_type must be one of ['RNASEQ', 'MICROARRAY']")
    self._global('rawtype', rawtype)
    self.log('Importing Raw Expression Values')
    self._update_values(df, 'Raw' + rawtype, raw=True)
    if quality_control:
        self.log('Performing Quality Control on genes')
        self._quality_control(**kwargs)
        assert self.anynancol() == False
    else:
        self.log('Skipping Quality Control!')
    if normalize:
        self.log('Performing Raw Expression Normalization')
        self._normalize(**kwargs)
        assert self.anynancol() == False
    if quantile:
        self.log('Performing Quantile Gene Normalization')
        self._quantile()
        assert self.anynancol() == False
    self.log('Filtering refgen: {}', refgen.name)
    self._set_refgen(refgen, filter=True)
    return self
