
import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import pandas as pd
import importlib

class TestTask(unittest.TestCase):
    def setUp(self):
        self.data = {
            "Sample1": [100, 200, 300],
            "Sample2": [150, 250, 350],
            "Sample3": [120, 220, 320]
        }
        self.genes = ["GeneA", "GeneB", "GeneC"]
        self.counts_df = pd.DataFrame(self.data, index=self.genes)

    def test_returns_dict_with_required_keys(self):
        import user_code
        importlib.reload(user_code)
        summary = user_code.summarize_gene_counts(self.counts_df)
        expected_keys = {
            "total_counts_per_gene",
            "total_counts_per_sample",
            "mean_gene_total",
            "median_gene_total",
            "mean_sample_total",
            "median_sample_total"
        }
        _dynamic_test(
            self,
            isinstance(summary, dict) and expected_keys.issubset(summary.keys()),
            "Function returns dictionary with all required keys.",
            f"Returned: {summary}. Missing keys: {expected_keys - set(summary.keys()) if isinstance(summary, dict) else 'Not a dict'}"
        )

    def test_total_counts_per_gene(self):
        import user_code
        importlib.reload(user_code)
        summary = user_code.summarize_gene_counts(self.counts_df)
        gene_totals = summary.get("total_counts_per_gene", None)
        expected = pd.Series([370, 670, 970], index=["GeneA", "GeneB", "GeneC"])
        _dynamic_test(
            self,
            isinstance(gene_totals, pd.Series) and all(gene_totals == expected),
            "Correct total counts per gene.",
            f"Expected: {expected.values}, got: {gene_totals.values if isinstance(gene_totals, pd.Series) else gene_totals}"
        )

    def test_total_counts_per_sample(self):
        import user_code
        importlib.reload(user_code)
        summary = user_code.summarize_gene_counts(self.counts_df)
        sample_totals = summary.get("total_counts_per_sample", None)
        expected = pd.Series({
            "Sample1": 600,
            "Sample2": 750,
            "Sample3": 660
        })
        _dynamic_test(
            self,
            isinstance(sample_totals, pd.Series) and all(sample_totals == expected),
            "Correct total counts per sample.",
            f"Expected: {expected.values}, got: {sample_totals.values if isinstance(sample_totals, pd.Series) else sample_totals}"
        )

    def test_mean_and_median_gene_total(self):
        import user_code
        importlib.reload(user_code)
        summary = user_code.summarize_gene_counts(self.counts_df)
        gene_totals = pd.Series([370, 670, 970])
        mean_expected = gene_totals.mean()
        median_expected = gene_totals.median()
        _dynamic_test(
            self,
            abs(summary.get("mean_gene_total", 0) - mean_expected) < 1e-6,
            "Correct mean of total counts per gene.",
            f"Expected mean: {mean_expected}, got: {summary.get('mean_gene_total', None)}"
        )
        _dynamic_test(
            self,
            abs(summary.get("median_gene_total", 0) - median_expected) < 1e-6,
            "Correct median of total counts per gene.",
            f"Expected median: {median_expected}, got: {summary.get('median_gene_total', None)}"
        )

    def test_mean_and_median_sample_total(self):
        import user_code
        importlib.reload(user_code)
        summary = user_code.summarize_gene_counts(self.counts_df)
        sample_totals = pd.Series([600, 750, 660])
        mean_expected = sample_totals.mean()
        median_expected = sample_totals.median()
        _dynamic_test(
            self,
            abs(summary.get("mean_sample_total", 0) - mean_expected) < 1e-6,
            "Correct mean of total counts per sample.",
            f"Expected mean: {mean_expected}, got: {summary.get('mean_sample_total', None)}"
        )
        _dynamic_test(
            self,
            abs(summary.get("median_sample_total", 0) - median_expected) < 1e-6,
            "Correct median of total counts per sample.",
            f"Expected median: {median_expected}, got: {summary.get('median_sample_total', None)}"
        )

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

The `pandas` library provides powerful methods to quickly summarize and analyze tabular data, such as gene count tables. Here is how the `sum`, `mean`, and `median` methods work, especially when using the `axis` parameter:

- **sum**: Calculates the sum of values along a specified axis. Use `axis=1` to sum across columns (totals for each row/gene) and `axis=0` to sum across rows (totals for each column/sample);
- **mean**: Computes the average value along a given axis. Use `axis=1` for the mean across samples for each gene, or `axis=0` for the mean across genes for each sample;
- **median**: Finds the median value along a specified axis. Use `axis=1` for the median across samples for each gene, or `axis=0` for the median across genes for each sample.

For example, `counts_df.sum(axis=1)` returns the total counts for each gene by summing values across all samples. Setting `axis=0` instead returns totals for each sample by summing across all genes. The same logic applies for `mean` and `median`. This flexibility allows you to easily calculate summary statistics for either genes or samples in your dataset.

Note

A beginner-friendly course introducing Python programming through real-world bioinformatics problems. Learn to handle biological data formats, analyze DNA sequences, process next-generation sequencing data, and build reproducible analysis pipelines—all with engaging, hands-on tasks and clear explanations.

Dive into sequence analysis techniques, including alignment basics and motif searching, to uncover biological insights from DNA and protein sequences.

Learn how to process next-generation sequencing (NGS) data, including read quality analysis and coverage calculations, using Python.

Explore gene expression analysis using RNA-seq data and learn how to build reproducible bioinformatics workflows with Python.

Challenge: Summarize Gene Counts

解答