def test_add_alpha_diversity_values_to_mapping_file(self):
        """checks a mapping file is added with the proper fields """

        # regular case no special cases for avg method
        expected_mapping_file_data = MAPPING_FILE_DATA_WITH_ALPHA_A
        expected_mapping_file_headers = ['SampleID', 'BarcodeSequence',
                                         'LinkerPrimerSequence', 'Treatment', 'DOB', 'Description',
                                         'chao1_alpha', 'chao1_normalized_alpha', 'chao1_alpha_label',
                                         'PD_whole_tree_alpha', 'PD_whole_tree_normalized_alpha',
                                         'PD_whole_tree_alpha_label']

        out_mapping_file_data, out_mapping_file_headers =\
            add_alpha_diversity_values_to_mapping_file(self.metrics,
                                                       self.sample_ids, self.alpha_diversity_data,
                                                       self.mapping_file_headers, self.mapping_file_data, 4, 'equal')

        self.assertEquals(out_mapping_file_data, expected_mapping_file_data)
        self.assertEquals(
            out_mapping_file_headers,
            expected_mapping_file_headers)

        # regular case no special cases for quantile method
        expected_mapping_file_data = MAPPING_FILE_DATA_WITH_ALPHA_B
        out_mapping_file_data, out_mapping_file_headers =\
            add_alpha_diversity_values_to_mapping_file(self.metrics,
                                                       self.sample_ids, self.alpha_diversity_data,
                                                       self.mapping_file_headers, self.mapping_file_data, 4, 'quantile')

        self.assertEquals(out_mapping_file_data, expected_mapping_file_data)
        self.assertEquals(
            out_mapping_file_headers,
            expected_mapping_file_headers)
    def test_add_alpha_diversity_values_to_mapping_file(self):
        """checks a mapping file is added with the proper fields """

        # regular case no special cases for avg method
        expected_mapping_file_data = MAPPING_FILE_DATA_WITH_ALPHA_A
        expected_mapping_file_headers = [
            'SampleID', 'BarcodeSequence', 'LinkerPrimerSequence', 'Treatment',
            'DOB', 'Description', 'chao1_alpha', 'chao1_normalized_alpha',
            'chao1_alpha_label', 'PD_whole_tree_alpha',
            'PD_whole_tree_normalized_alpha', 'PD_whole_tree_alpha_label'
        ]

        out_mapping_file_data, out_mapping_file_headers =\
            add_alpha_diversity_values_to_mapping_file(self.metrics,
                                                       self.sample_ids, self.alpha_diversity_data,
                                                       self.mapping_file_headers, self.mapping_file_data, 4, 'equal')

        self.assertEquals(out_mapping_file_data, expected_mapping_file_data)
        self.assertEquals(out_mapping_file_headers,
                          expected_mapping_file_headers)

        # regular case no special cases for quantile method
        expected_mapping_file_data = MAPPING_FILE_DATA_WITH_ALPHA_B
        out_mapping_file_data, out_mapping_file_headers =\
            add_alpha_diversity_values_to_mapping_file(self.metrics,
                                                       self.sample_ids, self.alpha_diversity_data,
                                                       self.mapping_file_headers, self.mapping_file_data, 4, 'quantile')

        self.assertEquals(out_mapping_file_data, expected_mapping_file_data)
        self.assertEquals(out_mapping_file_headers,
                          expected_mapping_file_headers)
    def test_add_alpha_diversity_values_to_mapping_file(self):
        """checks a mapping file is added with the proper fields """

        # regular case no special cases for avg method
        expected_mapping_file_data = MAPPING_FILE_DATA_WITH_ALPHA_A
        expected_mapping_file_headers = [
            "SampleID",
            "BarcodeSequence",
            "LinkerPrimerSequence",
            "Treatment",
            "DOB",
            "Description",
            "chao1_alpha",
            "chao1_normalized_alpha",
            "chao1_alpha_label",
            "PD_whole_tree_alpha",
            "PD_whole_tree_normalized_alpha",
            "PD_whole_tree_alpha_label",
        ]

        out_mapping_file_data, out_mapping_file_headers = add_alpha_diversity_values_to_mapping_file(
            self.metrics,
            self.sample_ids,
            self.alpha_diversity_data,
            self.mapping_file_headers,
            self.mapping_file_data,
            4,
            "equal",
        )

        self.assertEquals(out_mapping_file_data, expected_mapping_file_data)
        self.assertEquals(out_mapping_file_headers, expected_mapping_file_headers)

        # regular case no special cases for quantile method
        expected_mapping_file_data = MAPPING_FILE_DATA_WITH_ALPHA_B
        out_mapping_file_data, out_mapping_file_headers = add_alpha_diversity_values_to_mapping_file(
            self.metrics,
            self.sample_ids,
            self.alpha_diversity_data,
            self.mapping_file_headers,
            self.mapping_file_data,
            4,
            "quantile",
        )

        self.assertEquals(out_mapping_file_data, expected_mapping_file_data)
        self.assertEquals(out_mapping_file_headers, expected_mapping_file_headers)
