Py Protein Inference Module

class ProteinInferencePipeline(object):
    """
    This is the main Protein Inference class which houses the logic of the entire data analysis pipeline.
    Logic is executed in the [execute][pyproteininference.pipeline.ProteinInferencePipeline.execute] method.

    Attributes:
        parameter_file (str): Path to Protein Inference Yaml Parameter File.
        database_file (str): Path to Fasta database used in proteomics search.
        target_files (str/list): Path to Target Psm File (Or a list of files).
        decoy_files (str/list): Path to Decoy Psm File (Or a list of files).
        combined_files (str/list): Path to Combined Psm File (Or a list of files).
        target_directory (str): Path to Directory containing Target Psm Files.
        decoy_directory (str): Path to Directory containing Decoy Psm Files.
        combined_directory (str): Path to Directory containing Combined Psm Files.
        output_directory (str): Path to Directory where output will be written.
        output_filename (str): Path to Filename where output will be written. Will override output_directory.
        id_splitting (bool): True/False on whether to split protein IDs in the digest. Advanced usage only.
        append_alt_from_db (bool): True/False on whether to append alternative proteins from the DB digestion in
            Reader class.
        data (DataStore): [DataStore Object][pyproteininference.datastore.DataStore].
        digest (Digest): [Digest Object][pyproteininference.in_silico_digest.Digest].

    """

    def __init__(
        self,
        parameter_file,
        database_file=None,
        target_files=None,
        decoy_files=None,
        combined_files=None,
        target_directory=None,
        decoy_directory=None,
        combined_directory=None,
        output_directory=None,
        output_filename=None,
        id_splitting=False,
        append_alt_from_db=True,
    ):
        """

        Args:
            parameter_file (str/Configuration): Path to Protein Inference Yaml Parameter File.
            database_file (str): Path to Fasta database used in proteomics search.
            target_files (str/list): Path to Target Psm File (Or a list of files).
            decoy_files (str/list): Path to Decoy Psm File (Or a list of files).
            combined_files (str/list): Path to Combined Psm File (Or a list of files).
            target_directory (str): Path to Directory containing Target Psm Files.
            decoy_directory (str): Path to Directory containing Decoy Psm Files.
            combined_directory (str): Path to Directory containing Combined Psm Files.
            output_filename (str): Path to Filename where output will be written. Will override output_directory.
            output_directory (str): Path to Directory where output will be written.
            id_splitting (bool): True/False on whether to split protein IDs in the digest. Advanced usage only.
            append_alt_from_db (bool): True/False on whether to append alternative proteins from the DB digestion in
                Reader class.

        Returns:
            object:

        Example:
            >>> pipeline = pyproteininference.pipeline.ProteinInferencePipeline(
            >>>     parameter_file=yaml_params,
            >>>     database_file=database,
            >>>     target_files=target,
            >>>     decoy_files=decoy,
            >>>     combined_files=combined_files,
            >>>     target_directory=target_directory,
            >>>     decoy_directory=decoy_directory,
            >>>     combined_directory=combined_directory,
            >>>     output_directory=dir_name,
            >>>     output_filename=output_filename,
            >>>     append_alt_from_db=append_alt,
            >>> )
        """

        self.parameter_file = parameter_file
        self.database_file = database_file
        self.target_files = target_files
        self.decoy_files = decoy_files
        self.combined_files = combined_files
        self.target_directory = target_directory
        self.decoy_directory = decoy_directory
        self.combined_directory = combined_directory
        self.output_directory = output_directory
        self.output_filename = output_filename
        self.id_splitting = id_splitting
        self.append_alt_from_db = append_alt_from_db
        self.data = None
        self.digest = None
        self.gui_status_queue = None

        self._validate_input()

        self._set_output_directory()

        self._log_append_alt_from_db()

        self._log_id_splitting()

    @classmethod
    def create_from_gui_config(cls, queue: Queue, config: Configuration):
        """Creates the ProteinInferencePipeline from a Config object passed from the graphical user interface."""
        pipeline = cls(
            parameter_file=config,
            database_file=config.fasta_file[0] if isinstance(config.fasta_file, list) else None,
            combined_files=list(config.input_files),
            output_filename=config.output_file,
            id_splitting=config.identifier_splitting,
            append_alt_from_db=config.use_alt_proteins,
        )
        pipeline.gui_status_queue = queue
        return pipeline

    def execute(self):
        """
        This method is the main driver of the data analysis for the protein inference package.
        This method calls other classes and methods that make up the protein inference pipeline.
        This includes but is not limited to:

        This method sets the data [DataStore Object][pyproteininference.datastore.DataStore] and digest
            [Digest Object][pyproteininference.in_silico_digest.Digest].

        1. Parameter file management.
        2. Digesting Fasta Database (Optional).
        3. Reading in input Psm Files.
        4. Initializing the [DataStore Object][pyproteininference.datastore.DataStore].
        5. Restricting Psms.
        6. Creating Protein objects/scoring input.
        7. Scoring Proteins.
        8. Running Protein Picker.
        9. Running Inference Methods/Grouping.
        10. Calculating Q Values.
        11. Exporting Proteins to filesystem.

        Example:
            >>> pipeline = pyproteininference.pipeline.ProteinInferencePipeline(
            >>>     parameter_file=yaml_params,
            >>>     database_file=database,
            >>>     target_files=target,
            >>>     decoy_files=decoy,
            >>>     combined_files=combined_files,
            >>>     target_directory=target_directory,
            >>>     decoy_directory=decoy_directory,
            >>>     combined_directory=combined_directory,
            >>>     output_directory=dir_name,
            >>>     output_filename=output_filename,
            >>>     append_alt_from_db=append_alt,
            >>> )
            >>> pipeline.execute()

        """
        # STEP 1: Load parameter file #
        # STEP 1: Load parameter file #
        # STEP 1: Load parameter file #
        self._update_status(0, "Configuring analysis")
        if isinstance(self.parameter_file, Configuration):
            pyproteininference_parameters = pyproteininference.parameters.ProteinInferenceParameter(
                None, configuration=self.parameter_file
            )
        else:
            pyproteininference_parameters = pyproteininference.parameters.ProteinInferenceParameter(
                yaml_param_filepath=self.parameter_file
            )

        # STEP 2: Start with running an In Silico Digestion #
        # STEP 2: Start with running an In Silico Digestion #
        # STEP 2: Start with running an In Silico Digestion #
        self._update_status(0.05, "Running In Silico Digestion")
        digest = pyproteininference.in_silico_digest.PyteomicsDigest(
            database_path=self.database_file,
            digest_type=pyproteininference_parameters.digest_type,
            missed_cleavages=pyproteininference_parameters.missed_cleavages,
            reviewed_identifier_symbol=pyproteininference_parameters.reviewed_identifier_symbol,
            max_peptide_length=pyproteininference_parameters.restrict_peptide_length,
            id_splitting=self.id_splitting,
        )
        if self.database_file:
            logger.info("Running In Silico Database Digest on file {}".format(self.database_file))
            digest.digest_fasta_database()
        else:
            logger.warning(
                "No Database File provided, Skipping database digest and only taking protein-peptide mapping from the "
                "input files."
            )

        # STEP 3: Read PSM Data #
        # STEP 3: Read PSM Data #
        # STEP 3: Read PSM Data #
        self._update_status(0.25, "Reading PSM Data")

        def _as_list(x: Union[str, List[str]]) -> List[str]:
            return [x] if isinstance(x, str) else x

        input_files = (
            _as_list(self.target_files)
            if self.target_files
            else (
                _as_list(self.decoy_files)
                if self.decoy_files
                else _as_list(self.combined_files) if self.combined_files else list()
            )
        )
        extensions = set([os.path.splitext(x)[1].lower() for x in input_files])
        if len(extensions) > 1:
            raise ValueError("All input files must be of the same type and have the same file extension.")
        logger.info("File(s) have extensions: {}".format(extensions))
        if (
            ".idxml" in extensions
            or ".mzid" in extensions
            or ".pep.xml" in extensions
            or ".xml" in extensions
            or ".pepxml" in extensions
        ):
            reader = pyproteininference.reader.IdXMLReader(
                target_file=self.target_files,
                decoy_file=self.decoy_files,
                combined_files=self.combined_files,
                parameter_file_object=pyproteininference_parameters,
                digest=digest,
                append_alt_from_db=self.append_alt_from_db,
            )
        else:
            reader = pyproteininference.reader.GenericReader(
                target_file=self.target_files,
                decoy_file=self.decoy_files,
                combined_files=self.combined_files,
                parameter_file_object=pyproteininference_parameters,
                digest=digest,
                append_alt_from_db=self.append_alt_from_db,
            )
        reader.read_psms()

        # STEP 4: Initiate the datastore object #
        # STEP 4: Initiate the datastore object #
        # STEP 4: Initiate the datastore object #
        data = pyproteininference.datastore.DataStore(reader=reader, digest=digest)

        # Step 5: Restrict the PSM data
        # Step 5: Restrict the PSM data
        # Step 5: Restrict the PSM data
        self._update_status(0.50, "Filtering PSM Data")
        data.restrict_psm_data()

        data.recover_mapping()
        # Step 6: Generate protein scoring input
        # Step 6: Generate protein scoring input
        # Step 6: Generate protein scoring input
        self._update_status(0.60, "Calculating Scores")
        data.create_scoring_input()

        # Step 7: Remove non unique peptides if running exclusion
        # Step 7: Remove non unique peptides if running exclusion
        # Step 7: Remove non unique peptides if running exclusion
        if pyproteininference_parameters.inference_type == Inference.EXCLUSION:
            # This gets ran if we run exclusion...
            data.exclude_non_distinguishing_peptides()

        # STEP 8: Score our PSMs given a score method
        # STEP 8: Score our PSMs given a score method
        # STEP 8: Score our PSMs given a score method
        score = pyproteininference.scoring.Score(data=data)
        score.score_psms(score_method=pyproteininference_parameters.protein_score)

        # STEP 9: Run protein picker on the data
        # STEP 9: Run protein picker on the data
        # STEP 9: Run protein picker on the data
        self._update_status(0.65, "Selecting Proteins")
        if pyproteininference_parameters.picker:
            data.protein_picker()
        else:
            pass

        # STEP 10: Apply Inference
        # STEP 10: Apply Inference
        # STEP 10: Apply Inference
        self._update_status(0.75, "Performing Inference")
        pyproteininference.inference.Inference.run_inference(data=data, digest=digest)

        # STEP 11: Q value Calculations
        # STEP 11: Q value Calculations
        # STEP 11: Q value Calculations
        self._update_status(0.90, "Calculating Q Values")
        data.calculate_q_values()

        # STEP 12: Export to CSV
        # STEP 12: Export to CSV
        # STEP 12: Export to CSV
        self._update_status(0.95, "Saving Results")
        export = pyproteininference.export.Export(data=data)
        export.export_to_csv(
            output_filename=self.output_filename,
            directory=self.output_directory,
            export_type=pyproteininference_parameters.export,
        )

        self.data = data
        self.digest = digest

        logger.info("Protein Inference Finished")
        self._update_status(1, "Protein Inference Finished")

    def _update_status(self, percentage: float, message: str):
        """
        Internal method for updating the status of the pipeline in the GUI.

        Args:
            percentage (float): The percentage of the pipeline that has been completed.
            message (str): The message to display to the user.
        """
        if self.gui_status_queue:
            self.gui_status_queue.put_nowait((percentage, message))

    def _validate_input(self):
        """
        Internal method that validates whether the proper input files have been defined.

        One of the following combinations must be selected as input. No more and no less:

        1. either one or multiple target_files and decoy_files.
        2. either one or multiple combined_files that include target and decoy data.
        3. a directory that contains target files (target_directory) as well as a directory that contains decoy files
            (decoy_directory).
        4. a directory that contains combined target/decoy files (combined_directory).

        Raises:
            ValueError: ValueError will occur if an improper combination of input.
        """
        if (
            self.target_files
            and self.decoy_files
            and not self.combined_files
            and not self.target_directory
            and not self.decoy_directory
            and not self.combined_directory
        ):
            logger.info("Validating input as target_files and decoy_files")
        elif (
            self.combined_files
            and not self.target_files
            and not self.decoy_files
            and not self.decoy_directory
            and not self.target_directory
            and not self.combined_directory
        ):
            logger.info("Validating input as combined_files")
        elif (
            self.target_directory
            and self.decoy_directory
            and not self.target_files
            and not self.decoy_files
            and not self.combined_directory
            and not self.combined_files
        ):
            logger.info("Validating input as target_directory and decoy_directory")
            self._transform_directory_to_files()
        elif (
            self.combined_directory
            and not self.combined_files
            and not self.decoy_files
            and not self.decoy_directory
            and not self.target_files
            and not self.target_directory
        ):
            logger.info("Validating input as combined_directory")
            self._transform_directory_to_files()
        else:
            raise ValueError(
                "To run Protein inference please supply either: "
                "(1) either one or multiple target_files and decoy_files, "
                "(2) either one or multiple combined_files that include target and decoy data"
                "(3) a directory that contains target files (target_directory) as well as a directory that "
                "contains decoy files (decoy_directory)"
                "(4) a directory that contains combined target/decoy files (combined_directory)"
            )

    def _transform_directory_to_files(self):
        """
        This internal method takes files that are in the target_directory, decoy_directory, or combined_directory and
        reassigns these files to the target_files, decoy_files, and combined_files to be used in
         [Reader][pyproteininference.reader.Reader] object.
        """
        if self.target_directory and self.decoy_directory:
            logger.info("Transforming target_directory and decoy_directory into files")
            target_files = os.listdir(self.target_directory)
            target_files_full = [
                os.path.join(self.target_directory, x) for x in target_files if x.endswith(".txt") or x.endswith(".tsv")
            ]

            decoy_files = os.listdir(self.decoy_directory)
            decoy_files_full = [
                os.path.join(self.decoy_directory, x) for x in decoy_files if x.endswith(".txt") or x.endswith(".tsv")
            ]

            self.target_files = target_files_full
            self.decoy_files = decoy_files_full

        elif self.combined_directory:
            logger.info("Transforming combined_directory into files")
            combined_files = os.listdir(self.combined_directory)
            combined_files_full = [
                os.path.join(self.combined_directory, x)
                for x in combined_files
                if x.endswith(".txt") or x.endswith(".tsv")
            ]
            self.combined_files = combined_files_full

    def _set_output_directory(self):
        """
        Internal method for setting the output directory.
        If the output_directory argument is not supplied the output directory is set as the cwd.
        """
        if not self.output_directory:
            self.output_directory = os.getcwd()
        else:
            pass

    def _log_append_alt_from_db(self):
        """
        Internal method for logging whether the user sets alternative protein append to True or False.
        """
        if self.append_alt_from_db:
            logger.info("Append Alternative Proteins from Database set to True")
        else:
            logger.info("Append Alternative Proteins from Database set to False")

    def _log_id_splitting(self):
        """
        Internal method for logging whether the user sets ID splitting to True or False.
        """
        if self.id_splitting:
            logger.info("ID Splitting for Database Digestion set to True")
        else:
            logger.info("ID Splitting for Database Digestion set to False")

