[pre-commit.ci lite] apply automatic fixes for ruff linting errors

Author: pre-commit-ci-lite[bot]

src/sas/qtgui/Calculators/Shape2SAS/Constraints.py

@@ -112,7 +112,7 @@ def merge_text(current_text: str, parameter_text: str):
                 return get_default(parameter_text)
 
             new_lines = parameter_text.split("\n")
-            # fit_param string is formatted as: 
+            # fit_param string is formatted as:
             # [
             #  # header
             #  ['name1', 'unit1', ...],
@@ -129,7 +129,7 @@ def merge_text(current_text: str, parameter_text: str):
                 if name in old_names:
                     entry = old_lines[old_names.index(name)+2]
                     new_lines[i+2] = entry + ',' if entry[-1] != ',' else entry
-            
+
             # remove old lines from the current text and insert the new ones in the middle
             current_text = "\n".join(current_text_lines[:start+1] + new_lines[2:-1] + current_text_lines[start+end:])
             return current_text
@@ -167,7 +167,7 @@ def expand_center_of_mass_pars(constraint: ast.Assign) -> list[ast.Assign]:
             """Expand center of mass parameters to include all components."""
 
             # check if this is a COM assignment we need to expand
-            if (len(constraint.targets) != 1 or 
+            if (len(constraint.targets) != 1 or
                 not isinstance(constraint.targets[0], ast.Name) or
                 not isinstance(constraint.value, ast.Name)):
                 return constraint
@@ -267,7 +267,7 @@ def extract_symbols(constraints: list[ast.AST]) -> tuple[list[str], list[str]]:
 
             return lhs, rhs, lineno
 
-        def validate_params(params: ast.AST): 
+        def validate_params(params: ast.AST):
             if params is None:
                 self.log_embedded_error("No parameters found in constraints text.")
                 raise ValueError("No parameters found in constraints text.")
@@ -302,7 +302,7 @@ def validate_imports(imports: list[ast.ImportFrom | ast.Import]):
 
         def mark_named_parameters(checkedPars: list[list[bool]], modelPars: list[str], symbols: set[str]):
             """Mark parameters in the modelPars as checked if they are in symbols_lhs."""
-            def in_symbols(par: str): 
+            def in_symbols(par: str):
                 if par in symbols: return True
                 if 'd' + par in symbols: return True
                 return False

src/sas/qtgui/Calculators/Shape2SAS/DesignWindow.py

@@ -647,12 +647,12 @@ def getPluginModel(self):
         modelProfile = self.getModelProfile(self.ifFitPar, conditionBool=checkedPars, conditionFitPar=parNames)
 
         model_str, full_path = generate_plugin(
-            modelProfile, 
+            modelProfile,
             [parNames, parVals],
             usertext,
-            fitPar, 
-            Npoints, 
-            prPoints, 
+            fitPar,
+            Npoints,
+            prPoints,
             modelName
         )
 
@@ -711,10 +711,10 @@ def getSimulatedSAXSData(self):
         Distr = getPointDistribution(Profile, N)
 
         model = ModelSystem(
-            PointDistribution=Distr, 
-            Stype=Stype, par=par, 
-            polydispersity=polydispersity, 
-            conc=conc, 
+            PointDistribution=Distr,
+            Stype=Stype, par=par,
+            polydispersity=polydispersity,
+            conc=conc,
             sigma_r=sigma_r
         )
 

src/sas/qtgui/Calculators/Shape2SAS/Tables/subunitTable.py

@@ -512,7 +512,7 @@ def onAdding(self):
                 if row in subunitName.keys():
                     paintedName = subunitName[row] + f"{to_column_name}" + " = "
                     item = CustomStandardItem(
-                        paintedName, subunitUnits[row], 
+                        paintedName, subunitUnits[row],
                         subunitTooltip[row], subunitDefault_value[row],
                         plot_callback=self.updatePlotCallback
                     )
@@ -536,7 +536,7 @@ def onAdding(self):
                 method = MethodType(attr, OptionLayout)
                 name, defaultVal, units, tooltip, _, _ = method()
                 item = CustomStandardItem(
-                    name[row] + f"{to_column_name}" + " = ", units[row], 
+                    name[row] + f"{to_column_name}" + " = ", units[row],
                     tooltip[row], defaultVal[row],
                     plot_callback=self.updatePlotCallback
                 )

src/sas/qtgui/Calculators/Shape2SAS/ViewerModel.py

@@ -147,7 +147,7 @@ def initialiseAxis(self):
 
     def setAxis(self, x_range: (float, float), y_range: (float, float), z_range: (float, float)):
         """Set axis for the model with equal aspect ratio"""
-        
+
         # Calculate the overall range to ensure equal aspect ratio
         x_min, x_max = x_range
         y_min, y_max = y_range
@@ -156,10 +156,10 @@ def setAxis(self, x_range: (float, float), y_range: (float, float), z_range: (fl
         y_center = (y_min + y_max) / 2
         z_center = (z_min + z_max) / 2
         max_range = max(x_max - x_min, y_max - y_min, z_max - z_min)
-        
+
         # Add some padding
         half_range = (max_range*1.1) / 2
-        
+
         # Set equal ranges for all axes centered on their respective centers
         self.X_ax.setRange(x_center - half_range, x_center + half_range)
         self.Y_ax.setRange(y_center - half_range, y_center + half_range)

src/sas/sascalc/shape2sas/ExperimentalScattering.py

@@ -26,10 +26,10 @@ class SimulatedScattering:
     I_err: np.ndarray
 
 class IExperimental:
-    def __init__(self, 
-                 q: np.ndarray, 
-                 I0: np.ndarray, 
-                 I: np.ndarray, 
+    def __init__(self,
+                 q: np.ndarray,
+                 I0: np.ndarray,
+                 I: np.ndarray,
                  exposure: float):
         self.q = q
         self.I0 = I0
@@ -73,7 +73,7 @@ def simulate_data(self) -> Vector2D:
         N = k * self.q # original expression from Sedlak2017 paper
 
         qt = 1.4 # threshold - above this q value, the linear expression do not hold
-        a = 3.0 # empirical constant 
+        a = 3.0 # empirical constant
         b = 0.6 # empirical constant
         idx = np.where(self.q > qt)
         N[idx] = k * qt * np.exp(-0.5 * ((self.q[idx] - qt) / b)**a)
@@ -83,7 +83,7 @@ def simulate_data(self) -> Vector2D:
         q_arb = 0.3
         if q_max <= q_arb:
            I_sed_arb = I_sed[-2]
-        else: 
+        else:
             idx_arb = np.where(self.q > q_arb)[0][0]
             I_sed_arb = I_sed[idx_arb]
 
@@ -116,4 +116,4 @@ def getSimulatedScattering(scalc: SimulateScattering) -> SimulatedScattering:
     Isim_class = IExperimental(scalc.q, scalc.I0, scalc.I, scalc.exposure)
     I_sim, I_err = Isim_class.simulate_data()
 
-    return SimulatedScattering(I_sim=I_sim, q=scalc.q, I_err=I_err)
+    return SimulatedScattering(I_sim=I_sim, q=scalc.q, I_err=I_err)

src/sas/sascalc/shape2sas/HelperFunctions.py

@@ -22,7 +22,7 @@ def qMethodsNames(name: str):
             "User_sampled": Qsampling.onUserSampledQ
         }
         return methods[name]
-    
+
     def qMethodsInput(name: str):
         inputs = {
             "Uniform": {"qmin": 0.001, "qmax": 0.5, "Nq": 400},
@@ -50,7 +50,7 @@ def sinc(x) -> np.ndarray:
     function for calculating sinc = sin(x)/x
     numpy.sinc is defined as sinc(x) = sin(pi*x)/(pi*x)
     """
-    return np.sinc(x / np.pi)   
+    return np.sinc(x / np.pi)
 
 
 def get_max_dimension(x_list: np.ndarray, y_list: np.ndarray, z_list: np.ndarray) -> float:
@@ -76,11 +76,11 @@ def get_max_dimension(x_list: np.ndarray, y_list: np.ndarray, z_list: np.ndarray
     return max_l
 
 
-def plot_2D(x_list: np.ndarray, 
-            y_list: np.ndarray, 
-            z_list: np.ndarray, 
-            p_list: np.ndarray, 
-            Models: np.ndarray, 
+def plot_2D(x_list: np.ndarray,
+            y_list: np.ndarray,
+            z_list: np.ndarray,
+            p_list: np.ndarray,
+            Models: np.ndarray,
             high_res: bool) -> None:
     """
     plot 2D-projections of generated points (shapes) using matplotlib:
@@ -123,7 +123,7 @@ def plot_2D(x_list: np.ndarray,
         ax[0].set_title('pointmodel, (x,z), "front"')
 
         ## plot, perspective 2
-        ax[1].plot(y[idx_pos], z[idx_pos], linestyle='none', marker='.', markersize=markersize) 
+        ax[1].plot(y[idx_pos], z[idx_pos], linestyle='none', marker='.', markersize=markersize)
         ax[1].plot(y[idx_neg], z[idx_neg], linestyle='none', marker='.', markersize=markersize, color='black')
         ax[1].plot(y[idx_nul], z[idx_nul], linestyle='none', marker='.', markersize=markersize, color='grey')
         ax[1].set_xlim(lim)
@@ -133,15 +133,15 @@ def plot_2D(x_list: np.ndarray,
         ax[1].set_title('pointmodel, (y,z), "side"')
 
         ## plot, perspective 3
-        ax[2].plot(x[idx_pos], y[idx_pos], linestyle='none', marker='.', markersize=markersize) 
+        ax[2].plot(x[idx_pos], y[idx_pos], linestyle='none', marker='.', markersize=markersize)
         ax[2].plot(x[idx_neg], y[idx_neg], linestyle='none', marker='.', markersize=markersize, color='black')
-        ax[2].plot(x[idx_nul], y[idx_nul], linestyle='none', marker='.', markersize=markersize, color='grey')    
+        ax[2].plot(x[idx_nul], y[idx_nul], linestyle='none', marker='.', markersize=markersize, color='grey')
         ax[2].set_xlim(lim)
         ax[2].set_ylim(lim)
         ax[2].set_xlabel('x')
         ax[2].set_ylabel('y')
         ax[2].set_title('pointmodel, (x,y), "bottom"')
-    
+
         plt.tight_layout()
         if high_res:
             plt.savefig('points%s.png' % Model,dpi=600)
@@ -150,16 +150,16 @@ def plot_2D(x_list: np.ndarray,
         plt.close()
 
 
-def plot_results(q: np.ndarray, 
-                 r_list: list[np.ndarray], 
-                 pr_list: list[np.ndarray], 
-                 I_list: list[np.ndarray], 
-                 Isim_list: list[np.ndarray], 
-                 sigma_list: list[np.ndarray], 
-                 S_list: list[np.ndarray], 
-                 names: list[str], 
-                 scales: list[float], 
-                 xscale_log: bool, 
+def plot_results(q: np.ndarray,
+                 r_list: list[np.ndarray],
+                 pr_list: list[np.ndarray],
+                 I_list: list[np.ndarray],
+                 Isim_list: list[np.ndarray],
+                 sigma_list: list[np.ndarray],
+                 S_list: list[np.ndarray],
+                 names: list[str],
+                 scales: list[float],
+                 xscale_log: bool,
                  high_res: bool) -> None:
     """
     plot results for all models, using matplotlib:
@@ -174,7 +174,7 @@ def plot_results(q: np.ndarray,
     for (r, pr, I, Isim, sigma, S, model_name, scale) in zip (r_list, pr_list, I_list, Isim_list, sigma_list, S_list, names, scales):
         ax[0].plot(r,pr,zorder=zo,label='p(r), %s' % model_name)
 
-        if scale > 1: 
+        if scale > 1:
             ax[2].errorbar(q,Isim*scale,yerr=sigma*scale,linestyle='none',marker='.',label=r'$I_\mathrm{sim}(q)$, %s, scaled by %d' % (model_name,scale),zorder=1/zo)
         else:
             ax[2].errorbar(q,Isim*scale,yerr=sigma*scale,linestyle='none',marker='.',label=r'$I_\mathrm{sim}(q)$, %s' % model_name,zorder=zo)
@@ -220,10 +220,10 @@ def plot_results(q: np.ndarray,
     plt.close()
 
 
-def generate_pdb(x_list: list[np.ndarray], 
-                 y_list: list[np.ndarray], 
-                 z_list: list[np.ndarray], 
-                 p_list: list[np.ndarray], 
+def generate_pdb(x_list: list[np.ndarray],
+                 y_list: list[np.ndarray],
+                 z_list: list[np.ndarray],
+                 p_list: list[np.ndarray],
                  Model_list: list[str]) -> None:
     """
     Generates a visualisation file in PDB format with the simulated points (coordinates) and contrasts

src/sas/sascalc/shape2sas/Models.py

@@ -146,8 +146,8 @@ def setAvailableSubunits(self):
             "sphere": Sphere,
             "ball": Sphere,
 
-            "hollow_sphere": HollowSphere, 
-            "Hollow sphere": HollowSphere, 
+            "hollow_sphere": HollowSphere,
+            "Hollow sphere": HollowSphere,
 
             "cylinder": Cylinder,
 
@@ -170,7 +170,7 @@ def setAvailableSubunits(self):
 
             "disc_ring": DiscRing,
             "Disc ring": DiscRing,
-            
+
             "superellipsoid": SuperEllipsoid
         }
 
@@ -211,14 +211,14 @@ def onAppendingPoints(x_new: np.ndarray,
 
     @staticmethod
     def onCheckOverlap(
-        x: np.ndarray, 
-        y: np.ndarray, 
-        z: np.ndarray, 
-        p: np.ndarray, 
-        rotation: list[float], 
+        x: np.ndarray,
+        y: np.ndarray,
+        z: np.ndarray,
+        p: np.ndarray,
+        rotation: list[float],
         rotation_point: list[float],
-        com: list[float], 
-        subunitClass: object, 
+        com: list[float],
+        subunitClass: object,
         dimensions: list[float]
     ):
         """check for overlap with previous subunits. 
@@ -385,8 +385,8 @@ def getPointDistribution(prof: ModelProfile, Npoints):
         print(f"  Subunit {i}: {subunit} with dimensions {prof.dimensions[i]} at COM {prof.com[i]}")
         print(f"  Rotation: {prof.rotation[i]} at rotation point {prof.rotation_points[i]} with SLD {prof.p_s[i]}")
 
-    x_new, y_new, z_new, p_new, volume_total = GenerateAllPoints(Npoints, prof.com, prof.subunits, 
-                                                  prof.dimensions, prof.rotation, prof.rotation_points, 
+    x_new, y_new, z_new, p_new, volume_total = GenerateAllPoints(Npoints, prof.com, prof.subunits,
+                                                  prof.dimensions, prof.rotation, prof.rotation_points,
                                                   prof.p_s, prof.exclude_overlap).onGeneratingAllPointsSeparately()
-    
-    return ModelPointDistribution(x=x_new, y=y_new, z=z_new, p=p_new, volume_total=volume_total)
+
+    return ModelPointDistribution(x=x_new, y=y_new, z=z_new, p=p_new, volume_total=volume_total)

src/sas/sascalc/shape2sas/PluginGenerator.py

@@ -7,12 +7,12 @@
 
 
 def generate_plugin(
-    prof: ModelProfile, 
+    prof: ModelProfile,
     modelPars: list[list[str], list[str | float]],
-    usertext: UserText, 
+    usertext: UserText,
     fitPar: list[str],
-    Npoints: int, 
-    pr_points: int, 
+    Npoints: int,
+    pr_points: int,
     file_name: str
 ) -> tuple[str, Path]:
     """Generates a theoretical scattering plugin model"""
@@ -34,7 +34,7 @@ def get_shape_symbols(symbols: tuple[set[str], set[str]], modelPars: list[list[s
     for shape in modelPars[0]: # iterate over shape names
         for symbol in shape[1:]: # skip shape name
             shape_symbols.add(symbol)
-    
+
     # filter out user-defined symbols
     lhs_symbols, rhs_symbols = set(), set()
     for symbol in symbols[0]:
@@ -44,7 +44,7 @@ def get_shape_symbols(symbols: tuple[set[str], set[str]], modelPars: list[list[s
     for symbol in symbols[1]:
         if symbol in shape_symbols or symbol[1:] in shape_symbols:
             rhs_symbols.add(symbol)
-    
+
     return lhs_symbols, rhs_symbols
 
 def format_parameter_list(par: list[list[str | float]]) -> str:
@@ -185,12 +185,12 @@ def script_insert_constrained_parameters(symbols: set[str], modelPars: list[list
     return bool(text), "\n".join(text)  # indentation for the function body
 
 def generate_model(
-    prof: ModelProfile, 
+    prof: ModelProfile,
     modelPars: list[list[str], list[str | float]],
-    usertext: UserText, 
+    usertext: UserText,
     fitPar: list[str],
-    Npoints: int, 
-    pr_points: int, 
+    Npoints: int,
+    pr_points: int,
     model_name: str
 ) -> str:
     """Generates a theoretical model"""
@@ -286,5 +286,5 @@ def Iq({', '.join(fitPar)}):
 Iq.vectorized = True
 
 ''')
-    
-    return model_str
+
+    return model_str

src/sas/sascalc/shape2sas/Shape2SAS.py

@@ -278,7 +278,7 @@ def check_input(input: float, default: float, name: str, i: int):
 
         Theo_I = getTheoreticalScattering(
             TheoreticalScatteringCalculation(
-                System=model, 
+                System=model,
                 Calculation=Sim_par
             )
         )