Пример #4
0
def main():
    option_parser, opts, args = parse_command_line_parameters(**script_info)

    alpha_fps = opts.alpha_fps
    mapping_fp = opts.mapping_fp
    output_mapping_fp = opts.output_mapping_fp
    binning_method = opts.binning_method
    missing_value_name = opts.missing_value_name
    depth = opts.depth

    # make sure the number of bins is an integer
    try:
        number_of_bins = int(opts.number_of_bins)
    except ValueError:
        raise ValueError, 'The number of bins must be an integer, not %s'\
            % opts.number_of_bins

    # if using collated data, make sure they specify a depth
    if depth is not None:
        alpha_dict = {}

        # build up a dictionary with the filenames as keys and lines as values
        for single_alpha_fp in alpha_fps:
            alpha_dict[splitext(basename(single_alpha_fp))[0]] = open(
                single_alpha_fp, 'U').readlines()

        # format the collated data
        metrics, alpha_sample_ids, alpha_data = mean_alpha(alpha_dict,
            depth)

    # when not using collated data, the user can only specify one input file
    else:
        if len(alpha_fps) > 1:
            option_parser.error('A comma-separated list of files should only be'
                ' passed with the --alpha_fps option when using collated alpha '
                'diversity data and also selecting a rarefaction depth with the'
                ' --depth option.')
        else:
            metrics, alpha_sample_ids, alpha_data = parse_matrix(open(
                alpha_fps[0], 'U'))

    # parse the data from the files
    mapping_file_data, mapping_file_headers, comments = parse_mapping_file(
        open(mapping_fp, 'U'))

    # add the alpha diversity data to the mapping file
    out_mapping_file_data, out_mapping_file_headers = \
        add_alpha_diversity_values_to_mapping_file(metrics, alpha_sample_ids,
        alpha_data, mapping_file_headers, mapping_file_data, number_of_bins,
        binning_method, missing_value_name)

    # format the new data and write it down
    lines = format_mapping_file(out_mapping_file_headers, out_mapping_file_data)
    fd_out = open(output_mapping_fp, 'w')
    fd_out.writelines(lines)
    fd_out.close()
Пример #5
0
def main():
    option_parser, opts, args = parse_command_line_parameters(**script_info)

    alpha_fps = opts.alpha_fps
    mapping_fp = opts.mapping_fp
    output_mapping_fp = opts.output_mapping_fp
    binning_method = opts.binning_method
    missing_value_name = opts.missing_value_name
    depth = opts.depth
    number_of_bins = opts.number_of_bins
    collated_input = opts.collated_input

    # if using collated data, make sure they specify a depth
    if collated_input:
        alpha_dict = {}

        # build up a dictionary with the filenames as keys and lines as values
        for single_alpha_fp in alpha_fps:
            alpha_dict[splitext(basename(single_alpha_fp))[0]] = open(
                single_alpha_fp, 'U').readlines()

        # format the collated data
        try:
            metrics, alpha_sample_ids, alpha_data = mean_alpha(
                alpha_dict, depth)
        except ValueError as e:  # see mean_alpha for the possible exceptions
            option_parser.error(e.message)

    # when not using collated data, the user can only specify one input file
    else:
        if len(alpha_fps) > 1:
            option_parser.error(
                'A comma-separated list of files should only be'
                ' passed with the --alpha_fps option when using collated alpha '
                'diversity data and also selecting a rarefaction depth with the'
                ' --depth option.')
        else:
            metrics, alpha_sample_ids, alpha_data = parse_matrix(
                open(alpha_fps[0], 'U'))

    # parse the data from the files
    mapping_file_data, mapping_file_headers, comments = parse_mapping_file(
        open(mapping_fp, 'U'))

    # add the alpha diversity data to the mapping file
    out_mapping_file_data, out_mapping_file_headers = \
        add_alpha_diversity_values_to_mapping_file(metrics, alpha_sample_ids,
                                                   alpha_data, mapping_file_headers, mapping_file_data, number_of_bins,
                                                   binning_method, missing_value_name)

    # format the new data and write it down
    lines = format_mapping_file(out_mapping_file_headers,
                                out_mapping_file_data)
    fd_out = open(output_mapping_fp, 'w')
    fd_out.writelines(lines)
    fd_out.close()
Пример #6
0
                " passed with the --alpha_fps option when using collated alpha "
                "diversity data and also selecting a rarefaction depth with the"
                " --depth option."
            )
        else:
            metrics, alpha_sample_ids, alpha_data = parse_matrix(open(alpha_fps[0], "U"))

    # parse the data from the files
    mapping_file_data, mapping_file_headers, comments = parse_mapping_file(open(mapping_fp, "U"))

    # add the alpha diversity data to the mapping file
    out_mapping_file_data, out_mapping_file_headers = add_alpha_diversity_values_to_mapping_file(
        metrics,
        alpha_sample_ids,
        alpha_data,
        mapping_file_headers,
        mapping_file_data,
        number_of_bins,
        binning_method,
        missing_value_name,
    )

    # format the new data and write it down
    lines = format_mapping_file(out_mapping_file_headers, out_mapping_file_data)
    fd_out = open(output_mapping_fp, "w")
    fd_out.writelines(lines)
    fd_out.close()


if __name__ == "__main__":
    main()
    else:
        if len(alpha_fps) > 1:
            option_parser.error(
                'A comma-separated list of files should only be'
                ' passed with the --alpha_fps option when using collated alpha '
                'diversity data and also selecting a rarefaction depth with the'
                ' --depth option.')
        else:
            metrics, alpha_sample_ids, alpha_data = parse_matrix(
                open(alpha_fps[0], 'U'))

    # parse the data from the files
    mapping_file_data, mapping_file_headers, comments = parse_mapping_file(
        open(mapping_fp, 'U'))

    # add the alpha diversity data to the mapping file
    out_mapping_file_data, out_mapping_file_headers = \
        add_alpha_diversity_values_to_mapping_file(metrics, alpha_sample_ids,
        alpha_data, mapping_file_headers, mapping_file_data, number_of_bins,
        binning_method, missing_value_name)

    # format the new data and write it down
    lines = format_mapping_file(out_mapping_file_headers,
                                out_mapping_file_data)
    fd_out = open(output_mapping_fp, 'w')
    fd_out.writelines(lines)
    fd_out.close()


if __name__ == "__main__":
    main()