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

class TestTask(unittest.TestCase):
    def test_ranked_df_sorted_and_ranked(self):
        import user_code
        importlib.reload(user_code)
        data = {
            "smiles": [
                "CCO",
                "CCCN",
                "CC(=O)O",
                "CCN(CC)CC",
                "CCOC(=O)C"
            ],
            "predicted_activity": [0.23, 0.78, 0.12, 0.56, 0.44]
        }
        df = pd.DataFrame(data)
        result = user_code.rank_candidates(df)
        _dynamic_test(
            self,
            isinstance(result, pd.DataFrame),
            "Returned object is a DataFrame",
            f"Expected a DataFrame, got {type(result)}",
        )
        expected_order = ["CCCN", "CCN(CC)CC", "CCOC(=O)C", "CCO", "CC(=O)O"]
        _dynamic_test(
            self,
            list(result["smiles"]) == expected_order,
            "DataFrame is sorted by predicted_activity descending",
            f"Expected order {expected_order}, got {list(result['smiles'])}",
        )
        expected_ranks = [1, 2, 3, 4, 5]
        _dynamic_test(
            self,
            list(result["rank"]) == expected_ranks,
            "Ranks assigned correctly from 1 to N",
            f"Expected ranks {expected_ranks}, got {list(result['rank'])}",
        )

    def test_input_df_not_modified(self):
        import user_code
        importlib.reload(user_code)
        data = {
            "smiles": ["A", "B", "C"],
            "predicted_activity": [0.5, 0.7, 0.2]
        }
        df = pd.DataFrame(data)
        df_copy = df.copy(deep=True)
        user_code.rank_candidates(df)
        _dynamic_test(
            self,
            df.equals(df_copy),
            "Input DataFrame not modified in-place",
            "Input DataFrame was modified in-place, which is not allowed",
        )

    def test_rank_column_exists(self):
        import user_code
        importlib.reload(user_code)
        data = {
            "smiles": ["X", "Y"],
            "predicted_activity": [1.1, 2.2]
        }
        df = pd.DataFrame(data)
        result = user_code.rank_candidates(df)
        _dynamic_test(
            self,
            "rank" in result.columns,
            "Output DataFrame includes 'rank' column",
            "'rank' column missing from output DataFrame",
        )

    def test_handles_duplicate_scores(self):
        import user_code
        importlib.reload(user_code)
        data = {
            "smiles": ["A", "B", "C"],
            "predicted_activity": [0.5, 0.7, 0.7]
        }
        df = pd.DataFrame(data)
        result = user_code.rank_candidates(df)
        sorted_scores = list(result["predicted_activity"])
        _dynamic_test(
            self,
            sorted_scores == sorted(sorted_scores, reverse=True),
            "DataFrame sorted correctly even with duplicate scores",
            f"Expected descending scores, got {sorted_scores}",
        )
        expected_ranks = [1, 2, 3]
        _dynamic_test(
            self,
            list(result["rank"]) == expected_ranks,
            "Ranks assigned sequentially even with duplicate scores",
            f"Expected ranks {expected_ranks}, got {list(result['rank'])}",
        )

    def test_returns_new_dataframe(self):
        import user_code
        importlib.reload(user_code)
        data = {
            "smiles": ["A", "B", "C"],
            "predicted_activity": [0.5, 0.3, 0.7]
        }
        df = pd.DataFrame(data)
        result = user_code.rank_candidates(df)
        _dynamic_test(
            self,
            result is not df,
            "Function returns a new DataFrame object",
            "Function returned the same DataFrame object (in-place modification)",
        )

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

Dive into the world of chemoinformatics using Python! This course introduces you to essential concepts such as molecular representations, descriptors, similarity, clustering, and QSAR modeling. Through engaging theory and hands-on challenges, you'll learn to analyze chemical data, compute molecular properties, and build predictive models—all with beginner-friendly explanations and real-world examples.

Explore how molecules are represented digitally and learn to parse and interpret these representations using Python.

Learn how to compare molecules, find similar compounds, and group them for drug discovery applications.

Apply chemoinformatics techniques to screen and rank compound libraries for drug discovery.

Challenge: Screen Compounds Against Target Properties

Ratkaisu