class ProteinInferenceParameter(object):
    """
    Class that handles data retrieval, storage, and validation of Protein Inference Parameters.

    Attributes:
        yaml_param_filepath (str): path to properly formatted parameter file specific to Protein Inference.
        digest_type (str): String that determines that type of digestion in silico digestion for
            [Digest object][pyproteininference.in_silico_digest.Digest]. Typically "trypsin".
        export (str): String to indicate the export type for [Export object][pyproteininference.export.Export].
            Typically this is "psms", "peptides", or "psm_ids".
        fdr (float): Float to indicate FDR filtering.
        missed_cleavages (int): Integer to determine the number of missed cleavages in the database digestion
            [Digest object][pyproteininference.in_silico_digest.Digest].
        picker (bool): True/False on whether or not to run
            the [protein picker][pyproteininference.datastore.DataStore.protein_picker] algorithm.
        restrict_pep (float/None): Float to restrict the posterior error probability values by in the PSM input.
            Used in [restrict_psm_data][pyproteininference.datastore.DataStore.restrict_psm_data].
        restrict_peptide_length (int/None): Float to restrict the peptide length values by in the PSM input.
            Used in [restrict_psm_data][pyproteininference.datastore.DataStore.restrict_psm_data].
        restrict_q (float/None): Float to restrict the q values by in the PSM input.
            Used in [restrict_psm_data][pyproteininference.datastore.DataStore.restrict_psm_data].
        restrict_custom (float/None): Float to restrict the custom values by in the PSM input.
            Used in [restrict_psm_data][pyproteininference.datastore.DataStore.restrict_psm_data].
            Filtering depends on score_type variable. If score_type is multiplicative then values that are less than
            restrict_custom are kept. If score_type is additive then values that are more than restrict_custom are kept.
        protein_score (str): String to determine the way in which Proteins are scored can be any of the SCORE_METHODS
            in [Score object][pyproteininference.scoring.Score].
        psm_score_type (str): String to determine the type of score that the PSM scores are
            (Additive or Multiplicative) can be any of the SCORE_TYPES
            in [Score object][pyproteininference.scoring.Score].
        decoy_symbol (str): String to denote decoy proteins from target proteins. IE "##".
        isoform_symbol (str): String to denote isoforms from regular proteins. IE "-". Can also be None.
        reviewed_identifier_symbol (str): String to denote a "Reviewed" Protein. Typically this is: "sp|"
            if using Uniprot Fasta database.
        inference_type (str): String to determine the inference procedure. Can be any value of INFERENCE_TYPES
            of [Inference object][pyproteininference.inference.Inference].
        tag (str): String to be added to output files.
        psm_score (str): String that indicates the PSM input score. The value should match the string in the
            input data of the score you want to use for PSM score. This score will be used in scoring methods
                here: [Score object][pyproteininference.scoring.Score].
        grouping_type (str/None): String to determine the grouping procedure. Can be any value of
            GROUPING_TYPES of [Inference object][pyproteininference.inference.Inference].
        max_identifiers_peptide_centric (int): Maximum number of identifiers to assign to a group when
            running peptide_centric inference. Typically this is 10 or 5.
        lp_solver (str/None): The LP solver to use if inference_type="Parsimony".
            Can be any value in LP_SOLVERS in the [Inference object][pyproteininference.inference.Inference].

    """

    PARENT_PARAMETER_KEY = "parameters"

    GENERAL_PARAMETER_KEY = "general"
    DATA_RESTRICTION_PARAMETER_KEY = "data_restriction"
    SCORE_PARAMETER_KEY = "score"
    IDENTIFIERS_PARAMETER_KEY = "identifiers"
    INFERENCE_PARAMETER_KEY = "inference"
    DIGEST_PARAMETER_KEY = "digest"
    PARSIMONY_PARAMETER_KEY = "parsimony"
    PEPTIDE_CENTRIC_PARAMETER_KEY = "peptide_centric"

    XML_INPUT_PARSER_PARAMETER_KEY = "xml_parser"

    PARAMETER_MAIN_KEYS = {
        GENERAL_PARAMETER_KEY,
        DATA_RESTRICTION_PARAMETER_KEY,
        SCORE_PARAMETER_KEY,
        IDENTIFIERS_PARAMETER_KEY,
        INFERENCE_PARAMETER_KEY,
        DIGEST_PARAMETER_KEY,
        PARSIMONY_PARAMETER_KEY,
        PEPTIDE_CENTRIC_PARAMETER_KEY,
    }

    EXPORT_PARAMETER = "export"
    FDR_PARAMETER = "fdr"
    PICKER_PARAMETER = "picker"
    TAG_PARAMETER = "tag"

    GENERAL_PARAMETER_SUB_KEYS = {
        EXPORT_PARAMETER,
        FDR_PARAMETER,
        PICKER_PARAMETER,
        TAG_PARAMETER,
    }

    PEP_RESTRICT_PARAMETER = "pep_restriction"
    PEPTIDE_LENGTH_RESTRICT_PARAMETER = "peptide_length_restriction"
    Q_VALUE_RESTRICT_PARAMETER = "q_value_restriction"
    CUSTOM_RESTRICT_PARAMETER = "custom_restriction"
    MAX_ALLOWED_ALTERNATIVE_PROTEINS_PARAMETER = "max_allowed_alternative_proteins"

    DATA_RESTRICTION_PARAMETER_SUB_KEYS = {
        PEP_RESTRICT_PARAMETER,
        PEPTIDE_LENGTH_RESTRICT_PARAMETER,
        Q_VALUE_RESTRICT_PARAMETER,
        CUSTOM_RESTRICT_PARAMETER,
        MAX_ALLOWED_ALTERNATIVE_PROTEINS_PARAMETER,
    }

    PROTEIN_SCORE_PARAMETER = "protein_score"
    PSM_SCORE_PARAMETER = "psm_score"
    PSM_SCORE_TYPE_PARAMETER = "psm_score_type"

    SCORE_PARAMETER_SUB_KEYS = {
        PROTEIN_SCORE_PARAMETER,
        PSM_SCORE_PARAMETER,
        PSM_SCORE_TYPE_PARAMETER,
    }

    DECOY_SYMBOL_PARAMETER = "decoy_symbol"
    ISOFORM_SYMBOL_PARAMETER = "isoform_symbol"
    REVIEWED_IDENTIFIER_PARAMETER = "reviewed_identifier_symbol"

    IDENTIFIER_SUB_KEYS = {
        DECOY_SYMBOL_PARAMETER,
        ISOFORM_SYMBOL_PARAMETER,
        REVIEWED_IDENTIFIER_PARAMETER,
    }

    INFERENCE_TYPE_PARAMETER = "inference_type"
    GROUPING_TYPE_PARAMETER = "grouping_type"

    INFERENCE_SUB_KEYS = {INFERENCE_TYPE_PARAMETER, GROUPING_TYPE_PARAMETER}

    DIGEST_TYPE_PARAMETER = "digest_type"
    MISSED_CLEAV_PARAMETER = "missed_cleavages"

    DIGEST_SUB_KEYS = {DIGEST_TYPE_PARAMETER, MISSED_CLEAV_PARAMETER}

    LP_SOLVER_PARAMETER = "lp_solver"
    SHARED_PEPTIDES_PARAMETER = "shared_peptides"

    PARSIMONY_SUB_KEYS = {
        LP_SOLVER_PARAMETER,
        SHARED_PEPTIDES_PARAMETER,
    }

    MAX_IDENTIFIERS_PARAMETER = "max_identifiers"

    PEPTIDE_CENTRIC_SUB_KEYS = {MAX_IDENTIFIERS_PARAMETER}

    PARSER_OPENMS = "openms"
    PARSER_PYTEOMICS = "pyteomics"

    DEFAULT_DIGEST_TYPE = "trypsin"
    DEFAULT_EXPORT = "peptides"
    DEFAULT_FDR = 0.01
    DEFAULT_MISSED_CLEAVAGES = 3
    DEFAULT_PICKER = True
    DEFAULT_RESTRICT_PEP = 0.9
    DEFAULT_RESTRICT_PEPTIDE_LENGTH = 7
    DEFAULT_RESTRICT_Q = 0.005
    DEFAULT_MAX_ALLOWED_ALTERNATIVE_PROTEINS = 50
    DEFAULT_RESTRICT_CUSTOM = "None"
    DEFAULT_PROTEIN_SCORE = "multiplicative_log"
    DEFAULT_PSM_SCORE = "posterior_error_prob"
    DEFAULT_DECOY_SYMBOL = "##"
    DEFAULT_ISOFORM_SYMBOL = "-"
    DEFAULT_REVIEWED_IDENTIFIER_SYMBOL = "sp|"
    DEFAULT_INFERENCE_TYPE = "peptide_centric"
    DEFAULT_TAG = "py_protein_inference"
    DEFAULT_PSM_SCORE_TYPE = "multiplicative"
    DEFAULT_GROUPING_TYPE = "parsimonious_grouping"
    DEFAULT_MAX_IDENTIFIERS_PEPTIDE_CENTRIC = 5
    DEFAULT_LP_SOLVER = "pulp"
    DEFAULT_SHARED_PEPTIDES = "all"
    DEFAULT_XML_INPUT_PARSER = PARSER_OPENMS

    def __init__(self, yaml_param_filepath, configuration=None, validate=True):
        """Class to store Protein Inference parameter information as an object.

        Args:
            yaml_param_filepath (str): path to properly formatted parameter file specific to Protein Inference.
            validate (bool): True/False on whether to validate the parameter file of interest.

        Returns:
            None:

        Example:
            >>> pyproteininference.parameters.ProteinInferenceParameter(
            >>>     yaml_param_filepath = "/path/to/pyproteininference_params.yaml", validate=True
            >>> )


        """
        self.yaml_param_filepath = yaml_param_filepath
        self.digest_type = self.DEFAULT_DIGEST_TYPE
        self.export = self.DEFAULT_EXPORT
        self.fdr = self.DEFAULT_FDR
        self.missed_cleavages = self.DEFAULT_MISSED_CLEAVAGES
        self.picker = self.DEFAULT_PICKER
        self.restrict_pep = self.DEFAULT_RESTRICT_PEP
        self.restrict_peptide_length = self.DEFAULT_RESTRICT_PEPTIDE_LENGTH
        self.restrict_q = self.DEFAULT_RESTRICT_Q
        self.restrict_custom = self.DEFAULT_RESTRICT_CUSTOM
        self.protein_score = self.DEFAULT_PROTEIN_SCORE
        self.psm_score_type = self.DEFAULT_PSM_SCORE_TYPE
        self.decoy_symbol = self.DEFAULT_DECOY_SYMBOL
        self.isoform_symbol = self.DEFAULT_ISOFORM_SYMBOL
        self.reviewed_identifier_symbol = self.DEFAULT_REVIEWED_IDENTIFIER_SYMBOL
        self.inference_type = self.DEFAULT_INFERENCE_TYPE
        self.tag = self.DEFAULT_TAG
        self.psm_score = self.DEFAULT_PSM_SCORE
        self.grouping_type = self.DEFAULT_GROUPING_TYPE
        self.max_identifiers_peptide_centric = self.DEFAULT_MAX_IDENTIFIERS_PEPTIDE_CENTRIC
        self.lp_solver = self.DEFAULT_LP_SOLVER
        self.shared_peptides = self.DEFAULT_SHARED_PEPTIDES
        self.validate = validate
        self.xml_input_parser = self.DEFAULT_XML_INPUT_PARSER
        self.max_allowed_alternative_proteins = self.DEFAULT_MAX_ALLOWED_ALTERNATIVE_PROTEINS

        if configuration is not None:
            self.convert_from_gui_configuration(configuration)
        else:
            self.convert_to_object()

        if validate:
            self.validate_parameters()

        self._fix_none_parameters()

    def convert_to_object(self):
        """
        Function that takes a Protein Inference parameter file and converts it into a ProteinInferenceParameter object
        by assigning all Attributes of the ProteinInferenceParameter object.

        If no parameter filepath is supplied the parameter object will be loaded with default params.

        This function gets ran in the initialization of the ProteinInferenceParameter object.

        Returns:
            None:

        """
        if self.yaml_param_filepath:
            with open(self.yaml_param_filepath, "r") as stream:
                yaml_params = yaml.load(stream, Loader=yaml.Loader)

            try:
                self.digest_type = yaml_params[self.PARENT_PARAMETER_KEY][self.DIGEST_PARAMETER_KEY][
                    self.DIGEST_TYPE_PARAMETER
                ]
            except KeyError:
                logger.warning("digest_type set to default of {}".format(self.DEFAULT_DIGEST_TYPE))

            try:
                self.export = yaml_params[self.PARENT_PARAMETER_KEY][self.GENERAL_PARAMETER_KEY][self.EXPORT_PARAMETER]
            except KeyError:
                logger.warning("export set to default of {}".format(self.DEFAULT_EXPORT))

            try:
                self.fdr = yaml_params[self.PARENT_PARAMETER_KEY][self.GENERAL_PARAMETER_KEY][self.FDR_PARAMETER]
            except KeyError:
                logger.warning("fdr set to default of {}".format(self.DEFAULT_FDR))
            try:
                self.missed_cleavages = yaml_params[self.PARENT_PARAMETER_KEY][self.DIGEST_PARAMETER_KEY][
                    self.MISSED_CLEAV_PARAMETER
                ]
            except KeyError:
                logger.warning("missed_cleavages set to default of {}".format(self.DEFAULT_MISSED_CLEAVAGES))

            try:
                self.picker = yaml_params[self.PARENT_PARAMETER_KEY][self.GENERAL_PARAMETER_KEY][self.PICKER_PARAMETER]
            except KeyError:
                logger.warning("picker set to default of {}".format(self.DEFAULT_PICKER))

            try:
                self.restrict_pep = yaml_params[self.PARENT_PARAMETER_KEY][self.DATA_RESTRICTION_PARAMETER_KEY][
                    self.PEP_RESTRICT_PARAMETER
                ]
            except KeyError:
                logger.warning("restrict_pep set to default of {}".format(self.DEFAULT_RESTRICT_PEP))

            try:
                self.restrict_peptide_length = yaml_params[self.PARENT_PARAMETER_KEY][
                    self.DATA_RESTRICTION_PARAMETER_KEY
                ][self.PEPTIDE_LENGTH_RESTRICT_PARAMETER]
            except KeyError:
                logger.warning(
                    "restrict_peptide_length set to default of {}".format(self.DEFAULT_RESTRICT_PEPTIDE_LENGTH)
                )

            try:
                self.restrict_q = yaml_params[self.PARENT_PARAMETER_KEY][self.DATA_RESTRICTION_PARAMETER_KEY][
                    self.Q_VALUE_RESTRICT_PARAMETER
                ]
            except KeyError:
                logger.warning("restrict_q set to default of {}".format(self.DEFAULT_RESTRICT_Q))

            try:
                self.restrict_custom = yaml_params[self.PARENT_PARAMETER_KEY][self.DATA_RESTRICTION_PARAMETER_KEY][
                    self.CUSTOM_RESTRICT_PARAMETER
                ]
            except KeyError:
                logger.warning("restrict_custom set to default of {}".format(self.DEFAULT_RESTRICT_CUSTOM))

            try:
                self.max_allowed_alternative_proteins = yaml_params[self.PARENT_PARAMETER_KEY][
                    self.DATA_RESTRICTION_PARAMETER_KEY
                ][self.MAX_ALLOWED_ALTERNATIVE_PROTEINS_PARAMETER]
            except KeyError:
                logger.warning(
                    "max_allowed_alternative_proteins set to default of {}".format(
                        self.DEFAULT_MAX_ALLOWED_ALTERNATIVE_PROTEINS
                    )
                )

            try:
                self.protein_score = yaml_params[self.PARENT_PARAMETER_KEY][self.SCORE_PARAMETER_KEY][
                    self.PROTEIN_SCORE_PARAMETER
                ]
            except KeyError:
                logger.warning("protein_score set to default of {}".format(self.DEFAULT_PROTEIN_SCORE))

            try:
                self.psm_score_type = yaml_params[self.PARENT_PARAMETER_KEY][self.SCORE_PARAMETER_KEY][
                    self.PSM_SCORE_TYPE_PARAMETER
                ]
            except KeyError:
                logger.warning("psm_score_type set to default of {}".format(self.DEFAULT_PSM_SCORE_TYPE))

            try:
                self.decoy_symbol = yaml_params[self.PARENT_PARAMETER_KEY][self.IDENTIFIERS_PARAMETER_KEY][
                    self.DECOY_SYMBOL_PARAMETER
                ]
            except KeyError:
                logger.warning("decoy_symbol set to default of {}".format(self.DEFAULT_DECOY_SYMBOL))

            try:
                self.isoform_symbol = yaml_params[self.PARENT_PARAMETER_KEY][self.IDENTIFIERS_PARAMETER_KEY][
                    self.ISOFORM_SYMBOL_PARAMETER
                ]
            except KeyError:
                logger.warning("isoform_symbol set to default of {}".format(self.DEFAULT_ISOFORM_SYMBOL))

            try:
                self.reviewed_identifier_symbol = yaml_params[self.PARENT_PARAMETER_KEY][
                    self.IDENTIFIERS_PARAMETER_KEY
                ][self.REVIEWED_IDENTIFIER_PARAMETER]
            except KeyError:
                logger.warning(
                    "reviewed_identifier_symbol set to default of {}".format(self.DEFAULT_REVIEWED_IDENTIFIER_SYMBOL)
                )

            try:
                self.inference_type = yaml_params[self.PARENT_PARAMETER_KEY][self.INFERENCE_PARAMETER_KEY][
                    self.INFERENCE_TYPE_PARAMETER
                ]
            except KeyError:
                logger.warning("inference_type set to default of {}".format(self.DEFAULT_INFERENCE_TYPE))

            try:
                self.tag = yaml_params[self.PARENT_PARAMETER_KEY][self.GENERAL_PARAMETER_KEY][self.TAG_PARAMETER]
            except KeyError:
                logger.warning("tag set to default of {}".format(self.DEFAULT_TAG))

            try:
                self.psm_score = yaml_params[self.PARENT_PARAMETER_KEY][self.SCORE_PARAMETER_KEY][
                    self.PSM_SCORE_PARAMETER
                ]
            except KeyError:
                logger.warning("psm_score set to default of {}".format(self.DEFAULT_PSM_SCORE))

            try:
                self.grouping_type = yaml_params[self.PARENT_PARAMETER_KEY][self.INFERENCE_PARAMETER_KEY][
                    self.GROUPING_TYPE_PARAMETER
                ]
            except KeyError:
                logger.warning("grouping_type set to default of {}".format(self.DEFAULT_GROUPING_TYPE))

            try:
                self.xml_input_parser = yaml_params[self.PARENT_PARAMETER_KEY][self.GENERAL_PARAMETER_KEY][
                    self.XML_INPUT_PARSER_PARAMETER_KEY
                ]
            except KeyError:
                logger.warning("xml_input_parser set to default of {}".format(self.DEFAULT_XML_INPUT_PARSER))

            try:
                self.max_identifiers_peptide_centric = yaml_params[self.PARENT_PARAMETER_KEY][
                    self.PEPTIDE_CENTRIC_PARAMETER_KEY
                ][self.MAX_IDENTIFIERS_PARAMETER]
            except KeyError:
                logger.warning(
                    "max_identifiers_peptide_centric set to default of {}".format(
                        self.DEFAULT_MAX_IDENTIFIERS_PEPTIDE_CENTRIC
                    )
                )

            try:
                self.lp_solver = yaml_params[self.PARENT_PARAMETER_KEY][self.PARSIMONY_PARAMETER_KEY][
                    self.LP_SOLVER_PARAMETER
                ]
            except KeyError:
                logger.warning("lp_solver set to default of {}".format(self.DEFAULT_LP_SOLVER))
            try:
                # Do try except here to make old param files backwards compatible
                self.shared_peptides = yaml_params[self.PARENT_PARAMETER_KEY][self.PARSIMONY_PARAMETER_KEY][
                    self.SHARED_PEPTIDES_PARAMETER
                ]
            except KeyError:
                logger.warning("shared_peptides set to default of {}".format(self.DEFAULT_SHARED_PEPTIDES))

        else:
            logger.warning("Yaml parameter file not found, all parameters set to default")

    def convert_from_gui_configuration(self, configuration: Configuration):
        """
        Function that takes a Protein Inference GUI configuration object and converts it into a ProteinInferenceParameter object
        by assigning all Attributes of the ProteinInferenceParameter object.

        If no parameter filepath is supplied the parameter object will be loaded with default params.

        This function gets ran in the initialization of the ProteinInferenceParameter object.

        Returns:
            None:

        """
        self.digest_type = configuration.digest_type
        self.export = self.DEFAULT_EXPORT
        self.fdr = configuration.false_discovery_rate
        self.missed_cleavages = configuration.missed_cleavages
        self.picker = configuration.picker
        self.restrict_pep = configuration.pep_restriction
        self.restrict_peptide_length = configuration.peptide_length_restriction
        self.restrict_q = configuration.q_value_restriction
        self.restrict_custom = self.DEFAULT_RESTRICT_CUSTOM
        self.protein_score = configuration.protein_score
        self.psm_score_type = configuration.psm_score_type
        self.decoy_symbol = configuration.decoy_symbol
        self.isoform_symbol = configuration.isoform_symbol
        self.reviewed_identifier_symbol = configuration.reviewed_identifier_symbol
        self.inference_type = configuration.inference_type
        self.tag = self.DEFAULT_TAG
        if configuration.psm_score == "custom":
            self.psm_score = configuration.psm_score_custom
        else:
            self.psm_score = configuration.psm_score
        self.grouping_type = configuration.grouping_type
        self.max_identifiers_peptide_centric = configuration.max_identifiers
        self.lp_solver = self.DEFAULT_LP_SOLVER
        self.shared_peptides = configuration.shared_peptides
        self.xml_input_parser = configuration.xml_input_parser
        self.max_allowed_alternative_proteins = configuration.max_allowed_alternative_proteins

    def validate_parameters(self):
        """
        Class method to validate all parameters.

        Returns:
            None:

        """
        # Run all of the parameter validations
        self._validate_digest_type()
        self._validate_export_type()
        self._validate_floats()
        self._validate_bools()
        self._validate_score_type()
        self._validate_score_method()
        self._validate_score_combination()
        self._validate_inference_type()
        self._validate_grouping_type()
        self._validate_max_id()
        self._validate_lp_solver()
        self._validate_identifiers()
        self._validate_parsimony_shared_peptides()

    def _validate_digest_type(self):
        """
        Internal ProteinInferenceParameter method to validate the digest type.
        """
        # Make sure we have a valid digest type
        if self.digest_type in PyteomicsDigest.LIST_OF_DIGEST_TYPES:
            logger.info("Using digest type '{}'".format(self.digest_type))
        else:
            raise ValueError(
                "Digest Type '{}' not supported, please use one of the following enyzme digestions: '{}'".format(
                    self.digest_type, ", ".join(PyteomicsDigest.LIST_OF_DIGEST_TYPES)
                )
            )

    def _validate_export_type(self):
        """
        Internal ProteinInferenceParameter method to validate the export type.
        """
        # Make sure we have a valid export type
        if self.export in Export.EXPORT_TYPES:
            logger.info("Using Export type '{}'".format(self.export))
        else:
            raise ValueError(
                "Export Type '{}' not supported, please use one of the following export types: '{}'".format(
                    self.export, ", ".join(Export.EXPORT_TYPES)
                )
            )
        pass

    def _validate_floats(self):
        """
        Internal ProteinInferenceParameter method to validate floats.
        """
        # Validate that FDR, cleavages, and restrict values are all floats and or ints if they need to be

        try:
            if 0 <= float(self.fdr) <= 1:
                logger.info("FDR Input {}".format(self.fdr))

        except ValueError:
            raise ValueError("FDR must be a decimal between 0 and 1, FDR provided: {}".format(self.fdr))

        try:
            if 0 <= float(self.restrict_pep) <= 1:
                logger.info("PEP restriction {}".format(self.restrict_pep))

        except ValueError:
            if not self.restrict_pep or self.restrict_pep.lower() == "none":
                self.restrict_pep = None
                logger.info("Not restrict by PEP Value")
            else:
                raise ValueError(
                    "PEP restriction must be a decimal between 0 and 1, PEP restriction provided: {}".format(
                        self.restrict_pep
                    )
                )

        try:
            if 0 <= float(self.restrict_q) <= 1:
                logger.info("Q Value restriction {}".format(self.restrict_q))

        except ValueError:
            if not self.restrict_q or self.restrict_q.lower() == "none":
                self.restrict_q = None
                logger.info("Not restrict by Q Value")
            else:
                raise ValueError(
                    "Q Value restriction must be a decimal between 0 and 1, Q Value restriction provided: {}".format(
                        self.restrict_q
                    )
                )

        try:
            int(self.missed_cleavages)
            logger.info("Missed Cleavages selected: {}".format(self.missed_cleavages))
        except ValueError:
            raise ValueError(
                "Missed Cleavages must be an integer, Provided Missed Cleavages value: {}".format(self.missed_cleavages)
            )

        try:
            int(self.restrict_peptide_length)
            logger.info("Peptide Length Restriction: Len {}".format(self.restrict_peptide_length))
        except ValueError:
            if not self.restrict_peptide_length or self.restrict_peptide_length.lower() == "none":
                self.restrict_peptide_length = None
                logger.info("Not Restricting by Peptide Length")
            else:
                raise ValueError(
                    "Peptide Length Restriction must be an integer, "
                    "Provided Peptide Length Restriction value: {}".format(self.restrict_peptide_length)
                )

        try:
            float(self.restrict_custom)
            logger.info("Custom restriction {}".format(self.restrict_custom))
        except ValueError or TypeError:
            if not self.restrict_custom or self.restrict_custom.lower() == "none":
                self.restrict_custom = None
                logger.info("Not Restricting by Custom Value")
            else:
                raise ValueError(
                    "Custom restriction must be a number, Custom restriction provided: {}".format(self.restrict_custom)
                )

    def _validate_bools(self):
        """
        Internal ProteinInferenceParameter method to validate the bools.
        """
        # Make sure picker is a bool
        if type(self.picker) == bool:
            if self.picker:
                logger.info("Parameters loaded to run Picker")
            else:
                logger.info("Parameters loaded to NOT run Picker")
        else:
            raise ValueError(
                "Picker Variable must be set to True or False, Picker Variable provided: {}".format(self.picker)
            )

    def _validate_score_method(self):
        """
        Internal ProteinInferenceParameter method to validate the score method.
        """
        # Make sure we have the score method defined in code to use...
        if self.protein_score in Score.SCORE_METHODS:
            logger.info("Using Score Method '{}'".format(self.protein_score))
        else:
            raise ValueError(
                "Score Method '{}' not supported, "
                "please use one of the following Score Methods: '{}'".format(
                    self.protein_score, ", ".join(Score.SCORE_METHODS)
                )
            )

    def _validate_score_type(self):
        """
        Internal ProteinInferenceParameter method to validate the score type.
        """
        # Make sure score type is multiplicative or additive
        if self.psm_score_type in Score.SCORE_TYPES:
            logger.info("Using Score Type '{}'".format(self.psm_score_type))
        else:
            raise ValueError(
                "Score Type '{}' not supported, "
                "please use one of the following Score Types: '{}'".format(
                    self.psm_score_type, ", ".join(Score.SCORE_TYPES)
                )
            )

    def _validate_score_combination(self):
        """
        Internal ProteinInferenceParameter method to validate combination of score method and score type.
        """
        # Check to see if combination of score (column), method(multiplicative log, additive),
        # and score type (multiplicative/additive) is possible...
        # This will be super custom

        if self.psm_score_type == Score.ADDITIVE_SCORE_TYPE and self.protein_score != Score.ADDITIVE:
            raise ValueError(
                "If Score type is 'additive' (Higher PSM score is better) then you must use the 'additive' score method"
            )

        elif self.psm_score_type == Score.MULTIPLICATIVE_SCORE_TYPE and self.protein_score == Score.ADDITIVE:
            raise ValueError(
                "If Score type is 'multiplicative' (Lower PSM score is better) "
                "then you must NOT use the 'additive' score method please "
                "select one of the following score methods: {}".format(
                    ", ".join([x for x in Score.SCORE_METHODS if x != "additive"])
                )
            )

        else:
            logger.info(
                "Combination of Score Type: '{}' and Score Method: '{}' is Ok".format(
                    self.psm_score_type, self.protein_score
                )
            )

    def _validate_inference_type(self):
        """
        Internal ProteinInferenceParameter method to validate the inference type.
        """
        # Check if its parsimony, exclusion, inclusion, none
        if self.inference_type in Inference.INFERENCE_TYPES:
            logger.info("Using inference type '{}'".format(self.inference_type))
        else:
            raise ValueError(
                "Inferece Type '{}' not supported, please use one of the following Inferece Types: '{}'".format(
                    self.inference_type, ", ".join(Inference.INFERENCE_TYPES)
                )
            )

    def _validate_grouping_type(self):
        """
        Internal ProteinInferenceParameter method to validate the grouping type.
        """
        # Check if its parsimony, exclusion, inclusion, none
        if self.grouping_type in Inference.GROUPING_TYPES:
            logger.info("Using Grouping type '{}'".format(self.grouping_type))
        else:
            if self.grouping_type.lower() == "none" or not self.grouping_type:
                self.grouping_type = None
                logger.info("Using Grouping type: None")
            else:

                raise ValueError(
                    "Grouping Type '{}' not supported, please use one of the following Grouping Types: '{}'".format(
                        self.grouping_type, Inference.GROUPING_TYPES
                    )
                )

    def _validate_max_id(self):
        """
        Internal ProteinInferenceParameter method to validate the max peptide centric id.
        """
        # Check if max_identifiers_peptide_centric param is an INT
        if type(self.max_identifiers_peptide_centric) == int:
            logger.info(
                "Max Number of Indentifiers for Peptide Centric Inference: '{}'".format(
                    self.max_identifiers_peptide_centric
                )
            )
        else:
            raise ValueError(
                "Max Number of Indentifiers for Peptide Centric Inference must be an integer, "
                "provided value: {}".format(self.max_identifiers_peptide_centric)
            )

    def _validate_lp_solver(self):
        """
        Internal ProteinInferenceParameter method to validate the lp solver.
        """
        # Check if its pulp or None
        if self.lp_solver in Inference.LP_SOLVERS:
            logger.info("Using LP Solver '{}'".format(self.lp_solver))
        else:
            if self.lp_solver.lower() == "none" or not self.lp_solver:
                self.lp_solver = None
                logger.info("Setting LP Solver to None")
            else:
                raise ValueError(
                    "LP Solver '{}' not supported, please use one of the following LP Solvers: '{}'".format(
                        self.lp_solver, ", ".join(Inference.LP_SOLVERS)
                    )
                )

    def _validate_parsimony_shared_peptides(self):
        """
        Internal ProteinInferenceParameter method to validate the shared peptides parameter.
        """
        # Check if its all, best, or none
        if self.shared_peptides in Inference.SHARED_PEPTIDE_TYPES:
            logger.info("Using Shared Peptide types '{}'".format(self.shared_peptides))
        else:
            if self.shared_peptides.lower() == "none" or not self.shared_peptides:
                self.shared_peptides = None
                logger.info("Setting Shared Peptide type to None")
            else:
                raise ValueError(
                    "Shared Peptide types '{}' not supported, please use one of the following "
                    "Shared Peptide types: '{}'".format(self.shared_peptides, Inference.SHARED_PEPTIDE_TYPES)
                )

    def _validate_identifiers(self):
        """
        Internal ProteinInferenceParameter method to validate the decoy symbol, isoform symbol,
        and reviewed identifier symbol.

        """
        if type(self.decoy_symbol) == str:
            logger.info("Decoy Symbol set to: '{}'".format(self.decoy_symbol))
        else:
            raise ValueError("Decoy Symbol must be a string, provided value: {}".format(self.decoy_symbol))

        if type(self.isoform_symbol) == str:
            logger.info("Isoform Symbol set to: '{}'".format(self.isoform_symbol))
            if self.isoform_symbol.lower() == "none" or not self.isoform_symbol:
                self.isoform_symbol = None
                logger.info("Isoform Symbol set to None")
        else:
            if self.isoform_symbol:
                self.isoform_symbol = None
                logger.info("Isoform Symbol set to None")
            raise ValueError("Isoform Symbol must be a string, provided value: {}".format(self.isoform_symbol))

        if type(self.reviewed_identifier_symbol) == str:
            logger.info("Reviewed Identifier Symbol set to: '{}'".format(self.reviewed_identifier_symbol))
            if self.reviewed_identifier_symbol.lower() == "none" or not self.reviewed_identifier_symbol:
                self.reviewed_identifier_symbol = None
                logger.info("Reviewed Identifier Symbol set to None")
        else:
            if not self.reviewed_identifier_symbol:
                self.reviewed_identifier_symbol = None
                logger.info("Reviewed Identifier Symbol set to None")
            raise ValueError(
                "Reviewed Identifier Symbol must be a string, provided value: {}".format(
                    self.reviewed_identifier_symbol
                )
            )

    def _validate_parameter_shape(self, yaml_params):
        """
        Internal ProteinInferenceParameter method to validate shape of the parameter file by checking to make sure
         that all necessary main parameter fields are defined.
        """
        if self.PARENT_PARAMETER_KEY in yaml_params.keys():
            logger.info("Main Parameter Key is Present")
        else:
            raise ValueError(
                "Key {} needs to be defined as the outermost parameter group".format(self.PARENT_PARAMETER_KEY)
            )

        if self.PARAMETER_MAIN_KEYS.issubset(yaml_params[self.PARENT_PARAMETER_KEY]):
            logger.info("All Sub Parameter Keys Present")
        else:
            raise ValueError(
                "All of the following values: {}. Need to be Sub Parameters in the Yaml Parameter file".format(
                    ", ".join(self.PARAMETER_MAIN_KEYS),
                )
            )

        try:
            general_params = yaml_params[self.PARENT_PARAMETER_KEY][self.GENERAL_PARAMETER_KEY]
            for gkey in self.GENERAL_PARAMETER_SUB_KEYS:
                if gkey in general_params.keys():
                    pass
                else:
                    raise ValueError(
                        "General Sub Parameter '{}' is not found in the parameter file. "
                        "Please add it as a sub parameter of the general parameter field".format(gkey)
                    )

        except KeyError:
            raise ValueError("'general' sub Parameter not defined in the parameter file")

        try:
            data_res_params = yaml_params[self.PARENT_PARAMETER_KEY][self.DATA_RESTRICTION_PARAMETER_KEY]
            for drkey in self.DATA_RESTRICTION_PARAMETER_SUB_KEYS:
                if drkey in data_res_params.keys():
                    pass
                else:
                    raise ValueError(
                        "Data Restriction Sub Parameter '{}' is not found in the parameter file. "
                        "Please add it as a sub parameter of the data_restriction parameter field".format(drkey)
                    )

        except KeyError:
            raise ValueError("'data_restriction' sub Parameter not defined in the parameter file")

        try:
            score_params = yaml_params[self.PARENT_PARAMETER_KEY][self.SCORE_PARAMETER_KEY]
            for skey in self.SCORE_PARAMETER_SUB_KEYS:
                if skey in score_params.keys():
                    pass
                else:
                    raise ValueError(
                        "Score Sub Parameter '{}' is not found in the parameter file. "
                        "Please add it as a sub parameter of the score parameter field".format(skey)
                    )

        except KeyError:
            raise ValueError("'score' sub Parameter not defined in the parameter file")

        try:
            id_params = yaml_params[self.PARENT_PARAMETER_KEY][self.IDENTIFIERS_PARAMETER_KEY]
            for ikey in self.IDENTIFIER_SUB_KEYS:
                if ikey in id_params.keys():
                    pass
                else:
                    raise ValueError(
                        "Identifiers Sub Parameter '{}' is not found in the parameter file. "
                        "Please add it as a sub parameter of the identifiers parameter field".format(ikey)
                    )

        except KeyError:
            raise ValueError("'identifiers' sub Parameter not defined in the parameter file")

        try:
            inf_params = yaml_params[self.PARENT_PARAMETER_KEY][self.INFERENCE_PARAMETER_KEY]
            for infkey in self.INFERENCE_SUB_KEYS:
                if infkey in inf_params.keys():
                    pass
                else:
                    raise ValueError(
                        "Inference Sub Parameter '{}' is not found in the parameter file. "
                        "Please add it as a sub parameter of the inference parameter field".format(infkey)
                    )

        except KeyError:
            raise ValueError("'inference' sub Parameter not defined in the parameter file")

        try:
            digest_params = yaml_params[self.PARENT_PARAMETER_KEY][self.DIGEST_PARAMETER_KEY]
            for dkey in self.DIGEST_SUB_KEYS:
                if dkey in digest_params.keys():
                    pass
                else:
                    raise ValueError(
                        "Digest Sub Parameter '{}' is not found in the parameter file. "
                        "Please add it as a sub parameter of the digest parameter field".format(dkey)
                    )

        except KeyError:
            raise ValueError("'digest' sub Parameter not defined in the parameter file")

        try:
            parsimony_params = yaml_params[self.PARENT_PARAMETER_KEY][self.PARSIMONY_PARAMETER_KEY]
            for pkey in self.PARSIMONY_SUB_KEYS:
                if pkey in parsimony_params.keys():
                    pass
                else:
                    raise ValueError(
                        "Parsimony Sub Parameter '{}' is not found in the parameter file. "
                        "Please add it as a sub parameter of the parsimony parameter field".format(pkey)
                    )

        except KeyError:
            raise ValueError("'parsimony' sub Parameter not defined in the parameter file")

        try:
            pep_cen_params = yaml_params[self.PARENT_PARAMETER_KEY][self.PEPTIDE_CENTRIC_PARAMETER_KEY]
            for pckey in self.PEPTIDE_CENTRIC_SUB_KEYS:
                if pckey in pep_cen_params.keys():
                    pass
                else:
                    raise ValueError(
                        "Peptide Centric Sub Parameter '{}' is not found in the parameter file. "
                        "Please add it as a sub parameter of the peptide_centric parameter field".format(pckey)
                    )

        except KeyError:
            raise ValueError("'peptide_centric' sub Parameter not defined in the parameter file")

    def override_q_restrict(self, data):
        """
        ProteinInferenceParameter method to override restrict_q if the input data does not contain q values.

        Args:
            data (DataStore): [DataStore Object][pyproteininference.datastore.DataStore].

        """
        data_has_q = data.input_has_q()
        if data_has_q:
            pass
        else:
            if self.restrict_q:
                logger.warning("No Q values found in the input data, overriding parameters to not filter on Q value")
                self.restrict_q = None

    def override_pep_restrict(self, data):
        """
        ProteinInferenceParameter method to override restrict_pep if the input data does not contain pep values.

        Args:
            data (DataStore): [DataStore Object][pyproteininference.datastore.DataStore].

        """
        data_has_pep = data.input_has_pep()
        if data_has_pep:
            pass
        else:
            if self.restrict_pep:
                logger.warning(
                    "No Pep values found in the input data, overriding parameters to not filter on Pep value"
                )
                self.restrict_pep = None

    def override_custom_restrict(self, data):
        """
        ProteinInferenceParameter method to override restrict_custom if
        the input data does not contain custom score values.

        Args:
            data (DataStore): [DataStore Object][pyproteininference.datastore.DataStore].

        """
        data_has_custom = data.input_has_custom()
        if data_has_custom:
            pass
        else:
            if self.restrict_custom:
                logger.warning(
                    "No Custom values found in the input data, overriding parameters to not filter on Custom value"
                )
                self.restrict_custom = None

    def fix_parameters_from_datastore(self, data):
        """
        ProteinInferenceParameter method to override restriction values in the
        parameter file if those scores do not exist in the input files.

        Args:
            data (DataStore): [DataStore Object][pyproteininference.datastore.DataStore].

        """

        self.override_q_restrict(data=data)
        self.override_pep_restrict(data=data)
        self.override_custom_restrict(data=data)

    def _fix_none_parameters(self):
        """
        Internal ProteinInferenceParameter method to fix parameters that have been defined as None.
        These get read in as strings with YAML reader and need to be converted to None type.
        """

        self._fix_grouping_type()
        self._fix_lp_solver()
        self._fix_shared_peptides()

    def _fix_grouping_type(self):
        """
        Internal ProteinInferenceParameter method to override grouping type for None value.
        """
        if self.grouping_type in ["None", "none", None]:
            self.grouping_type = None

    def _fix_lp_solver(self):
        """
        Internal ProteinInferenceParameter method to override lp_solver for None value.
        """
        if self.lp_solver in ["None", "none", None]:
            self.lp_solver = None

    def _fix_shared_peptides(self):
        """
        Internal ProteinInferenceParameter method to override shared_peptides for None value.
        """
        if self.shared_peptides in ["None", "none", None]:
            self.shared_peptides = None