Visualizing the distribution of **GC content** across a dataset of DNA sequences is a fundamental task in genome analysis. By examining the **GC content**, you can quickly identify sequences with unusually high or low GC percentages, which may indicate special biological functions or sequencing artifacts. In this challenge, you will practice both calculating GC content and presenting your results visually using a bar chart, a standard approach in biological data visualization.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import user_code

class TestTask(unittest.TestCase):
    def test_gc_content_calculation(self):
        # Test correct GC content calculation for several sequences
        sequences = [
            "ATGCGCGTA",      # 5 G/C out of 9: 55.56
            "ATATATATAT",    # 0 G/C out of 10: 0
            "GGGCCCGGG",     # 9 G/C out of 9: 100
            "TTAACCGGTT",    # 4 G/C out of 10: 40
            "GCGCGCGCGC"     # 10 G/C out of 10: 100
        ]
        expected_gc = [
            5 / 9 * 100,
            0.0,
            100.0,
            4 / 10 * 100,
            100.0
        ]
        # Patch plt.show to prevent plot from blocking
        orig_show = plt.show
        plt.show = lambda *a, **kw: None
        try:
            importlib.reload(user_code)
            # Patch plt.bar to capture data
            bar_data = {}
            orig_bar = plt.bar
            def fake_bar(x, height, color=None, **kwargs):
                bar_data['x'] = x
                bar_data['height'] = height
                bar_data['color'] = color
                return orig_bar(x, height, color=color, **kwargs)
            plt.bar = fake_bar
            user_code.plot_gc_content(sequences)
        finally:
            plt.show = orig_show
            plt.bar = orig_bar
        heights = bar_data.get('height', [])
        _dynamic_test(
            self,
            all(abs(h - e) < 1.0 for h, e in zip(heights, expected_gc)),
            "GC content is correctly calculated for all sequences.",
            f"Expected GC contents: {expected_gc}, got: {heights}",
        )

    def test_bar_colors(self):
        # Test that bars with GC content > 60% are colored differently
        sequences = ["GGGG", "ATAT", "GCGC", "ATGC"] # GC%: 100, 0, 100, 50
        orig_show = plt.show
        plt.show = lambda *a, **kw: None
        importlib.reload(user_code)
        bar_data = {}
        orig_bar = plt.bar
        def fake_bar(x, height, color=None, **kwargs):
            bar_data['color'] = color
            return orig_bar(x, height, color=color, **kwargs)
        plt.bar = fake_bar
        try:
            user_code.plot_gc_content(sequences)
        finally:
            plt.show = orig_show
            plt.bar = orig_bar
        colors = bar_data.get('color', [])
        _dynamic_test(
            self,
            colors[0] == colors[2] and colors[0] != colors[1] and colors[0] != colors[3],
            "Bars with GC content above 60% are highlighted with a different color.",
            f"Expected color for high-GC bars to be different. Got: {colors}",
        )

    def test_xaxis_labels_and_ylim(self):
        # Test x-axis labels are sequence indices and y-axis is 0-100
        sequences = ["A", "C", "G", "T"]
        orig_show = plt.show
        plt.show = lambda *a, **kw: None
        importlib.reload(user_code)
        orig_xticks = plt.xticks
        orig_ylim = plt.ylim
        labels_captured = {}
        def fake_xticks(ticks, labels=None, **kwargs):
            labels_captured['ticks'] = ticks
            labels_captured['labels'] = labels
            return orig_xticks(ticks, labels, **kwargs)
        plt.xticks = fake_xticks
        ylim_captured = {}
        def fake_ylim(*args, **kwargs):
            if len(args) == 2:
                ylim_captured['ylim'] = args
            return orig_ylim(*args, **kwargs)
        plt.ylim = fake_ylim
        try:
            user_code.plot_gc_content(sequences)
        finally:
            plt.show = orig_show
            plt.xticks = orig_xticks
            plt.ylim = orig_ylim
        ticks = labels_captured.get('ticks', [])
        labels = labels_captured.get('labels', [])
        ylim = ylim_captured.get('ylim', (None, None))
        _dynamic_test(
            self,
            list(ticks) == list(range(len(sequences))) and all(str(i) == l for i, l in enumerate(labels)),
            "X-axis labels correspond to sequence indices.",
            f"Expected x-axis labels: {[str(i) for i in range(len(sequences))]}, got: {labels}",
        )
        _dynamic_test(
            self,
            ylim == (0, 100),
            "Y-axis is set from 0 to 100.",
            f"Expected y-axis limits (0, 100), got {ylim}",
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True

    return '\\n'.join(lines) if changed else code

if __name__ == "__main__":
    unittest.main()


test_main.py

Learn how Python is used in biology for analyzing DNA sequences, processing biological data, and visualizing research results. Includes hands-on examples with bioinformatics libraries.

Explore how Python can be used to analyze DNA and other biological sequences, including searching for motifs, calculating GC content, and basic sequence manipulations.

Delve into protein sequences, amino acid composition, and basic protein analysis using Python.

Learn how to visualize biological data using Python, including plotting sequence statistics and creating informative charts for research.

Challenge: Plot GC Content for a Dataset

Oplossing

Challenge: Plot GC Content for a Dataset

Oplossing