ruff check + format. Finally

Author: rozyczko

EasyReflectometryApp/Backends/Py/__init__.py

@@ -1,3 +1,3 @@
 from .py_backend import PyBackend
 
-__all__ = [PyBackend]
+__all__ = [PyBackend]

EasyReflectometryApp/Backends/Py/analysis.py

@@ -113,9 +113,9 @@ def prefitCheck(self) -> bool:
             if param['min'] >= param['max']:
                 QtWidgets.QMessageBox.warning(
                     None,
-                    "Invalid Parameter Bounds",
+                    'Invalid Parameter Bounds',
                     f"Parameter '{param['name']}' has invalid bounds: "
-                    f"min ({param['min']}) must be less than max ({param['max']})."
+                    f'min ({param["min"]}) must be less than max ({param["max"]}).',
                 )
                 return False
 
@@ -132,9 +132,8 @@ def prefitCheck(self) -> bool:
                 # Show a warning in a message box
                 QtWidgets.QMessageBox.warning(
                     None,
-                    "Invalid Parameter Bounds",
-                    f"Parameters {joined} have infinite bounds, "
-                    "which is not allowed for differential evolution minimizer."
+                    'Invalid Parameter Bounds',
+                    f'Parameters {joined} have infinite bounds, which is not allowed for differential evolution minimizer.',
                 )
 
                 return False
@@ -231,7 +230,7 @@ def removeExperiment(self, index: int) -> None:
             self.experimentsChanged.emit()
             self.externalExperimentChanged.emit()
         else:
-            print(f"Experiment index {index} is out of range.")
+            print(f'Experiment index {index} is out of range.')
 
     ########################
     ## Multi-experiment selection support
@@ -294,7 +293,7 @@ def get_concatenated_experiment_data(self):
                     all_ye.extend(data.ye if hasattr(data, 'ye') and data.ye.size > 0 else np.zeros_like(data.y))
                     all_xe.extend(data.xe if hasattr(data, 'xe') and data.xe.size > 0 else np.zeros_like(data.x))
             except (IndexError, AttributeError) as e:
-                print(f"Error accessing experiment {exp_idx}: {e}")
+                print(f'Error accessing experiment {exp_idx}: {e}')
                 continue
 
         if not all_x:
@@ -306,16 +305,15 @@ def get_concatenated_experiment_data(self):
 
         x_sorted, y_sorted, ye_sorted, xe_sorted = zip(*combined_data) if combined_data else ([], [], [], [])
 
-        exp_names = [self._experiments_logic.available()[i] 
-                     for i in self._selected_experiment_indices if i < len(self._experiments_logic.available())]
-        combined_name = f"Combined: {', '.join(exp_names)}"
+        exp_names = [
+            self._experiments_logic.available()[i]
+            for i in self._selected_experiment_indices
+            if i < len(self._experiments_logic.available())
+        ]
+        combined_name = f'Combined: {", ".join(exp_names)}'
 
         return DataSet1D(
-            name=combined_name,
-            x=np.array(x_sorted),
-            y=np.array(y_sorted),
-            ye=np.array(ye_sorted),
-            xe=np.array(xe_sorted)
+            name=combined_name, x=np.array(x_sorted), y=np.array(y_sorted), ye=np.array(ye_sorted), xe=np.array(xe_sorted)
         )
 
     def get_individual_experiment_data_list(self):
@@ -340,25 +338,23 @@ def get_individual_experiment_data_list(self):
             '#e377c2',  # Pink
             '#7f7f7f',  # Gray
             '#bcbd22',  # Olive
-            '#17becf'   # Cyan
+            '#17becf',  # Cyan
         ]
 
         for idx, exp_idx in enumerate(self._selected_experiment_indices):
             try:
                 data = self._experiments_logic._project_lib.experimental_data_for_model_at_index(exp_idx)
                 if data.x.size > 0:  # Only include non-empty datasets
-                    exp_name = self._experiments_logic.available()[exp_idx] if \
-                        exp_idx < len(self._experiments_logic.available()) else f"Experiment {exp_idx + 1}"
+                    exp_name = (
+                        self._experiments_logic.available()[exp_idx]
+                        if exp_idx < len(self._experiments_logic.available())
+                        else f'Experiment {exp_idx + 1}'
+                    )
                     color = color_palette[idx % len(color_palette)]
 
-                    experiment_data_list.append({
-                        'data': data,
-                        'name': exp_name,
-                        'color': color,
-                        'index': exp_idx
-                    })
+                    experiment_data_list.append({'data': data, 'name': exp_name, 'color': color, 'index': exp_idx})
             except (IndexError, AttributeError) as e:
-                print(f"Error accessing experiment {exp_idx}: {e}")
+                print(f'Error accessing experiment {exp_idx}: {e}')
                 continue
 
         return experiment_data_list
@@ -373,16 +369,16 @@ def _refresh_plotting_system(self) -> None:
         try:
             if hasattr(self.parent(), '_plotting_1d'):
                 plotting = self.parent()._plotting_1d
-                print("📊 Refreshing plotting system...")
-                print(f"   Current selection: {self._selected_experiment_indices}")
+                print('📊 Refreshing plotting system...')
+                print(f'   Current selection: {self._selected_experiment_indices}')
 
                 # Emit signals to refresh experiment data and ranges
                 plotting.experimentDataChanged.emit()
                 plotting.experimentChartRangesChanged.emit()
                 plotting.refreshExperimentPage()
                 plotting.refreshExperimentRanges()
         except Exception as e:
-            print(f"❌ Error refreshing plotting system: {e}")
+            print(f'❌ Error refreshing plotting system: {e}')
 
     ########################
     ## Minimizers
@@ -431,14 +427,14 @@ def enabledParameters(self) -> list[dict[str]]:
         if self._chached_enabled_parameters is not None:
             return self._chached_enabled_parameters
         enabled_parameters = []
-        #import time
-        #t0 = time.time()
+        # import time
+        # t0 = time.time()
         for parameter in self._parameters_logic.parameters:
             if not parameter['enabled']:
                 continue
             enabled_parameters.append(parameter)
-        #t1 = time.time()
-        #print(f"Enabled parameters computation time: {t1 - t0:.4f} seconds")
+        # t1 = time.time()
+        # print(f"Enabled parameters computation time: {t1 - t0:.4f} seconds")
         self._chached_enabled_parameters = enabled_parameters
         return enabled_parameters
 

EasyReflectometryApp/Backends/Py/experiment.py

@@ -63,4 +63,4 @@ def load(self, paths: str) -> None:
             self._project_logic.load_new_experiment(IO.generalizePath(path))
             self.experimentChanged.emit()
             self.externalExperimentChanged.emit()
-        pass # debug anchor
+        pass  # debug anchor

EasyReflectometryApp/Backends/Py/logic/assemblies.py

@@ -72,8 +72,7 @@ def set_type_at_current_index(self, new_value: str) -> bool:
             new_assembly = Multilayer()
             new_assembly.layers[0].material = self._assemblies[self.index].layers.data[0].material
         elif new_value == 'Repeating Multi-layer':
-            new_assembly = RepeatingMultilayer(repetitions=1,
-                                               name = new_value)
+            new_assembly = RepeatingMultilayer(repetitions=1, name=new_value)
             new_assembly.layers[0].material = self._assemblies[self.index].layers.data[0].material
         elif new_value == 'Surfactant Layer':
             index_air = self._project_lib.get_index_air()

EasyReflectometryApp/Backends/Py/logic/experiments.py

@@ -57,9 +57,9 @@ def set_model_on_experiment(self, new_value: int) -> None:
                 model = models[new_value]
                 exp.model = model
             except IndexError:
-                print(f"Model index {new_value} is out of range for the current experiment.")
+                print(f'Model index {new_value} is out of range for the current experiment.')
         else:
-            print("No experiment or models available to set on the experiment.")
+            print('No experiment or models available to set on the experiment.')
         pass
 
     def remove_experiment(self, index: int) -> None:
@@ -70,11 +70,8 @@ def remove_experiment(self, index: int) -> None:
             del self._project_lib._experiments[index]
             # readjust the dictionary keys for continuity
             temp_experiments = self._project_lib._experiments.copy()
-            self._project_lib._experiments = {
-                i: exp for i, exp in enumerate(temp_experiments.values())
-            }
+            self._project_lib._experiments = {i: exp for i, exp in enumerate(temp_experiments.values())}
             if self._project_lib._current_experiment_index >= index:
-                self._project_lib._current_experiment_index = \
-                max(0, self._project_lib._current_experiment_index - 1)
+                self._project_lib._current_experiment_index = max(0, self._project_lib._current_experiment_index - 1)
         else:
-            print(f"Experiment index {index} is out of range.")
+            print(f'Experiment index {index} is out of range.')

EasyReflectometryApp/Backends/Py/logic/helpers.py

@@ -2,13 +2,13 @@
 # SPDX-License-Identifier: BSD-3-Clause
 # © 2025 Contributors to the EasyApp project <https://github.com/easyscience/EasyApp>
 
-class IO:
 
+class IO:
     @staticmethod
     def formatMsg(type, *args):
         types = {'main': '*', 'sub': '  -'}
         mark = types[type]
