
import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import io
from contextlib import redirect_stdout
import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

class TestTask(unittest.TestCase):
    def setUp(self):
        # Patch plt.show to do nothing
        self._original_show = plt.show
        plt.show = lambda *args, **kwargs: None

    def tearDown(self):
        # Restore plt.show
        plt.show = self._original_show

    def test_curve_fit_used(self):
        import user_code
        importlib.reload(user_code)
        # Check that curve_fit is used in the function
        import ast
        with open('user_code.py', 'r') as f:
            tree = ast.parse(f.read())
        found = False
        for node in ast.walk(tree):
            if isinstance(node, ast.Call):
                if hasattr(node.func, 'id') and node.func.id == 'curve_fit':
                    found = True
                elif hasattr(node.func, 'attr') and node.func.attr == 'curve_fit':
                    found = True
        _dynamic_test(
            self,
            found,
            "Function uses curve_fit for fitting",
            "curve_fit not used in the function",
        )

    def test_fitted_parameters_printed(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.fit_and_plot_kinetics(
                np.array([0, 1, 2, 3, 4, 5]),
                np.array([1.0, 0.82, 0.67, 0.55, 0.45, 0.37])
            )
        output = f.getvalue()
        # Check that output contains at least two numbers separated by comma or space
        matches = re.findall(r'[-+]?\\d*\\.?\\d+(?:[eE][-+]?\\d+)?', output)
        _dynamic_test(
            self,
            len(matches) >= 2,
            "Function prints the optimized parameters",
            f"Expected parameters to be printed, got: '{output}'",
        )

    def test_plot_has_data_and_fit(self):
        import user_code
        importlib.reload(user_code)
        # Clear any existing figures
        plt.close('all')
        user_code.fit_and_plot_kinetics(
            np.array([0, 1, 2, 3, 4, 5]),
            np.array([1.0, 0.82, 0.67, 0.55, 0.45, 0.37])
        )
        fig = plt.gcf()
        ax = plt.gca()
        # There should be at least one Line2D and one PathCollection (scatter)
        lines = [obj for obj in ax.get_children() if isinstance(obj, matplotlib.lines.Line2D)]
        scatters = [obj for obj in ax.get_children() if isinstance(obj, matplotlib.collections.PathCollection)]
        has_scatter = len(scatters) > 0
        has_line = len(lines) > 0
        _dynamic_test(
            self,
            has_scatter and has_line,
            "Plot includes both experimental data (scatter) and fitted curve (line)",
            f"Expected both scatter and line plot, found: {len(scatters)} scatter, {len(lines)} lines",
        )

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

An engaging, hands-on course introducing Python programming through real-world chemistry problems. Learn to clean experimental data, perform molar calculations, visualize spectra, and analyze reaction rates using Python and scientific libraries.

Learn Python basics through chemistry-themed examples, focusing on variables, data types, and simple calculations relevant to laboratory work.

Dive into real-world chemistry data: clean, process, and analyze raw experimental results using Python.

Explore how to visualize and analyze chemical spectra and reaction rates using Python's scientific libraries.

Challenge: Analyze Reaction Kinetics

Ratkaisu

Challenge: Analyze Reaction Kinetics

Ratkaisu