[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Author: pre-commit-ci[bot]

src/python/impactx/dashboard/Input/visualization/lattice/statistics.py

@@ -82,7 +82,9 @@ def update_element_counts() -> dict[str, int]:
 
         state.lattice_is_empty = len(counts) == 0
         # sort from desc. so we see top elements left to right
-        sorted_counts = dict(sorted(counts.items(), key=lambda item: item[1], reverse=True))
+        sorted_counts = dict(
+            sorted(counts.items(), key=lambda item: item[1], reverse=True)
+        )
 
         state.element_counts = sorted_counts
         return sorted_counts

src/python/impactx/dashboard/Toolbar/file_imports/python/lattice_helper.py

@@ -1,5 +1,6 @@
 import re
-from typing import Dict, List, Set, Any
+from typing import Any, Dict, List
+
 
 class DashboardLatticeParser:
     """
@@ -15,7 +16,7 @@ def __init__(self, content: str):
     def parse(self) -> Dict[str, Any]:
         """
         Extracts the lattice configuration from provided ImpactX simulation file.
-        
+
         Example return:
         {
             "lattice_elements": [
@@ -44,21 +45,21 @@ def parse(self) -> Dict[str, Any]:
                     print(f"Warning: Unsupported operation type: {operation_type}")
 
         clean_lattice_list = self.replace_variables(expanded_elements)
-        clean_lattice_list_str = '\n'.join(clean_lattice_list)
+        clean_lattice_list_str = "\n".join(clean_lattice_list)
         result = self.parse_cleaned_lattice(clean_lattice_list_str)
 
         return result
 
     def parse_cleaned_lattice(self, content: str) -> Dict[str, List[Dict[str, Any]]]:
         """
         Parses the lattice elements from the ImpactX simulation file content.
-        
+
         Extracts element names and their parameters from constructor calls in the format:
         elements.ElementName(param1=value1, param2=value2, ...)
-        
+
         EX:
             elements.Drift(ds=1.0)
-                
+
             Results in:
             {
                 "lattice_elements": [
@@ -68,7 +69,7 @@ def parse_cleaned_lattice(self, content: str) -> Dict[str, List[Dict[str, Any]]]
                     }
                 ]
             }
-            
+
         :param content: The content of the ImpactX simulation file.
         :return: A dictionary containing the parsed lattice elements.
         """
@@ -79,10 +80,7 @@ def parse_cleaned_lattice(self, content: str) -> Dict[str, List[Dict[str, Any]]]
         lattice_elements = re.findall(element_pattern, content, re.DOTALL)
 
         for element_name, parameter in lattice_elements:
-            element = {
-                "name": element_name,
-                "parameters": {}
-            }
+            element = {"name": element_name, "parameters": {}}
 
             # CHANGE: Updated parameter pattern to handle multiline and whitespace around =
             # OLD: r"(\w+)=([^,\)]+)"
@@ -97,11 +95,10 @@ def parse_cleaned_lattice(self, content: str) -> Dict[str, List[Dict[str, Any]]]
 
         return dictionary
 
-
     def collect_lattice_operations(self, debug: bool = False) -> List[Dict[str, str]]:
         """
         Collects lattice operations (sim.lattice.append(), sim.lattice.extend(), and variable.reverse() calls)
-        in the order they appear in the content.   
+        in the order they appear in the content.
 
         EX:
             sim.lattice.append(monitor) ; sim.lattice.extend([drift1, quad1]) ; lattice_half.reverse()
@@ -125,12 +122,16 @@ def collect_lattice_operations(self, debug: bool = False) -> List[Dict[str, str]
         # Store sim.lattice.append and sim.lattice.extend calls
         for match in re.finditer(lattice_call_pattern, self._content):
             operation, arg = match.groups()
-            operations.append((match.start(), {"type": operation, "argument": arg.strip()}))
+            operations.append(
+                (match.start(), {"type": operation, "argument": arg.strip()})
+            )
 
         # Store .reverse() calls
         reverse_pattern = r"(\w+)\.reverse\(\)"
         for match in re.finditer(reverse_pattern, self._content):
-            operations.append((match.start(), {"type": "reverse", "argument": match.group(1)}))
+            operations.append(
+                (match.start(), {"type": "reverse", "argument": match.group(1)})
+            )
 
         # important: sort operations by their position in the content
         # since the for loops can be executed in any order
@@ -145,33 +146,33 @@ def _get_variable_assignments(self) -> Dict[str, str]:
         """
         Helper function to extract all variable list assignments from content.
         Caches the result to avoid re-parsing the same content.
-        
+
         EX:
             content = '''
                 drift1 = elements.Drift(ds=1.0)
                 cell = [drift1, quad1]
                 line = [cell, monitor]
             '''
             _get_variable_assignments()
-                
+
             Results in:
                 {
                     "cell": "drift1, quad1",
                     "line": "cell, monitor"
                 }
-        
+
         """
         if self._content_hash in self._variable_assignments_cache:
             return self._variable_assignments_cache[self._content_hash]
-        
+
         variable_assignments = {}
         var_assignment_pattern = r"(\w+)\s*=\s*\[(.*?)\]"
-        
+
         for match in re.finditer(var_assignment_pattern, self._content, re.DOTALL):
             var_name = match.group(1)
             list_content = match.group(2)
             variable_assignments[var_name] = list_content
-        
+
         self._variable_assignments_cache[self._content_hash] = variable_assignments
         return variable_assignments
 
@@ -187,7 +188,7 @@ def _flatten(self, variable_name: str, debug: bool = False) -> List[str]:
                 sim.lattice.extend(line)
             '''
             _flatten(content, "line")
-                
+
             Results in:
                 ["drift1", "quad1", "drift1", "quad1"]
 
@@ -199,22 +200,28 @@ def _flatten(self, variable_name: str, debug: bool = False) -> List[str]:
         cache_key = f"{self._content_hash}:{variable_name}"
         if cache_key in self._flatten_cache:
             return self._flatten_cache[cache_key]
-        
+
         # Get variable assignments (cached)
         variable_assignments = self._get_variable_assignments()
-        
+
         # Check if the input is an inline list like "[monitor, elements.Drift(...)]"
         if variable_name.startswith("[") and variable_name.endswith("]"):
             list_contents = variable_name[1:-1]
             # split on commas that are NOT inside parentheses
-            list_to_flatten = [element.strip() for element in re.split(r",\s*(?![^()]*\))", list_contents) if element.strip()]
+            list_to_flatten = [
+                element.strip()
+                for element in re.split(r",\s*(?![^()]*\))", list_contents)
+                if element.strip()
+            ]
         else:
             if variable_name not in variable_assignments:
                 self._flatten_cache[cache_key] = [variable_name]
                 return [variable_name]  # It's not a list, it's a single element
 
             list_content = variable_assignments[variable_name]
-            list_to_flatten = [item.strip() for item in list_content.split(",") if item.strip()]
+            list_to_flatten = [
+                item.strip() for item in list_content.split(",") if item.strip()
+            ]
 
         expanded = []
         for item in list_to_flatten:
@@ -224,9 +231,8 @@ def _flatten(self, variable_name: str, debug: bool = False) -> List[str]:
 
         # Cache the result
         self._flatten_cache[cache_key] = expanded
-        
-        return expanded
 
+        return expanded
 
     def replace_variables(self, raw_lattice: List[str]) -> List[str]:
         """
@@ -237,7 +243,7 @@ def replace_variables(self, raw_lattice: List[str]) -> List[str]:
                 drift1 = elements.Drift(ds=1.0)
                 quad1 = elements.Quad(k=0.5)
                 raw_lattice = ["drift1", "quad1"]
-            (output)    
+            (output)
                 raw_lattice = ["elements.Drift(ds=1.0)", "elements.Quad(k=0.5)"]
 
         :param raw_lattice: List of lattice element variable names or constructor calls, e.g. ["drift1", "quad1"].
@@ -259,7 +265,7 @@ def replace_variables(self, raw_lattice: List[str]) -> List[str]:
         # Replace each item in the list
         # later can be optimized by not iterating over the whole raw_lattice list
         return [element_mapping.get(item, item) for item in raw_lattice]
-        
+
     def extract_lattice_inputs(self, parsed_lattice: Dict[str, Any]) -> List[str]:
         """
         Extracts all parameter values from parsed lattice data.
@@ -303,8 +309,7 @@ def _apply_reverse(self, var_name: str) -> None:
         # Clear the flatten cache so future lookups rebuild the list using the new reversed order.
         self._flatten_cache.clear()
 
-
-    #-----------------------------------------------------------------------------
+    # -----------------------------------------------------------------------------
     # Debug methods
     # -----------------------------------------------------------------------------
 

src/python/impactx/dashboard/Toolbar/file_imports/python/parser.py

@@ -71,8 +71,10 @@ def parse_impactx_simulation_file(file) -> None:
         lattice_contents = lattice_parser.parse()
 
         used_inputs = lattice_parser.extract_lattice_inputs(lattice_contents)
-        variable_contents = DashboardParserHelper.parse_variables(file_content, used_inputs)
-        
+        variable_contents = DashboardParserHelper.parse_variables(
+            file_content, used_inputs
+        )
+
         parsed_values_dictionary = {
             **single_input_contents,
             **list_input_contents,

src/python/impactx/dashboard/Toolbar/file_imports/ui_populator.py

@@ -6,7 +6,6 @@
 License: BSD-3-Clause-LBNL
 """
 
-from copy import error
 from ... import ctrl, state
 from ...Input.lattice.ui import add_lattice_element
 from ...Input.lattice.variable_handler import LatticeVariableHandler
@@ -22,7 +21,9 @@ def on_import_file_change(import_file, **kwargs):
             populate_impactx_simulation_file_to_ui(import_file)
         except Exception as error:
             state.import_file_error = True
-            state.import_file_error_message = f"Unable to parse because of the following error: {error}"
+            state.import_file_error_message = (
+                f"Unable to parse because of the following error: {error}"
+            )
         finally:
             state.importing_file = False
 

tests/python/dashboard/test_impactx_examples_import.py

@@ -7,8 +7,10 @@
 """
 
 from pathlib import Path
+
 from .utils import DashboardTester, get_impactx_root_dir
 
+
 class DashboardExamples:
     def __init__(self, dashboard: DashboardTester):
         self.dashboard = dashboard
@@ -83,7 +85,6 @@ def dogleg_lattice(self):
         ]
         self._run_example("dogleg", "dogleg/run_dogleg.py", LATTICE_CONFIGURATION)
 
-
     def chicane_lattice(self):
         """
         Utilizes lattice_half.reverse()
@@ -106,6 +107,7 @@ def chicane_lattice(self):
 
         self._run_example("chicane", "chicane/run_chicane.py", LATTICE_CONFIGURATION)
 
+
 def test_examples(dashboard):
     """
     Exercise a subset of example imports against the running dashboard.

tests/python/dashboard/test_lattice_stats.py

@@ -6,6 +6,7 @@
 License: BSD-3-Clause-LBNL
 """
 
+
 def test_lattice_stats(dashboard):
     """
     Tests the lattice statistics to ensure accuracy and indirectly
@@ -17,35 +18,35 @@ def test_lattice_stats(dashboard):
         "total_elements": 11,
         "total_length": "3.0m",
         "max_length": "1.0m",
-        "avg_length" : "0.6m",
+        "avg_length": "0.6m",
         "min_length": "0.25m",
         "total_steps": 125,
         "periods": 1,
-        "element_counts": {'beammonitor': 6, 'drift': 3, 'quad': 2}
+        "element_counts": {"beammonitor": 6, "drift": 3, "quad": 2},
     }
 
     APOCHROMATIC_EXPECTED_RESULTS = {
         "total_elements": 14,
         "total_length": "32.5m",
         "total_steps": 300,
         "periods": 1,
-        "element_counts": {'chrquad': 8, 'chrdrift': 4, 'beammonitor': 2}
+        "element_counts": {"chrquad": 8, "chrdrift": 4, "beammonitor": 2},
     }
 
     CHICANE_CSR_EXPECTED_RESULTS = {
         "total_elements": 14,
         "total_length": "15.01m",
         "total_steps": 200,
         "periods": 1,
-        "element_counts": {'drift': 4, 'dipedge': 4, 'sbend': 4, 'beammonitor': 2}
+        "element_counts": {"drift": 4, "dipedge": 4, "sbend": 4, "beammonitor": 2},
     }
 
     DOGLEG_REVERSE_EXPECTED_RESULTS = {
         "total_elements": 8,
         "total_length": "6.51m",
         "total_steps": 100,
         "periods": 1,
-        "element_counts": {'beammonitor': 2, 'drift': 2, 'sbend': 2, 'dipedge': 2}
+        "element_counts": {"beammonitor": 2, "drift": 2, "sbend": 2, "dipedge": 2},
     }
 
     IOLATTICE_EXPECTED_RESULTS = {
@@ -54,7 +55,13 @@ def test_lattice_stats(dashboard):
         #  locally gives 919, pytest gives 2283 when all 5 examples are tested, passes if ran alone
         # "total_steps": 918,
         "periods": 5,
-        "element_counts": {"drift": 52, "quad": 39, "dipedge": 16, "sbend": 8, "beammonitor": 2},
+        "element_counts": {
+            "drift": 52,
+            "quad": 39,
+            "dipedge": 16,
+            "sbend": 8,
+            "beammonitor": 2,
+        },
     }
 
     # Begin Testing
@@ -70,4 +77,3 @@ def test_lattice_stats(dashboard):
         dashboard.load_example(example)
         for state_name, expected_value in expected.items():
             dashboard.assert_state(state_name, expected_value)
-