-        widths = [22,21,20,10]
+        widths = [22, 21, 20, 10]
         widths[0] -= len(mark)
         msgs = []
         for idx, arg in enumerate(args):

EasyReflectometryApp/Backends/Py/logic/parameters.py

@@ -23,21 +23,21 @@ def as_status_string(self) -> str:
 
     @property
     def parameters(self) -> list[dict[str, Any]]:
-        return _from_parameters_to_list_of_dicts(
-            self._project_lib.parameters, self._project_lib._models
-        )
+        return _from_parameters_to_list_of_dicts(self._project_lib.parameters, self._project_lib._models)
 
     def constraint_context(self) -> list[dict[str, Any]]:
         parameter_snapshot = self.parameters
         context: list[dict[str, Any]] = []
         for parameter in parameter_snapshot:
-            context.append({
-                'alias': parameter['alias'],
-                'display_name': parameter['display_name'],
-                'group': parameter.get('group', ''),
-                'independent': parameter['independent'],
-                'object': parameter['object'],
-            })
+            context.append(
+                {
+                    'alias': parameter['alias'],
+                    'display_name': parameter['display_name'],
+                    'group': parameter.get('group', ''),
+                    'independent': parameter['independent'],
+                    'object': parameter['object'],
+                }
+            )
         return context
 
     def constraint_metadata(self) -> list[dict[str, Any]]:
@@ -47,12 +47,14 @@ def constraint_metadata(self) -> list[dict[str, Any]]:
             # Include ALL parameters (both independent and dependent) for constraint expressions
             # if not entry['independent']:
             #     continue
-            metadata.append({
-                'alias': entry['alias'],
-                'displayName': entry['display_name'],
-                'group': entry.get('group', ''),
-                'independent': entry['independent'],
-            })
+            metadata.append(
+                {
+                    'alias': entry['alias'],
+                    'displayName': entry['display_name'],
+                    'group': entry.get('group', ''),
+                    'independent': entry['independent'],
+                }
+            )
         metadata.sort(key=lambda item: item['displayName'])
         return metadata
 
@@ -147,7 +149,8 @@ def add_constraint(
 
         if arithmetic_operator != '' and independent_idx > -1:
             dependent.make_dependent_on(
-                dependency_expression='a' + arithmetic_operator + 'b', dependency_map={'a': independent, 'b': float(value)})
+                dependency_expression='a' + arithmetic_operator + 'b', dependency_map={'a': independent, 'b': float(value)}
+            )
         elif arithmetic_operator == '' and independent_idx == -1:
             relational_operator = relational_operator.replace('=', '==')
             relational_operator = relational_operator.replace('&lt', '>')
@@ -160,6 +163,7 @@ def add_constraint(
 
         print(f'{dependent_idx}, {relational_operator}, {value}, {arithmetic_operator}, {independent_idx}')
 
+
 def _from_parameters_to_list_of_dicts(parameters: List[Parameter], models) -> list[dict[str, Any]]:
     """Convert parameters to list of dictionaries with simplified logic.
 
@@ -245,22 +249,24 @@ def _is_layer_parameter(param: Parameter) -> bool:
                 prefixed_display_name = display_name
 
             alias = _make_alias(prefixed_display_name or parameter.name)
-            parameter_list.append({
-                'name': prefixed_display_name,
-                'display_name': prefixed_display_name,
-                'group': group_name,
-                'alias': alias,
-                'unique_name': parameter.unique_name,
-                'value': float(parameter.value),
-                'error': float(parameter.variance),
-                'max': float(parameter.max),
-                'min': float(parameter.min),
-                'units': parameter.unit,
-                'fit': parameter.free,
-                'independent': parameter.independent,
-                'dependency': _get_dependency_expression(parameter, model_unique_name),
-                'enabled': parameter.enabled if hasattr(parameter, 'enabled') else True,
-                'object': parameter,  # Direct reference to the Parameter object
-            })
+            parameter_list.append(
+                {
+                    'name': prefixed_display_name,
+                    'display_name': prefixed_display_name,
+                    'group': group_name,
+                    'alias': alias,
+                    'unique_name': parameter.unique_name,
+                    'value': float(parameter.value),
+                    'error': float(parameter.variance),
+                    'max': float(parameter.max),
+                    'min': float(parameter.min),
+                    'units': parameter.unit,
+                    'fit': parameter.free,
+                    'independent': parameter.independent,
+                    'dependency': _get_dependency_expression(parameter, model_unique_name),
+                    'enabled': parameter.enabled if hasattr(parameter, 'enabled') else True,
+                    'object': parameter,  # Direct reference to the Parameter object
+                }
+            )
 
     return parameter_list