Comparing **amino acid composition** across multiple proteins is a fundamental step in comparative proteomics. By visualizing these differences side by side, you can quickly spot trends, similarities, or unique features among protein sequences from different organisms or experimental conditions. In this challenge, you will build a visualization that plots the amino acid composition of several proteins as grouped bar charts, with each group representing one amino acid and each bar within a group representing a different protein.


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

class TestTask(unittest.TestCase):
    def setUp(self):
        # Ensure we re-load user_code for each test
        if "user_code" in sys.modules:
            del sys.modules["user_code"]
        import user_code
        importlib.reload(user_code)
        self.user_code = user_code
        self.amino_acids = [
            'A', 'R', 'N', 'D', 'C', 'E', 'Q', 'G', 'H', 'I',
            'L', 'K', 'M', 'F', 'P', 'S', 'T', 'W', 'Y', 'V'
        ]

    def test_function_exists(self):
        func = getattr(self.user_code, 'plot_amino_acid_compositions', None)
        _dynamic_test(
            self,
            callable(func),
            "Function plot_amino_acid_compositions is defined.",
            "Function plot_amino_acid_compositions is not defined or not callable."
        )

    def test_fraction_calculation(self):
        # Use a simple sequence with known composition
        seq = 'AAAACCCCGGGGTTTT'
        expected = {aa:0.0 for aa in self.amino_acids}
        expected['A'] = 4/16
        expected['C'] = 4/16
        expected['G'] = 4/16
        expected['T'] = 4/16
        func = getattr(self.user_code, 'plot_amino_acid_compositions', None)
        captured = {}
        # Patch plt.bar to capture values
        orig_bar = plt.bar
        bars = []
        def fake_bar(x, heights, width=None, label=None):
            bars.append((list(x), list(heights), width, label))
        plt.bar = fake_bar
        try:
            func([seq], ["TestProtein"])
        except Exception as e:
            plt.bar = orig_bar
            raise e
        finally:
            plt.bar = orig_bar
        found = False
        for x, heights, width, label in bars:
            if label == "TestProtein":
                for aa, frac in zip(self.amino_acids, heights):
                    if aa in expected:
                        _dynamic_test(
                            self,
                            abs(frac - expected[aa]) < 1e-8,
                            f"Fraction for {aa} is correct.",
                            f"Expected fraction for {aa}: {expected[aa]}, got: {frac}"
                        )
                found = True
        _dynamic_test(
            self,
            found,
            "Bar heights for protein captured successfully.",
            "Did not find bar heights for protein label 'TestProtein'."
        )

    def test_xticks_labels(self):
        func = getattr(self.user_code, 'plot_amino_acid_compositions', None)
        orig_xticks = plt.xticks
        xtick_calls = []
        def fake_xticks(*args, **kwargs):
            xtick_calls.append(args)
            return orig_xticks(*args, **kwargs)
        plt.xticks = fake_xticks
        try:
            func(["AAAACCCCGGGGTTTT"], ["TestProtein"])
        except Exception as e:
            plt.xticks = orig_xticks
            raise e
        finally:
            plt.xticks = orig_xticks
        found = False
        for args in xtick_calls:
            if len(args) > 1:
                labels = args[1]
                if isinstance(labels, (list, tuple)) and list(labels) == self.amino_acids:
                    found = True
        _dynamic_test(
            self,
            found,
            "X-axis tick labels include all 20 amino acids.",
            f"X-axis labels missing or incorrect: {xtick_calls}"
        )

    def test_legend_labels_custom(self):
        func = getattr(self.user_code, 'plot_amino_acid_compositions', None)
        orig_legend = plt.legend
        called = {}
        def fake_legend(*args, **kwargs):
            called['legend'] = True
            return orig_legend(*args, **kwargs)
        plt.legend = fake_legend
        try:
            func(["AAAKKK"], ["Alpha"])
        except Exception as e:
            plt.legend = orig_legend
            raise e
        finally:
            plt.legend = orig_legend
        _dynamic_test(
            self,
            called.get('legend', False),
            "Legend is displayed when custom protein labels are provided.",
            "Legend not displayed when custom labels are given."
        )

    def test_legend_labels_default(self):
        func = getattr(self.user_code, 'plot_amino_acid_compositions', None)
        orig_legend = plt.legend
        called = {'labels': []}
        orig_bar = plt.bar
        def fake_legend(*args, **kwargs):
            called['legend'] = True
            return orig_legend(*args, **kwargs)
        def fake_bar(x, heights, width=None, label=None):
            if label:
                called['labels'].append(label)
            return orig_bar(x, heights, width=width, label=label)
        plt.legend = fake_legend
        plt.bar = fake_bar
        try:
            func(["AAAKKK", "CCCGGG"], None)
        except Exception as e:
            plt.legend = orig_legend
            plt.bar = orig_bar
            raise e
        finally:
            plt.legend = orig_legend
            plt.bar = orig_bar
        _dynamic_test(
            self,
            called.get('legend', False),
            "Legend is displayed when default protein labels are used.",
            "Legend not displayed when default labels are used."
        )
        _dynamic_test(
            self,
            "Protein 1" in called['labels'] and "Protein 2" in called['labels'],
            "Default protein labels are used in the legend.",
            f"Default labels not present: {called['labels']}"
        )

    def test_handles_single_sequence(self):
        func = getattr(self.user_code, 'plot_amino_acid_compositions', None)
        # Should not error with a single protein
        try:
            func(["MKTFFVAGVILLLPLVSSQCVNLTTRTQ"], ["Test1"])
            passed = True
        except Exception as e:
            passed = False
        _dynamic_test(
            self,
            passed,
            "Function runs without error for a single protein.",
            "Function raises an error for a single protein."
        )

    def test_handles_multiple_sequences(self):
        func = getattr(self.user_code, 'plot_amino_acid_compositions', None)
        # Should not error with multiple proteins
        try:
            func([
                "MKTFFVAGVILLLPLVSSQCVNLTTRTQ",
                "MGLSDGEWQLVLNVWGKVEADIPGHGQEVLIRLFKG",
                "MKKFFDSRREQMKLQK"
            ], ["A", "B", "C"])
            passed = True
        except Exception as e:
            passed = False
        _dynamic_test(
            self,
            passed,
            "Function runs without error for multiple proteins.",
            "Function raises an error for multiple proteins."
        )

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: Compare Amino Acid Composition Across Proteins

Oplossing

Challenge: Compare Amino Acid Composition Across Proteins

Oplossing