fixing dragging in gui and linewidth=88

Author: carsen-stringer

.style.yapf

@@ -1,6 +1,4 @@
 [style]
-based_on_style = pep8
-spaces_before_comment = 4
+based_on_style = google
 split_before_named_assigns = false
-allow_split_before_dict_value = false
-column_limit = 88
+column_limit = 88

suite2p/__main__.py

@@ -11,8 +11,7 @@ def add_args(parser: argparse.ArgumentParser):
                         help="run single plane ops")
     parser.add_argument("--ops", default=[], type=str, help="options")
     parser.add_argument("--db", default=[], type=str, help="options")
-    parser.add_argument("--version", action="store_true",
-                        help="print version number.")
+    parser.add_argument("--version", action="store_true", help="print version number.")
     ops0 = default_ops()
     for k in ops0.keys():
         v = dict(default=ops0[k], help="{0} : {1}".format(k, ops0[k]))
@@ -49,8 +48,7 @@ def parse_args(parser: argparse.ArgumentParser):
                 ops[k] = n.astype(type(default_key))
                 print(set_param_msg.format(k, ops[k]))
         elif isinstance(default_key, bool):
-            args_key = bool(
-                int(args_key))    # bool("0") is true, must convert to int
+            args_key = bool(int(args_key))  # bool("0") is true, must convert to int
             if default_key != args_key:
                 ops[k] = args_key
                 print(set_param_msg.format(k, ops[k]))

suite2p/classification/classifier.py

@@ -54,8 +54,7 @@ def load(self, classfile, keys=None):
             self.loaded = True
             self.classfile = classfile
             self._fit()
-        except (ValueError, KeyError, OSError, RuntimeError, TypeError,
-                NameError):
+        except (ValueError, KeyError, OSError, RuntimeError, TypeError, NameError):
             print("ERROR: incorrect classifier file")
             self.loaded = False
 
