Mega linter autofix

Author: saganatt

machine_learning_hep/processer.py

@@ -417,7 +417,7 @@ def dfread(rdir, trees, cols, idx_name=None):
                 if idx_name:
                     # df.rename_axis(idx_name, inplace=True)
                     df[idx_name] = df.index
-                    df.set_index(["df", idx_name], inplace=True)
+                    df = df.set_index(["df", idx_name])
                 return df
             except Exception as e:
                 self.logger.exception("Failed to read data from trees: %s", str(e))

machine_learning_hep/processerdhadrons.py

@@ -92,8 +92,8 @@ def __init__(
         self.p_mass_fit_lim = datap["analysis"][self.typean]["mass_fit_lim"]
         self.p_bin_width = datap["analysis"][self.typean]["bin_width"]
         limits_mass = datap["analysis"][self.typean]["mass_fit_lim"]
-        nbins_mass = int(round((limits_mass[1] - limits_mass[0]) / self.p_bin_width))
-        self.p_num_bins = int(round((self.p_mass_fit_lim[1] - self.p_mass_fit_lim[0]) / self.p_bin_width))
+        nbins_mass = round((limits_mass[1] - limits_mass[0]) / self.p_bin_width)
+        self.p_num_bins = round((self.p_mass_fit_lim[1] - self.p_mass_fit_lim[0]) / self.p_bin_width)
         self.s_presel_gen_eff = datap["analysis"][self.typean]["presel_gen_eff"]
 
         self.lpt_finbinmin = datap["analysis"][self.typean]["sel_an_binmin"]
@@ -113,10 +113,7 @@ def process_histomass_single(self, index):
         myfile = TFile.Open(self.l_histomass[index], "recreate")
         dfevtorig = read_df(self.l_evtorig[index])
         neventsorig = len(dfevtorig)
-        if self.s_evtsel is not None:
-            dfevtevtsel = dfevtorig.query(self.s_evtsel)
-        else:
-            dfevtevtsel = dfevtorig
+        dfevtevtsel = dfevtorig.query(self.s_evtsel) if self.s_evtsel is not None else dfevtorig
         neventsafterevtsel = len(dfevtevtsel)
 
         # validation plot for event selection
@@ -246,14 +243,11 @@ def do_eff_single(ipt, bin_id, df_mc_gen, df_mc_reco, sel_column, bincounter, hi
             df_gen_sel = df_mc_gen.loc[(df_mc_gen[sel_column] == 1) & (df_mc_gen.ismcsignal == 1)]
             df_reco_presel = df_mc_reco.loc[(df_mc_reco[sel_column] == 1) & (df_mc_reco.ismcsignal == 1)]
             df_reco_sel = None
-            if self.doml is True:
-                df_reco_sel = df_reco_presel.query(self.l_selml[bin_id])
-            else:
-                df_reco_sel = df_reco_presel.copy()
+            df_reco_sel = df_reco_presel.query(self.l_selml[bin_id]) if self.doml is True else df_reco_presel.copy()
             if self.do_custom_analysis_cuts:
                 df_reco_sel = self.apply_cuts_ptbin(df_reco_sel, ipt)
 
-            for df, hist in zip((df_gen_sel, df_reco_presel, df_reco_sel), hists):
+            for df, hist in zip((df_gen_sel, df_reco_presel, df_reco_sel), hists, strict=False):
                 val = len(df)
                 err = math.sqrt(val)
                 hist.SetBinContent(bincounter + 1, val)

machine_learning_hep/utilities.py

@@ -128,10 +128,7 @@ def write_df(dfo, path):
 
 def read_df(path, **kwargs):
     try:
-        if path.endswith(".parquet"):
-            df = pd.read_parquet(path, **kwargs)
-        else:
-            df = pickle.load(openfile(path, "rb"))
+        df = pd.read_parquet(path, **kwargs) if path.endswith(".parquet") else pickle.load(openfile(path, "rb"))
     except Exception as e:  # pylint: disable=broad-except
         logger.critical("failed to open file <%s>: %s", path, str(e))
         sys.exit()
@@ -160,7 +157,7 @@ def conv_none(value):
         mask_by_value_dict[mc["column"]] = {mc["find_by_value"]: conv_none(mc["mask_with"])}
 
     # Mask all we can do by value
-    df_to_mask.replace(mask_by_value_dict, inplace=True)
+    df_to_mask = df_to_mask.replace(mask_by_value_dict)
 
     # Now mask all which are searched by query
     for mc in mask_by_query_list:
@@ -308,12 +305,12 @@ def make_latex_table(column_names, row_names, rows, caption=None, save_path="./t
         columns = "|".join(["c"] * (len(column_names) + 1))
         f.write("\\begin{tabular}{" + columns + "}\n")
         f.write("\\hline\n")
-        columns = "&".join([""] + column_names)
+        columns = "&".join(["", *column_names])
         columns = columns.replace("_", "\\_")
         f.write(columns + "\\\\\n")
         f.write("\\hline\\hline\n")
-        for rn, row in zip(row_names, rows):
-            row_string = "&".join([rn] + row)
+        for rn, row in zip(row_names, rows, strict=False):
+            row_string = "&".join([rn, *row])
             row_string = row_string.replace("_", "\\_")
             f.write(row_string + "\\\\\n")
         f.write("\\end{tabular}\n")
@@ -411,10 +408,7 @@ def equal_axis_list(axis1, list2, precision=10):
     bins = get_bins(axis1)
     if len(bins) != len(list2):
         return False
-    for i, j in zip(bins, list2):
-        if round(i, precision) != round(j, precision):
-            return False
-    return True
+    return all(round(i, precision) == round(j, precision) for i, j in zip(bins, list2, strict=False))
 
 
 def equal_binning(his1, his2):
@@ -432,9 +426,7 @@ def equal_binning_lists(his, list_x=None, list_y=None, list_z=None):
         return False
     if list_y is not None and not equal_axis_list(his.GetYaxis(), list_y):
         return False
-    if list_z is not None and not equal_axis_list(his.GetZaxis(), list_z):
-        return False
-    return True
+    return not (list_z is not None and not equal_axis_list(his.GetZaxis(), list_z))
 
 
 def folding(h_input, response_matrix, h_output):
@@ -943,13 +935,13 @@ def plot_latex(latex):
     # set canvas margins
     if isinstance(margins_c, list) and len(margins_c) > 0:
         for setter, value in zip(
-            [can.SetBottomMargin, can.SetLeftMargin, can.SetTopMargin, can.SetRightMargin], margins_c
+            [can.SetBottomMargin, can.SetLeftMargin, can.SetTopMargin, can.SetRightMargin], margins_c, strict=False
         ):
             setter(value)
     # set logarithmic scale for selected axes
     log_y = False
     if isinstance(logscale, str) and len(logscale) > 0:
-        for setter, axis in zip([can.SetLogx, can.SetLogy, can.SetLogz], ["x", "y", "z"]):
+        for setter, axis in zip([can.SetLogx, can.SetLogy, can.SetLogz], ["x", "y", "z"], strict=False):
             if axis in logscale:
                 setter()
                 if axis == "y":