Пример #1
0
def main(argv=None):

    # Parse command line
    try:
        settings, args = process_command_line(None)

    except BaseException:
        return 1

    # Parse format config file
    try:
        rows = read_config_file_as_table(settings.format_config)

        our_file_list = [row["unified_path"] for row in rows]

    except ConfigException as ex:
        print ex.message
        return 1

    # Used database name "article_refactor_24_3_2016"
    header, final_table = merge_results(our_tables, their_tables,
                                        settings.threshold, settings.database)

    # Generate non formatted table
    output_path = os.path.join(settings.workdir, settings.output_file)
    temp_file_path = output_path + "_unformmated"

    with open(temp_file_path, "wb") as fl:

        fl.write("%s\n" % "\t".join(header))

        for row in final_table:
            fl.write("%s\n" % "\t".join(str(val) for val in row))

    # Format the temporary table
    format_final_table(temp_file_path, our_file_list, output_path)

    return 0
Пример #2
0
	return settings, args

def upload_tables(table_list):

	for our_file, table_name in table_list:
		print "*" * 100
		print "Uploading %s with name %s" % (our_file, table_name)
		upload_table(our_file, table_name)

	print "*" * 100



if __name__ == "__main__":
	settings, args = process_command_line(None)

	try: 
		config_rows = read_config_file_as_table(settings.config_file)

	except ConfigException as ex:
		print ex
		exit(1)

	table_list = zip([row["file_name"] for row in config_rows],
					 [row["table_name"] for row in config_rows])

	upload_tables(table_list)

	exit(0)
Пример #3
0
    return settings, args


def upload_tables(table_list):

    for our_file, table_name in table_list:
        print "*" * 100
        print "Uploading %s with name %s" % (our_file, table_name)
        upload_table(our_file, table_name)

    print "*" * 100


if __name__ == "__main__":
    settings, args = process_command_line(None)

    try:
        config_rows = read_config_file_as_table(settings.config_file)

    except ConfigException as ex:
        print ex
        exit(1)

    table_list = zip([row["file_name"] for row in config_rows],
                     [row["table_name"] for row in config_rows])

    upload_tables(table_list)

    exit(0)
