
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.device_data = pd.DataFrame({
            'device_id': ['A01', 'A02', 'A03', 'A04', 'A05'],
            'reading': [22.5, 35.1, -10.2, 28.0, 48.7]
        })
        self.min_value = 0.0
        self.max_value = 40.0

    def test_rows_within_range_only(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.clean_and_transform_device_data(self.device_data, self.min_value, self.max_value)
        # Only rows with reading between 0 and 40 (inclusive) should remain
        expected_ids = ['A01', 'A02', 'A04']
        actual_ids = list(result['device_id']) if result is not None and 'device_id' in result else []
        _dynamic_test(
            self,
            actual_ids == expected_ids,
            f"Rows with readings in range [{self.min_value}, {self.max_value}] are kept only.",
            f"Expected device_ids {expected_ids}, got {actual_ids}.",
        )

    def test_reading_fahrenheit_column_exists(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.clean_and_transform_device_data(self.device_data, self.min_value, self.max_value)
        _dynamic_test(
            self,
            result is not None and 'reading_fahrenheit' in result.columns,
            "New column 'reading_fahrenheit' exists.",
            "Column 'reading_fahrenheit' does not exist in result.",
        )

    def test_reading_fahrenheit_values_correct(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.clean_and_transform_device_data(self.device_data, self.min_value, self.max_value)
        # Check conversion for each remaining row
        if result is not None and 'reading' in result.columns and 'reading_fahrenheit' in result.columns:
            for i, row in result.iterrows():
                c = row['reading']
                f = row['reading_fahrenheit']
                expected_f = c * 9/5 + 32
                _dynamic_test(
                    self,
                    abs(f - expected_f) < 1e-6,
                    f"reading_fahrenheit for reading {c} is correct.",
                    f"Expected {expected_f} for reading {c}, got {f}.",
                )
        else:
            _dynamic_test(
                self,
                False,
                "",
                "Result DataFrame missing required columns.",
            )

    def test_shape_and_content(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.clean_and_transform_device_data(self.device_data, self.min_value, self.max_value)
        # The result should have 3 rows and 3 columns
        _dynamic_test(
            self,
            result is not None and result.shape == (3, 3),
            "Result DataFrame has correct shape (3, 3).",
            f"Result shape expected (3, 3), got {None if result is None else result.shape}.",
        )
        # Check device_id order and readings
        expected = pd.DataFrame({
            'device_id': ['A01', 'A02', 'A04'],
            'reading': [22.5, 35.1, 28.0],
            'reading_fahrenheit': [22.5*9/5+32, 35.1*9/5+32, 28.0*9/5+32]
        })
        if result is not None:
            for idx, row in expected.iterrows():
                actual_row = result.iloc[idx] if idx < len(result) else None
                _dynamic_test(
                    self,
                    actual_row is not None and actual_row['device_id'] == row['device_id'] and abs(actual_row['reading'] - row['reading']) < 1e-6 and abs(actual_row['reading_fahrenheit'] - row['reading_fahrenheit']) < 1e-6,
                    f"Row {idx} matches expected values.",
                    f"Row {idx} does not match. Expected {row.to_dict()}, got {None if actual_row is None else actual_row.to_dict()}.",
                )

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

Master Python as a powerful tool for automation engineering. This course guides you through practical and advanced Python techniques to automate repetitive tasks, analyze data, and interact with systems, all tailored for automation engineers. Each section blends engaging theory with hands-on, real-world challenges.

Learn how Python can automate repetitive and time-consuming tasks commonly faced by automation engineers, from log parsing to report generation.

Dive into data manipulation and analysis using Python and pandas, tailored for automation engineers handling structured data.

Master Python techniques for interacting with systems, automating tests, and analyzing results—core skills for automation engineers.

Challenge: Clean and Transform Device Data

Ratkaisu