Fix lint and coverage

Author: jacob720

src/daq_config_server/converters/_converters.py

@@ -19,12 +19,12 @@ def beamline_parameters_to_dict(contents: str) -> dict[str, Any]:
     lines = contents.splitlines()
     config_pairs: dict[str, Any] = {}
 
-    # Get list of parameter keys and values
+    # Get dict of parameter keys and values
     for line in remove_comments(lines):
         splitline = line.split("=")
         if len(splitline) >= 2:
             param, value = line.split("=")
-            if param in config_pairs:
+            if param.strip() in config_pairs:
                 raise ValueError(f"Repeated key in parameters: {param}")
             config_pairs[param.strip()] = value.strip()
 
@@ -50,11 +50,13 @@ class DisplayConfig(BaseModel):
 
     @model_validator(mode="after")
     def check_zoom_levels_match_required(self):
-        if self.required_zoom_levels is not None and self.required_zoom_levels != set(
-            self.zoom_levels.keys()
+        existing_keys = set(self.zoom_levels.keys())
+        if (
+            self.required_zoom_levels is not None
+            and self.required_zoom_levels != existing_keys
         ):
             raise ValueError(
-                f"Zoom levels {set(self.zoom_levels.keys())} "
+                f"Zoom levels {existing_keys} "
                 f"do not match required zoom levels: {self.required_zoom_levels}"
             )
         return self
@@ -72,7 +74,7 @@ def display_config_to_dict(contents: str) -> DisplayConfig:
     crosshairY = 600
     zoomLevel = 2.0
     crosshairX = 700
-    crosshairY = 600
+    crosshairY = 800
 
     Example output:
     """

src/daq_config_server/converters/convert.py

@@ -1,13 +1,14 @@
 import json
 from pathlib import Path
+from typing import Any
 
 from pydantic import BaseModel
 
 import daq_config_server.converters._file_converter_map as file_converter_map
 from daq_config_server.converters._converter_utils import ConverterParseError
 
 
-def get_converted_file_contents(file_path: Path) -> dict:
+def get_converted_file_contents(file_path: Path) -> dict[str, Any]:
     with file_path.open("r", encoding="utf-8") as f:
         raw_contents = f.read()
     if converter := file_converter_map.FILE_TO_CONVERTER_MAP.get(str(file_path)):

tests/unit_tests/test_converters.py

@@ -16,7 +16,11 @@
     DisplayConfig,
     DisplayConfigData,
     beamline_parameters_to_dict,
+    beamline_pitch_lut,
+    beamline_roll_lut,
+    detector_xy_lut,
     display_config_to_dict,
+    undulator_energy_gap_lut,
     xml_to_dict,
 )
 from daq_config_server.converters.convert import get_converted_file_contents
@@ -36,6 +40,18 @@ def test_get_converted_file_contents_uses_converter_if_file_in_map(
     mock_convert_function.assert_called_once()
 
 
+def test_get_converted_file_contents_converts_pydantic_model_to_dict(
+    mock_file_converter_map: dict[str, Callable[[str], Any]],
+):
+    file_to_convert = TestDataPaths.TEST_GOOD_LUT_PATH
+    model = GenericLut(column_names=["column1", "column2"], rows=[[1, 2], [2, 3]])
+    mock_convert_function = MagicMock(return_value=model)
+    mock_file_converter_map[str(file_to_convert)] = mock_convert_function
+    result = get_converted_file_contents(file_to_convert)
+    assert isinstance(result, dict)
+    mock_convert_function.assert_called_once()
+
+
 def test_error_is_raised_if_file_cant_be_parsed(
     mock_file_converter_map: dict[str, Callable[[str], Any]],
 ):
@@ -64,6 +80,11 @@ def test_parsing_bad_lut_causes_error():
         parse_lut(contents, ("energy_eV", int), ("gap_mm", float))
 
 
+def test_lut_with_different_number_of_row_items_to_column_names_causes_error():
+    with pytest.raises(ValueError):
+        GenericLut(column_names=["column1", "column2"], rows=[[1, 2], [1, 2, 3]])
+
+
 def test_display_config_to_dict_gives_expected_result_and_can_be_jsonified():
     with open(TestDataPaths.TEST_GOOD_DISPLAY_CONFIG_PATH) as f:
         contents = f.read()
@@ -92,6 +113,29 @@ def test_display_config_to_dict_gives_expected_result_and_can_be_jsonified():
     json.dumps(result.model_dump())
 
 
+def test_display_config_with_wrong_zoom_levels_causes_error():
+    zoom_levels = {
+        1.0: DisplayConfigData(
+            bottomRightX=410,
+            bottomRightY=278,
+            crosshairX=541,
+            crosshairY=409,
+            topLeftX=383,
+            topLeftY=253,
+        ),
+        2.5: DisplayConfigData(
+            bottomRightX=388,
+            bottomRightY=322,
+            crosshairX=551,
+            crosshairY=410,
+            topLeftX=340,
+            topLeftY=283,
+        ),
+    }
+    with pytest.raises(ValueError):
+        DisplayConfig(zoom_levels=zoom_levels, required_zoom_levels=({1.0, 3.0}))
+
+
 def test_xml_to_dict_gives_expected_result_and_can_be_jsonified():
     with open(TestDataPaths.TEST_GOOD_XML_PATH) as f:
         contents = f.read()
@@ -121,7 +165,7 @@ def test_xml_to_dict_gives_expected_result_and_can_be_jsonified():
     json.dumps(result)
 
 
-def test_beamline_parameters_to_dict_gives_expected_result_and_can_be_jsonified():
+def test_beamline_parameters_to_dict_gives_expected_result():
     with open(TestDataPaths.TEST_BEAMLINE_PARAMETERS_PATH) as f:
         contents = f.read()
     with open(TestDataPaths.EXPECTED_BEAMLINE_PARAMETERS_JSON_PATH) as f:
@@ -130,13 +174,19 @@ def test_beamline_parameters_to_dict_gives_expected_result_and_can_be_jsonified(
     assert result == expected
 
 
-def test_bad_beamline_parameters_causes_error_to_be_raised():
+def test_bad_beamline_parameters_with_non_keyword_string_value_causes_error():
     with open(TestDataPaths.TEST_BAD_BEAMLINE_PARAMETERS_PATH) as f:
         contents = f.read()
     with pytest.raises(ValueError):
         beamline_parameters_to_dict(contents)
 
 
+def test_beam_line_parameters_with_repeated_key_causes_error():
+    input = "thing = 1\nthing = 2"
+    with pytest.raises(ValueError):
+        beamline_parameters_to_dict(input)
+
+
 def test_remove_comments_works_as_expected():
     input = [
         "This line should not be changed",
@@ -171,3 +221,81 @@ def test_parse_value_works_as_expected(
     parsed_value = parse_value(value, convert_to)
     assert parsed_value == expected_parsed_value
     assert type(parsed_value) is type(expected_parsed_value)
+
+
+def test_detector_xy_lut_gives_expected_results():
+    input = (
+        "# distance beamY beamX (values from mosflm)\n"
+        "Units mm mm mm\n"
+        "150 152.2 166.26\n"
+        "800 152.08 160.96\n"
+    )
+    expected = GenericLut(
+        column_names=["detector_distances_mm", "beam_centre_x_mm", "beam_centre_y_mm"],
+        rows=[[150, 152.2, 166.26], [800, 152.08, 160.96]],
+    )
+    result = detector_xy_lut(input)
+    assert result == expected
+
+
+def test_beam_line_pitch_lut_gives_expected_result():
+    input = (
+        "#       Bragg	pitch\n"
+        "#	Degree	values	for	pitch	are	interpreted	as	mrad\n"
+        "#	The	values	cannot	change	direction.\n"
+        "#       last update 2025/01/15 NP\n"
+        "Units Deg mrad\n"
+        "Units Deg Deg\n"
+        "16.40956 -0.62681\n"
+        "14.31123 -0.61833\n"
+        "12.69285 -0.61243\n"
+        "11.40557 -0.60849\n"
+    )
+    expected = GenericLut(
+        column_names=["bragg_angle_deg", "pitch_mrad"],
+        rows=[
+            [16.40956, -0.62681],
+            [14.31123, -0.61833],
+            [12.69285, -0.61243],
+            [11.40557, -0.60849],
+        ],
+    )
+    result = beamline_pitch_lut(input)
+    assert result == expected
+
+
+def test_beam_line_roll_lut_gives_expected_result():
+    input = (
+        "#Bragg angle against roll( absolute number)\n"
+        "#reloadLookupTables()\n"
+        "# last update 2024/06/20 NP\n"
+        "Units Deg mrad\n"
+        "26.4095 2.6154\n"
+        "6.3075  2.6154\n"
+    )
+    expected = GenericLut(
+        column_names=["bragg_angle_deg", "roll_mrad"],
+        rows=[[26.4095, 2.6154], [6.3075, 2.6154]],
+    )
+    result = beamline_roll_lut(input)
+    assert result == expected
+
+
+def test_undulator_gap_lut_gives_expected_result():
+    input = (
+        "#######################\n"
+        "#                     #\n"
+        "# 5.5mm CPMU 20/11/22 #\n"
+        "#                     #\n"
+        "Units eV mm\n"
+        "5700		5.4606\n"
+        "5760		5.5\n"
+        "6000		5.681\n"
+        "6500		6.045\n"
+    )
+    expected = GenericLut(
+        column_names=["energy_eV", "gap_mm"],
+        rows=[[5700, 5.4606], [5760, 5.5], [6000, 5.681], [6500, 6.045]],
+    )
+    result = undulator_energy_gap_lut(input)
+    assert result == expected