Пример #4
0
def run():

    settings, args = process_command_line(None)

    try:
        config_rows = read_config_file_as_table(settings.config_file)

        if settings.unified_config_file:
            unified_config_rows = read_config_file_as_table(
                settings.unified_config_file)

    except ConfigException as ex:
        print ex
        return 1

    interaction_type_to_condition_files_dictionary = get_condition_files(
        config_rows)

    signif_dictionary = generate_signif_per_conditions_dictionary(config_rows)
    # max_lib_dictionary = generate_max_lib_per_condition_dictionary(config_rows)

    # Mark whether option was set
    categories_lists = {}

    # categories_lists = {DIV_OPTION_SIGNIF: signif_dictionary}
    if settings.signif:
        categories_lists[DIV_OPTION_SIGNIF] = signif_dictionary

    if settings.known_targets_file:
        known_pair_list = generate_known_pairs_list(
            settings.known_targets_file)
        categories_lists[DIV_OPTION_KNOWN_TARGETS] = known_pair_list

    if settings.no_binding_file:
        binding_pair_list = generate_binding_pairs_list(
            settings.no_binding_file)
        categories_lists[DIV_OPTION_BINDING] = binding_pair_list

    if settings.questionable_file:
        questionable_pair_list = generate_questionable_pairs_list(
            settings.questionable_file)
        categories_lists[DIV_OPTION_QUESTIONABLE] = questionable_pair_list

    interaction_to_condition_totals = {}
    interaction_to_condition_libs = {}
    interaction_to_condition_signif_libs = {}

    # Go over the files and make the total count of interactions per interaction type
    for interaction_type, condition_files_dictionary in interaction_type_to_condition_files_dictionary.items(
    ):

        interaction_to_condition_totals[interaction_type] = {}
        interaction_to_condition_libs[interaction_type] = {}
        interaction_to_condition_signif_libs[interaction_type] = {}

        for condition_name, file_list in condition_files_dictionary.items():

            interaction_to_condition_totals[interaction_type][
                condition_name] = {}
            interaction_to_condition_libs[interaction_type][
                condition_name] = {}
            interaction_to_condition_signif_libs[interaction_type][
                condition_name] = {}

            for file_path in file_list:

                fp = FileProcessor(
                    file_path, {
                        "read_count": CountHandler(),
                        "signif_lib_count": MaxLibHandler()
                    })

                fp.process()

                interactions_dct = fp.row_handlers["read_count"].dct
                max_signif_lib_dct = fp.row_handlers["signif_lib_count"].dct

                # Handle total count
                for name, count in interactions_dct.items():

                    # Add the name for the first time
                    if name not in interaction_to_condition_totals[
                            interaction_type][condition_name]:
                        interaction_to_condition_totals[interaction_type][
                            condition_name][name] = 0

                    # Increase the count
                    interaction_to_condition_totals[interaction_type][
                        condition_name][name] += count

                # Handle signif libs
                for name, lib_count in max_signif_lib_dct.items():

                    # Add the name for the first time
                    if name not in interaction_to_condition_signif_libs[
                            interaction_type][condition_name]:
                        interaction_to_condition_signif_libs[interaction_type][
                            condition_name][name] = 0

                    # Set the maximal lib
                    interaction_to_condition_signif_libs[interaction_type][condition_name][name] = \
                     max(interaction_to_condition_signif_libs[interaction_type][condition_name][name], lib_count)

                # Handle total libs
                for name, lib_count in interactions_dct.items():

                    # Add the name for the first time
                    if name not in interaction_to_condition_libs[
                            interaction_type][condition_name]:
                        interaction_to_condition_libs[interaction_type][
                            condition_name][name] = 0

                    # Set the maximal lib
                    interaction_to_condition_libs[interaction_type][
                        condition_name][name] += 1

    # Only if unified config file was inserted
    if settings.unified_config_file:

        unified_interaction_type_to_condition_files_dictionary = get_condition_files(
            unified_config_rows)

        unified_interaction_to_condition_totals = {}
        unified_interaction_to_condition_libs = {}

        for interaction_type, condition_files_dictionary in unified_interaction_type_to_condition_files_dictionary.items(
        ):

            unified_interaction_to_condition_totals[interaction_type] = {}
            unified_interaction_to_condition_libs[interaction_type] = {}

            for condition_name, file_list in condition_files_dictionary.items(
            ):

                unified_interaction_to_condition_totals[interaction_type][
                    condition_name] = {}

                for file_path in file_list:

                    fp = FileProcessor(
                        file_path, {
                            "lib_count":
                            UnifiedLibHandler(
                                interaction_to_condition_libs[interaction_type]
                                [condition_name])
                        })

                    fp.process()

                    unified_interaction_to_condition_libs[interaction_type][condition_name] = \
                     fp.row_handlers["lib_count"].dct

    # Generate group tables per condition
    for interaction_type, condition_totals in interaction_to_condition_totals.items(
    ):

        perms = []

        # Generate all permutations for the flags
        for i in range(len(categories_lists) + 1):
            values = [True] * i + [False] * (len(categories_lists) - i)
            perms += list(set(itertools.permutations(values)))

        # Generate the different groups according to t
        for permutation in perms:

            categories_results = {
                category: permutation[i]
                for i, category in enumerate(categories_lists.keys())
            }

            generate_table(
                interaction_type, condition_totals,
                interaction_to_condition_libs[interaction_type],
                interaction_to_condition_signif_libs[interaction_type],
                categories_results, categories_lists)

    # Generate unified tables
    if settings.unified_config_file:

        for interaction_type, condition_to_libs in unified_interaction_to_condition_libs.items(
        ):

            for condition_name, names_to_libs in condition_to_libs.items():

                with open(
                        "output/unified_%s_%s.table" %
                    (interaction_type, condition_name), "wb") as fl:

                    writer = csv.writer(fl,
                                        delimiter='\t',
                                        quotechar='|',
                                        quoting=csv.QUOTE_MINIMAL)
                    writer.writerow(["libs", "known", "unknown"])

                    libs_max = max(
                        set([int(val) for key, val in names_to_libs.items()]))

                    for i in range(libs_max + 1):
                        writer.writerow([
                            i,
                            sum([
                                1 for name, val in names_to_libs.items()
                                if val == i and is_known(
                                    name,
                                    categories_lists[DIV_OPTION_KNOWN_TARGETS])
                            ]),
                            sum([
                                1 for name, val in names_to_libs.items()
                                if val == i and not is_known(
                                    name,
                                    categories_lists[DIV_OPTION_KNOWN_TARGETS])
                            ])
                        ])

    return 0
