In comparative genomics, visualizing the relationship between DNA sequence length and GC content can reveal important patterns, such as evolutionary adaptations or sequencing artifacts. This challenge will help you integrate your knowledge of sequence analysis and biological data visualization by creating a scatter plot that displays both sequence length and GC content for a collection of DNA sequences. You will also enhance your plot by labeling outlier sequences and optionally color-coding points by group, which is a common requirement when comparing data from different sources or species.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import types
import numpy as np

class TestTask(unittest.TestCase):
    def setUp(self):
        self.sequences = [
            "ATGCGCGTAC",      # 10, 60.0
            "ATATATATATAT",    # 12, 0.0
            "CGCGCGCGCGCGCGCGCGCG", # 20, 100.0
            "ATGC",            # 4, 50.0
            "GGGGGGGGGGGGGG",  # 14, 100.0
            "TATATATATATA",    # 12, 0.0
            "ATGCGC",          # 6, 66.666...
            "ATATATAT",        # 8, 0.0
            "GCGCGCGCGCGC",    # 12, 100.0
            "ATGCGTACGTAGCTAGCTAGCTAGCTAGCTA" # 31, 48.387...
        ]
        self.groups = ["A", "A", "B", "A", "B", "A", "A", "A", "B", "B"]

    def test_gc_content_calculation(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'calculate_gc_content', None)
        _dynamic_test(
            self,
            callable(func),
            "calculate_gc_content is defined and callable",
            "calculate_gc_content is not defined or not callable"
        )
        expected_gc = [60.0, 0.0, 100.0, 50.0, 100.0, 0.0, 66.66666666666666, 0.0, 100.0, 48.38709677419355]
        for seq, exp in zip(self.sequences, expected_gc):
            result = func(seq)
            _dynamic_test(
                self,
                isinstance(result, (float, int)) and abs(result - exp) < 1e-2,
                f"GC content correct for '{seq}'",
                f"Expected {exp} for '{seq}', got {result}"
            )

    def test_sequence_length(self):
        import user_code
        importlib.reload(user_code)
        plot_func = getattr(user_code, 'plot_length_gc', None)
        _dynamic_test(
            self,
            callable(plot_func),
            "plot_length_gc is defined and callable",
            "plot_length_gc is not defined or not callable"
        )
        # Test length extraction
        lengths = [len(seq) for seq in self.sequences]
        # For this test, monkeypatch calculate_gc_content to avoid plotting
        orig_gc = getattr(user_code, 'calculate_gc_content', None)
        called_lengths = []
        def fake_gc(seq):
            called_lengths.append(len(seq))
            return 0.0
        setattr(user_code, 'calculate_gc_content', fake_gc)
        try:
            plot_func(self.sequences)
        except Exception:
            pass
        _dynamic_test(
            self,
            called_lengths == lengths,
            "Sequence lengths are correctly calculated",
            f"Expected lengths {lengths}, got {called_lengths}"
        )
        setattr(user_code, 'calculate_gc_content', orig_gc)

    def test_scatter_plot_points(self):
        import user_code
        import matplotlib
        import matplotlib.pyplot as plt
        importlib.reload(user_code)
        plot_func = getattr(user_code, 'plot_length_gc', None)
        # Monkeypatch plt.show to avoid GUI
        plt_show_called = {'called': False}
        orig_show = plt.show
        def fake_show():
            plt_show_called['called'] = True
            plt.close('all')
        plt.show = fake_show
        # Call with known data
        try:
            plot_func(self.sequences)
        except Exception:
            pass
        _dynamic_test(
            self,
            plt_show_called['called'],
            "Scatter plot is displayed (plt.show called)",
            "Scatter plot was not displayed (plt.show not called)"
        )
        plt.show = orig_show

    def test_outlier_labeling(self):
        import user_code
        import matplotlib.pyplot as plt
        importlib.reload(user_code)
        plot_func = getattr(user_code, 'plot_length_gc', None)
        # Monkeypatch annotate to record calls
        called_labels = []
        orig_annotate = plt.Axes.annotate
        def fake_annotate(self, *args, **kwargs):
            called_labels.append(args[0])
            return orig_annotate(self, *args, **kwargs)
        plt.Axes.annotate = fake_annotate
        orig_show = plt.show
        plt.show = lambda: None
        try:
            plot_func(self.sequences)
        except Exception:
            pass
        _dynamic_test(
            self,
            any("Seq" in str(label) for label in called_labels),
            "Outlier points are labeled",
            f"No outlier labels found: {called_labels}"
        )
        plt.Axes.annotate = orig_annotate
        plt.show = orig_show

    def test_color_by_group(self):
        import user_code
        import matplotlib.pyplot as plt
        importlib.reload(user_code)
        plot_func = getattr(user_code, 'plot_length_gc', None)
        # Monkeypatch scatter to capture color argument
        colors_used = []
        orig_scatter = plt.Axes.scatter
        def fake_scatter(self, x, y, *args, **kwargs):
            colors_used.append(kwargs.get('c', None))
            return orig_scatter(self, x, y, *args, **kwargs)
        plt.Axes.scatter = fake_scatter
        orig_show = plt.show
        plt.show = lambda: None
        try:
            plot_func(self.sequences, self.groups)
        except Exception:
            pass
        _dynamic_test(
            self,
            any(isinstance(c, list) or isinstance(c, np.ndarray) for c in colors_used),
            "Points are colored by group when group argument is provided",
            f"Group coloring not applied. Colors used: {colors_used}"
        )
        plt.Axes.scatter = orig_scatter
        plt.show = orig_show

    def test_color_single(self):
        import user_code
        import matplotlib.pyplot as plt
        importlib.reload(user_code)
        plot_func = getattr(user_code, 'plot_length_gc', None)
        # Monkeypatch scatter to capture color argument
        colors_used = []
        orig_scatter = plt.Axes.scatter
        def fake_scatter(self, x, y, *args, **kwargs):
            colors_used.append(kwargs.get('c', None))
            return orig_scatter(self, x, y, *args, **kwargs)
        plt.Axes.scatter = fake_scatter
        orig_show = plt.show
        plt.show = lambda: None
        try:
            plot_func(self.sequences)
        except Exception:
            pass
        _dynamic_test(
            self,
            any(isinstance(c, str) for c in colors_used),
            "Points are colored with a single color when no group is provided",
            f"Single color not used. Colors used: {colors_used}"
        )
        plt.Axes.scatter = orig_scatter
        plt.show = orig_show

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: Visualize Sequence Length and GC Content

Oplossing