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 Descriptors, Crippen

class TestTask(unittest.TestCase):
    def test_returns_dict(self):
        import user_code
        importlib.reload(user_code)
        smiles_list = ["CCO", "c1ccccc1", "CC(=O)O", "invalid"]
        result = user_code.compute_descriptors(smiles_list)
        _dynamic_test(
            self,
            isinstance(result, dict) and all(s in result for s in smiles_list),
            "Returns a dictionary mapping each input SMILES.",
            f"Expected dictionary with all input SMILES keys, got: {result}",
        )

    def test_valid_smiles_values(self):
        import user_code
        importlib.reload(user_code)
        smiles_list = ["CCO", "c1ccccc1", "CC(=O)O"]
        result = user_code.compute_descriptors(smiles_list)
        for smi in smiles_list:
            value = result.get(smi, None)
            _dynamic_test(
                self,
                isinstance(value, dict) and 'molecular_weight' in value and 'logP' in value,
                f"Valid SMILES '{smi}' returns correct descriptor dictionary.",
                f"Expected dict with 'molecular_weight' and 'logP' for '{smi}', got: {value}",
            )
            if isinstance(value, dict):
                mol = Chem.MolFromSmiles(smi)
                mw = Descriptors.MolWt(mol)
                logp = Crippen.MolLogP(mol)
                _dynamic_test(
                    self,
                    abs(value['molecular_weight'] - mw) < 0.001 and abs(value['logP'] - logp) < 0.001,
                    f"Correct molecular weight and logP for '{smi}'.",
                    f"Expected mw={mw}, logP={logp}, got {value}",
                )

    def test_invalid_smiles(self):
        import user_code
        importlib.reload(user_code)
        # Empty string "" is valid in RDKit (returns an empty molecule with 0.0 descriptors),
        # so we test only truly invalid SMILES here.
        smiles_list = ["invalid", "C1CC1C@"]
        result = user_code.compute_descriptors(smiles_list)
        for smi in smiles_list:
            value = result.get(smi, None)
            _dynamic_test(
                self,
                value is None,
                f"Invalid SMILES '{smi}' returns None.",
                f"Expected None for invalid SMILES '{smi}', got: {value}",
            )

    def test_mixed_valid_invalid(self):
        import user_code
        importlib.reload(user_code)
        smiles_list = ["CCO", "invalid", "CC(=O)O"]
        result = user_code.compute_descriptors(smiles_list)
        _dynamic_test(
            self,
            result["CCO"] is not None and result["invalid"] is None and result["CC(=O)O"] is not None,
            "Correctly handles list with both valid and invalid SMILES.",
            f"Expected valid SMILES to have descriptor dict and invalid to be None, got: {result}",
        )

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: Compute Descriptors for a Compound Library

解答