@@ -77,9 +76,8 @@ def predict_proba(self, stat):
             needs self.keys keys
 
         """
-        test_stats = np.array([
-            stat[j][k] for j in range(len(stat)) for k in self.keys
-        ]).reshape(len(stat), -1)
+        test_stats = np.array([stat[j][k] for j in range(len(stat)) for k in self.keys
+                              ]).reshape(len(stat), -1)
         logp = self._get_logp(test_stats)
         y_pred = self.model.predict_proba(logp)[:, 1]
         return y_pred
@@ -109,8 +107,8 @@ def _get_logp(self, stats):
             x[x > self.grid[-1, n]] = self.grid[-1, n]
             x[np.isnan(x)] = self.grid[0, n]
             ibin = np.digitize(x, self.grid[:, n], right=True) - 1
-            logp[:, n] = np.log(self.p[ibin, n] +
-                                1e-6) - np.log(1 - self.p[ibin, n] + 1e-6)
+            logp[:, n] = np.log(self.p[ibin, n] + 1e-6) - np.log(1 - self.p[ibin, n] +
+                                                                 1e-6)
         return logp
 
     def _fit(self):

suite2p/classification/classify.py

@@ -5,8 +5,7 @@
 
 builtin_classfile = Path(__file__).joinpath(
     "../../classifiers/classifier.npy").resolve()
-user_classfile = Path.home().joinpath(
-    ".suite2p/classifiers/classifier_user.npy")
+user_classfile = Path.home().joinpath(".suite2p/classifiers/classifier_user.npy")
 
 
 def classify(

suite2p/default_ops.py

@@ -50,8 +50,7 @@ def patch_detect(patches, diam):
             cellprob = yi[-1]
             dP = yi[:2]
             niter = 1 / rsz * 200
-            p = dynamics.follow_flows(-1 * dP * (cellprob > 0) / 5.,
-                                      niter=niter)
+            p = dynamics.follow_flows(-1 * dP * (cellprob > 0) / 5., niter=niter)
             maski = dynamics.get_masks(p, iscell=(cellprob > 0), flows=dP,
                                        threshold=1.0)
             maski = fill_holes_and_remove_small_masks(maski)
@@ -69,14 +68,13 @@ def refine_masks(stats, patches, seeds, diam, Lyc, Lxc):
     patch_masks = patch_detect(patches, diam)
     ly = patches[0].shape[0] // 2
     igood = np.zeros(nmasks, "bool")
-    for i, (patch_mask, stat,
-            (yi, xi)) in enumerate(zip(patch_masks, stats, seeds)):
+    for i, (patch_mask, stat, (yi, xi)) in enumerate(zip(patch_masks, stats, seeds)):
         mask = np.zeros((Lyc, Lxc), np.float32)
         ypix0, xpix0 = stat["ypix"], stat["xpix"]
         mask[ypix0, xpix0] = stat["lam"]
         func_mask = utils.square_mask(mask, ly, yi, xi)
-        ious = utils.mask_ious(patch_mask.astype(np.uint16),
-                               (func_mask > 0).astype(np.uint16))[0]
+        ious = utils.mask_ious(patch_mask.astype(np.uint16), (func_mask
+                                                              > 0).astype(np.uint16))[0]
         if len(ious) > 0 and ious.max() > 0.45:
             mask_id = np.argmax(ious) + 1
             patch_mask = patch_mask[max(0, ly - yi):min(2 * ly, Lyc + ly - yi),
@@ -98,8 +96,8 @@ def refine_masks(stats, patches, seeds, diam, Lyc, Lxc):
     return stats
 
 
-def roi_detect(mproj, diameter=None, cellprob_threshold=0.0,
-               flow_threshold=1.5, pretrained_model=None):
+def roi_detect(mproj, diameter=None, cellprob_threshold=0.0, flow_threshold=1.5,
+               pretrained_model=None):
     if not os.path.exists(pretrained_model):
         model = CellposeModel(model_type=pretrained_model)
     else:
@@ -184,25 +182,22 @@ def select_rois(ops: Dict[str, Any], mov: np.ndarray, diameter=None):
 
     t0 = time.time()
     if diameter is not None:
-        if isinstance(diameter,
-                      (list, np.ndarray)) and len(ops["diameter"]) > 1:
+        if isinstance(diameter, (list, np.ndarray)) and len(ops["diameter"]) > 1:
             rescale = diameter[1] / diameter[0]
             img = cv2.resize(img, (Lxc, int(Lyc * rescale)))
         else:
             rescale = 1.0
             diameter = [diameter, diameter]
         if diameter[1] > 0:
-            print(
-                "!NOTE! diameter set to %0.2f for cell detection with cellpose"
-                % diameter[1])
+            print("!NOTE! diameter set to %0.2f for cell detection with cellpose" %
+                  diameter[1])
         else:
             print(
                 "!NOTE! diameter set to 0 or None, diameter will be estimated by cellpose"
             )
     else:
         print(
-            "!NOTE! diameter set to 0 or None, diameter will be estimated by cellpose"
-        )
+            "!NOTE! diameter set to 0 or None, diameter will be estimated by cellpose")
 
     if ops.get("spatial_hp_cp", 0):
         img = np.clip(normalize99(img), 0, 1)

suite2p/detection/anatomical.py

@@ -51,8 +51,7 @@ def intensity_ratio(ops, stats):
     cell_pix = masks.create_cell_pix(stats, Ly=ops["Ly"], Lx=ops["Lx"])
     cell_masks0 = [
         masks.create_cell_mask(stat, Ly=ops["Ly"], Lx=ops["Lx"],
-                               allow_overlap=ops["allow_overlap"])
-        for stat in stats
+                               allow_overlap=ops["allow_overlap"]) for stat in stats
     ]
     neuropil_ipix = masks.create_neuropil_masks(
         ypixs=[stat["ypix"] for stat in stats],
@@ -66,8 +65,7 @@ def intensity_ratio(ops, stats):
     for cell_mask, cell_mask0, neuropil_mask, neuropil_mask0 in zip(
             cell_masks, cell_masks0, neuropil_masks, neuropil_ipix):
         cell_mask[cell_mask0[0]] = cell_mask0[1]
-        neuropil_mask[neuropil_mask0.astype(
-            np.int64)] = 1. / len(neuropil_mask0)
+        neuropil_mask[neuropil_mask0.astype(np.int64)] = 1. / len(neuropil_mask0)
 
     mimg2 = ops["meanImg_chan2"]
     inpix = cell_masks @ mimg2.flatten()
@@ -83,7 +81,7 @@ def cellpose_overlap(stats, mimg2):
     masks = anatomical.roi_detect(mimg2)[0]
     Ly, Lx = masks.shape
     redstats = np.zeros((len(stats), 2),
-                        np.float32)    #changed the size of preallocated space
+                        np.float32)  #changed the size of preallocated space
     for i in range(len(stats)):
         smask = np.zeros((Ly, Lx), np.uint16)
         ypix0, xpix0 = stats[i]["ypix"], stats[i]["xpix"]
@@ -92,7 +90,7 @@ def cellpose_overlap(stats, mimg2):
         iou = ious.max()
         redstats[
             i,
-        ] = np.array([iou > 0.5, iou])    #this had the wrong dimension
+        ] = np.array([iou > 0.5, iou])  #this had the wrong dimension
     return redstats
 
 
@@ -104,8 +102,7 @@ def detect(ops, stats):
     # non-rigid regression with nblks x nblks pieces
     nblks = 3
     Ly, Lx = ops["Ly"], ops["Lx"]
-    ops["meanImg_chan2_corrected"] = correct_bleedthrough(
-        Ly, Lx, nblks, mimg, mimg2)
+    ops["meanImg_chan2_corrected"] = correct_bleedthrough(Ly, Lx, nblks, mimg, mimg2)
 
     redstats = None
     if ops.get("anatomical_red", True):

suite2p/detection/chan2detect.py

@@ -8,8 +8,7 @@
 def pca_denoise(mov: np.ndarray, block_size: List, n_comps_frac: float):
     t0 = time.time()
     nframes, Ly, Lx = mov.shape
-    yblock, xblock, _, block_size, _ = make_blocks(Ly, Lx,
-                                                   block_size=block_size)
+    yblock, xblock, _, block_size, _ = make_blocks(Ly, Lx, block_size=block_size)
 
     mov_mean = mov.mean(axis=0)
     mov -= mov_mean

suite2p/detection/denoise.py

@@ -15,11 +15,9 @@ def detect(ops, classfile=None):
 
     t0 = time.time()
     bin_size = int(
-        max(1, ops["nframes"] // ops["nbinned"],
-            np.round(ops["tau"] * ops["fs"])))
+        max(1, ops["nframes"] // ops["nbinned"], np.round(ops["tau"] * ops["fs"])))
     print("Binning movie in chunks of length %2.2d" % bin_size)
-    with BinaryFile(filename=ops["reg_file"], Ly=ops["Ly"],
-                    Lx=ops["Lx"]) as f:
+    with BinaryFile(filename=ops["reg_file"], Ly=ops["Ly"], Lx=ops["Lx"]) as f:
         mov = f.bin_movie(
             bin_size=bin_size,
             bad_frames=ops.get("badframes"),
@@ -37,8 +35,7 @@ def detect(ops, classfile=None):
 def bin_movie(f_reg, bin_size, yrange=None, xrange=None, badframes=None):
     """ bin registered movie """
     n_frames = f_reg.shape[0]
-    good_frames = ~badframes if badframes is not None else np.ones(
-        n_frames, dtype=bool)
+    good_frames = ~badframes if badframes is not None else np.ones(n_frames, dtype=bool)
     batch_size = min(good_frames.sum(), 500)
     Lyc = yrange[1] - yrange[0]
     Lxc = xrange[1] - xrange[0]
@@ -68,8 +65,7 @@ def bin_movie(f_reg, bin_size, yrange=None, xrange=None, badframes=None):
             # only if current batch size exceeds or matches bin_size
             n_d = data.shape[0]
             data = data[:(n_d // bin_size) * bin_size]
-            data = data.reshape(-1, bin_size, Lyc,
-                                Lxc).astype(np.float32).mean(axis=1)
+            data = data.reshape(-1, bin_size, Lyc, Lxc).astype(np.float32).mean(axis=1)
         else:
             # Current batch size is below bin_size (could have many bad frames in this batch)
             # Downsample taking the mean of batch to get a single bin
@@ -86,8 +82,8 @@ def bin_movie(f_reg, bin_size, yrange=None, xrange=None, badframes=None):
     return mov
 
 
-def detection_wrapper(f_reg, mov=None, yrange=None, xrange=None,
-                      ops=default_ops(), classfile=None):
+def detection_wrapper(f_reg, mov=None, yrange=None, xrange=None, ops=default_ops(),
+                      classfile=None):
     """
 	Main detection function. 
 
