
import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
from rdkit import Chem
from rdkit.Chem import AllChem, DataStructs

class TestTask(unittest.TestCase):
    def setUp(self):
        self.smiles = [
            "CCO",          # ethanol
            "CCCO",         # propanol
            "CCCCO",        # butanol
            "c1ccccc1",     # benzene
            "c1ccncc1",     # pyridine
            "CCN",          # ethylamine
            "CCCN",         # propylamine
            "CC(C)O"        # isopropanol
        ]

    def test_returns_list_of_clusters(self):
        import user_code
        importlib.reload(user_code)
        clusters = user_code.cluster_by_similarity(self.smiles)
        _dynamic_test(
            self,
            isinstance(clusters, list) and all(isinstance(c, list) for c in clusters),
            "Returns a list of clusters, each as a list of SMILES strings",
            f"Expected a list of lists, got: {type(clusters)} with elements: {[type(c) for c in clusters]}",
        )

    def test_each_smiles_appears_once(self):
        import user_code
        importlib.reload(user_code)
        clusters = user_code.cluster_by_similarity(self.smiles)
        flat = [s for cluster in clusters for s in cluster]
        unique = set(flat)
        _dynamic_test(
            self,
            len(flat) == len(unique),
            "Each SMILES string appears in exactly one cluster",
            f"Duplicates found in clusters: {flat}",
        )

    def test_all_smiles_present(self):
        import user_code
        importlib.reload(user_code)
        clusters = user_code.cluster_by_similarity(self.smiles)
        flat = [s for cluster in clusters for s in cluster]
        _dynamic_test(
            self,
            set(flat) == set(self.smiles),
            "All SMILES strings from the input list are present in the output clusters",
            f"Missing or extra SMILES: expected {set(self.smiles)}, got {set(flat)}",
        )

    def test_each_cluster_has_similar_pair(self):
        import user_code
        importlib.reload(user_code)
        clusters = user_code.cluster_by_similarity(self.smiles)
        for idx, cluster in enumerate(clusters):
            found_similar = False
            if len(cluster) == 1:
                # Singletons are allowed if no other molecule is similar
                found_similar = True
            else:
                mols = [Chem.MolFromSmiles(smi) for smi in cluster]
                fps = [AllChem.GetMorganFingerprintAsBitVect(m, 2) for m in mols]
                for i in range(len(fps)):
                    for j in range(i+1, len(fps)):
                        sim = DataStructs.TanimotoSimilarity(fps[i], fps[j])
                        if sim > 0.6:
                            found_similar = True
                            break
                    if found_similar:
                        break
            _dynamic_test(
                self,
                found_similar,
                f"Cluster {idx} contains at least one pair of molecules with Tanimoto similarity above 0.6",
                f"Cluster {idx} does not contain a pair with Tanimoto similarity above 0.6: {cluster}",
            )

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: Cluster a Compound Library

Solution