Пример #5
0
def run():

	settings, args = process_command_line(None)

	try:
		config_rows = read_config_file_as_table(settings.config_file)

		if settings.unified_config_file:
			unified_config_rows = read_config_file_as_table(settings.unified_config_file)

	except ConfigException as ex:
		print ex
		return 1

	interaction_type_to_condition_files_dictionary = get_condition_files(config_rows)

	signif_dictionary = generate_signif_per_conditions_dictionary(config_rows)
	# max_lib_dictionary = generate_max_lib_per_condition_dictionary(config_rows)

	# Mark whether option was set
	categories_lists = {}

	# categories_lists = {DIV_OPTION_SIGNIF: signif_dictionary}
	if settings.signif:
		categories_lists[DIV_OPTION_SIGNIF] = signif_dictionary

	if settings.known_targets_file:
		known_pair_list = generate_known_pairs_list(settings.known_targets_file)
		categories_lists[DIV_OPTION_KNOWN_TARGETS] = known_pair_list

	if settings.no_binding_file:
		binding_pair_list = generate_binding_pairs_list(settings.no_binding_file)
		categories_lists[DIV_OPTION_BINDING] = binding_pair_list

	if settings.questionable_file:
		questionable_pair_list = generate_questionable_pairs_list(settings.questionable_file)
		categories_lists[DIV_OPTION_QUESTIONABLE] = questionable_pair_list

	interaction_to_condition_totals = {}
	interaction_to_condition_libs = {}
	interaction_to_condition_signif_libs = {}

	# Go over the files and make the total count of interactions per interaction type
	for interaction_type, condition_files_dictionary in interaction_type_to_condition_files_dictionary.items():

		interaction_to_condition_totals[interaction_type] = {}
		interaction_to_condition_libs[interaction_type] = {}
		interaction_to_condition_signif_libs[interaction_type] = {}

		for condition_name, file_list in condition_files_dictionary.items():

			interaction_to_condition_totals[interaction_type][condition_name] = {}
			interaction_to_condition_libs[interaction_type][condition_name] = {}
			interaction_to_condition_signif_libs[interaction_type][condition_name] = {}

			for file_path in file_list:

				fp = FileProcessor(file_path, {"read_count": CountHandler(),
											   "signif_lib_count": MaxLibHandler()})

				fp.process()

				interactions_dct = fp.row_handlers["read_count"].dct
				max_signif_lib_dct = fp.row_handlers["signif_lib_count"].dct

				# Handle total count
				for name, count in interactions_dct.items():

					# Add the name for the first time
					if name not in interaction_to_condition_totals[interaction_type][condition_name]:
						interaction_to_condition_totals[interaction_type][condition_name][name] = 0

					# Increase the count
					interaction_to_condition_totals[interaction_type][condition_name][name] += count

				# Handle signif libs
				for name, lib_count in max_signif_lib_dct.items():

					# Add the name for the first time
					if name not in interaction_to_condition_signif_libs[interaction_type][condition_name]:
						interaction_to_condition_signif_libs[interaction_type][condition_name][name] = 0

					# Set the maximal lib
					interaction_to_condition_signif_libs[interaction_type][condition_name][name] = \
						max(interaction_to_condition_signif_libs[interaction_type][condition_name][name], lib_count)

				# Handle total libs
				for name, lib_count in interactions_dct.items():

					# Add the name for the first time
					if name not in interaction_to_condition_libs[interaction_type][condition_name]:
						interaction_to_condition_libs[interaction_type][condition_name][name] = 0

					# Set the maximal lib
					interaction_to_condition_libs[interaction_type][condition_name][name] += 1


	# Only if unified config file was inserted
	if settings.unified_config_file:

		unified_interaction_type_to_condition_files_dictionary = get_condition_files(unified_config_rows)

		unified_interaction_to_condition_totals = {}
		unified_interaction_to_condition_libs = {}

		for interaction_type, condition_files_dictionary in unified_interaction_type_to_condition_files_dictionary.items():

			unified_interaction_to_condition_totals[interaction_type] = {}
			unified_interaction_to_condition_libs[interaction_type] = {}

			for condition_name, file_list in condition_files_dictionary.items():

				unified_interaction_to_condition_totals[interaction_type][condition_name] = {}

				for file_path in file_list:

					fp = FileProcessor(file_path, {"lib_count": UnifiedLibHandler(interaction_to_condition_libs[interaction_type][condition_name])})

					fp.process()

					unified_interaction_to_condition_libs[interaction_type][condition_name] = \
						fp.row_handlers["lib_count"].dct

	# Generate group tables per condition
	for interaction_type, condition_totals in interaction_to_condition_totals.items():

		perms = []

		# Generate all permutations for the flags
		for i in range(len(categories_lists) + 1):
			values = [True] * i + [False] * (len(categories_lists) - i)
			perms += list(set(itertools.permutations(values)))

		# Generate the different groups according to t
		for permutation in perms:

			categories_results = {category: permutation[i] for i, category in enumerate(categories_lists.keys())}

			generate_table(interaction_type,
						   condition_totals,
						   interaction_to_condition_libs[interaction_type],
						   interaction_to_condition_signif_libs[interaction_type],
						   categories_results,
						   categories_lists)

	# Generate unified tables
	if settings.unified_config_file:

		for interaction_type, condition_to_libs in unified_interaction_to_condition_libs.items():

			for condition_name, names_to_libs in condition_to_libs.items():

				with open("output/unified_%s_%s.table" % (interaction_type, condition_name), "wb") as fl:

					writer = csv.writer(fl, delimiter='\t', quotechar='|', quoting=csv.QUOTE_MINIMAL)
					writer.writerow(["libs", "known", "unknown"])

					libs_max = max(set([int(val) for key, val in names_to_libs.items()]))

					for i in range(libs_max + 1):
						writer.writerow([i,
										 sum([1 for name, val in names_to_libs.items() if val == i and is_known(name, categories_lists[DIV_OPTION_KNOWN_TARGETS])]),
										 sum([1 for name, val in names_to_libs.items() if val == i and not is_known(name, categories_lists[DIV_OPTION_KNOWN_TARGETS])])])

	return 0