@@ -129,8 +125,7 @@ def detection_wrapper(f_reg, mov=None, yrange=None, xrange=None,
 
     if mov is None:
         bin_size = int(
-            max(1, n_frames // ops["nbinned"],
-                np.round(ops["tau"] * ops["fs"])))
+            max(1, n_frames // ops["nbinned"], np.round(ops["tau"] * ops["fs"])))
         print("Binning movie in chunks of length %2.2d" % bin_size)
         mov = bin_movie(f_reg, bin_size, yrange=yrange, xrange=xrange,
                         badframes=ops.get("badframes", None))
@@ -147,9 +142,8 @@ def detection_wrapper(f_reg, mov=None, yrange=None, xrange=None,
 
     if ops.get("denoise", 1):
         mov = pca_denoise(
-            mov,
-            block_size=[ops["block_size"][0] // 2,
-                        ops["block_size"][1] // 2], n_comps_frac=0.5)
+            mov, block_size=[ops["block_size"][0] // 2, ops["block_size"][1] // 2],
+            n_comps_frac=0.5)
 
     if ops.get("anatomical_only", 0):
         try:
@@ -158,20 +152,17 @@ def detection_wrapper(f_reg, mov=None, yrange=None, xrange=None,
         except Exception as e:
             print("Warning: cellpose did not import")
             print(e)
-            print(
-                "cannot use anatomical mode, but otherwise suite2p will run normally"
-            )
+            print("cannot use anatomical mode, but otherwise suite2p will run normally")
             CELLPOSE_INSTALLED = False
         if not CELLPOSE_INSTALLED:
             print(
                 "~~~ tried to import cellpose to run anatomical but failed, install with: ~~~"
             )
             print("$ pip install cellpose")
         else:
-            print(">>>> CELLPOSE finding masks in " + [
-                "max_proj / mean_img", "mean_img", "enhanced_mean_img",
-                "max_proj"
-            ][int(ops["anatomical_only"]) - 1])
+            print(">>>> CELLPOSE finding masks in " +
+                  ["max_proj / mean_img", "mean_img", "enhanced_mean_img", "max_proj"][
+                      int(ops["anatomical_only"]) - 1])
             stat = anatomical.select_rois(ops=ops, mov=mov,
                                           diameter=ops.get("diameter", None))
     else:
@@ -193,26 +184,25 @@ def detection_wrapper(f_reg, mov=None, yrange=None, xrange=None,
 
         if ops["preclassify"] > 0:
             if classfile is None:
-                print(
-                    f"NOTE: Applying user classifier at {str(user_classfile)}")
+                print(f"NOTE: Applying user classifier at {str(user_classfile)}")
                 classfile = user_classfile
 
             stat = roi_stats(stat, Ly, Lx, aspect=ops.get("aspect", None),
-                             diameter=ops.get("diameter", None),
-                             do_crop=ops.get("soma_crop", 1))
+                             diameter=ops.get("diameter",
+                                              None), do_crop=ops.get("soma_crop", 1))
             if len(stat) == 0:
                 iscell = np.zeros((0, 2))
             else:
                 iscell = classify(stat=stat, classfile=classfile)
             np.save(Path(ops["save_path"]).joinpath("iscell.npy"), iscell)
             ic = (iscell[:, 0] > ops["preclassify"]).flatten().astype("bool")
             stat = stat[ic]
-            print("Preclassify threshold %0.2f, %d ROIs removed" %
-                  (ops["preclassify"], (~ic).sum()))
+            print("Preclassify threshold %0.2f, %d ROIs removed" % (ops["preclassify"],
+                                                                    (~ic).sum()))
 
         stat = roi_stats(stat, Ly, Lx, aspect=ops.get("aspect", None),
-                         diameter=ops.get("diameter", None),
-                         max_overlap=ops["max_overlap"],
+                         diameter=ops.get("diameter",
+                                          None), max_overlap=ops["max_overlap"],
                          do_crop=ops.get("soma_crop", 1))
         print("After removing overlaps, %d ROIs remain" % (len(stat)))