rapidtide 3.0.8__py3-none-any.whl → 3.0.10__py3-none-any.whl

rapidtide/workflows/rapidtide.py

@@ -45,8 +45,9 @@ import rapidtide.stats as tide_stats
 import rapidtide.util as tide_util
 import rapidtide.voxelData as tide_voxelData
 import rapidtide.wiener as tide_wiener
+import rapidtide.workflows.calcSimFuncMap as tide_calcSimFuncMap
 import rapidtide.workflows.cleanregressor as tide_cleanregressor
-import rapidtide.workflows.estimateDelayMap as tide_estimateDelayMap
+import rapidtide.workflows.fitSimFuncMap as tide_fitSimFuncMap
 import rapidtide.workflows.refineDelayMap as tide_refineDelayMap
 import rapidtide.workflows.refineRegressor as tide_refineRegressor
 import rapidtide.workflows.regressfrommaps as tide_regressfrommaps
@@ -113,6 +114,10 @@ def echocancel(thetimecourse, echooffset, thetimestep, outputname, padtimepoints
     )
     return outputtimecourse, echofit, echoR2
 
+def setpassoptions(passdict, optiondict):
+    for key, value in passdict.items():
+        optiondict[key] = value
+
 
 def rapidtide_main(argparsingfunc):
     optiondict, theprefilter = argparsingfunc
@@ -572,7 +577,7 @@ def rapidtide_main(argparsingfunc):
         savename = f"{outputname}_desc-processed_mask"
         tide_io.savetonifti(corrmask.reshape(xsize, ysize, numslices), theheader, savename)
 
-    LGR.verbose(f"image threshval = {threshval}")
+    LGR.verbose(f"image threshval = {threshval:.2f}")
     validvoxels = np.where(corrmask > 0)[0]
     if optiondict["debug"]:
         print(f"{validvoxels.shape=}")
@@ -967,7 +972,7 @@ def rapidtide_main(argparsingfunc):
     )
     LGR.verbose("Input vector")
     LGR.verbose(f"length: {len(inputvec)}")
-    LGR.verbose(f"input freq: {inputfreq}")
+    LGR.verbose(f"input freq: {inputfreq:.2f}")
     LGR.verbose(f"input start time: {inputstarttime:.3f}")
 
     if not optiondict["useinitregressorref"]:
@@ -1345,6 +1350,29 @@ def rapidtide_main(argparsingfunc):
             append=False,
         )
 
+    # prepare for fast resampling
+    optiondict["fastresamplerpadtime"] = (
+        max((-optiondict["lagmin"], optiondict["lagmax"]))
+        + 30.0
+        + np.abs(optiondict["offsettime"])
+    )
+    numpadtrs = int(optiondict["fastresamplerpadtime"] // fmritr)
+    optiondict["fastresamplerpadtime"] = fmritr * numpadtrs
+    LGR.info(f"setting up fast resampling with padtime = {optiondict['fastresamplerpadtime']}")
+
+    genlagtc = tide_resample.FastResampler(
+        reference_x, reference_y, padtime=optiondict["fastresamplerpadtime"]
+    )
+    genlagtc.save(f"{outputname}_desc-lagtcgenerator_timeseries")
+    if optiondict["debug"]:
+        genlagtc.info()
+    totalpadlen = validtimepoints + 2 * numpadtrs
+    paddedinitial_fmri_x = (
+        np.linspace(0.0, totalpadlen * fmritr, num=totalpadlen, endpoint=False)
+        + skiptime
+        - fmritr * numpadtrs
+    )
+
     # allocate all the data arrays
     tide_util.logmem("before main array allocation")
     internalspaceshape = numspatiallocs
@@ -1359,7 +1387,30 @@ def rapidtide_main(argparsingfunc):
     outmaparray = np.zeros(internalspaceshape, dtype=rt_floattype)
     tide_util.logmem("after main array allocation")
 
-    corroutlen = np.shape(trimmedcorrscale)[0]
+    if optiondict["similaritymetric"] == "riptide":
+        riptideregressorset, riptidedelays = tide_calcSimFuncMap.makeRIPTiDeRegressors(
+            initial_fmri_x,
+            optiondict["lagmin"],
+            optiondict["lagmax"],
+            genlagtc,
+            LGR,
+            targetstep=optiondict["riptidestep"],
+            edgepad=0,
+            showprogressbar=optiondict["showprogressbar"],
+            chunksize=optiondict["mp_chunksize"],
+            nprocs=optiondict["nprocs"],
+            alwaysmultiproc=optiondict["alwaysmultiproc"],
+            rt_floatset=rt_floatset,
+            rt_floattype=rt_floattype,
+            debug=optiondict["debug"],
+        )
+        numriptideregressors = riptideregressorset.shape[0]
+        corroutlen = numriptideregressors
+    else:
+        riptideregressorset = None
+        riptidedelays = None
+        corroutlen = np.shape(trimmedcorrscale)[0]
+
     if theinputdata.filetype == "text":
         nativecorrshape = (xsize, corroutlen)
     else:
@@ -1372,6 +1423,7 @@ def rapidtide_main(argparsingfunc):
     LGR.debug(
         f"allocating memory for correlation arrays {internalcorrshape} {internalvalidcorrshape}"
     )
+
     corrout, corrout_shm = tide_util.allocarray(
         internalvalidcorrshape,
         rt_floatset,
@@ -1427,29 +1479,6 @@ def rapidtide_main(argparsingfunc):
     else:
         theinitialdelay = None
 
-    # prepare for fast resampling
-    optiondict["fastresamplerpadtime"] = (
-        max((-optiondict["lagmin"], optiondict["lagmax"]))
-        + 30.0
-        + np.abs(optiondict["offsettime"])
-    )
-    numpadtrs = int(optiondict["fastresamplerpadtime"] // fmritr)
-    optiondict["fastresamplerpadtime"] = fmritr * numpadtrs
-    LGR.info(f"setting up fast resampling with padtime = {optiondict['fastresamplerpadtime']}")
-
-    genlagtc = tide_resample.FastResampler(
-        reference_x, reference_y, padtime=optiondict["fastresamplerpadtime"]
-    )
-    genlagtc.save(f"{outputname}_desc-lagtcgenerator_timeseries")
-    if optiondict["debug"]:
-        genlagtc.info()
-    totalpadlen = validtimepoints + 2 * numpadtrs
-    paddedinitial_fmri_x = (
-        np.linspace(0.0, totalpadlen * fmritr, num=totalpadlen, endpoint=False)
-        + skiptime
-        - fmritr * numpadtrs
-    )
-
     if theinputdata.filetype == "text":
         nativefmrishape = (xsize, np.shape(initial_fmri_x)[0])
     elif theinputdata.filetype == "cifti":
@@ -1465,7 +1494,12 @@ def rapidtide_main(argparsingfunc):
     )
 
     # now do the arrays for delay refinement
-    if optiondict["dolinfitfilt"] or optiondict["docvrmap"] or optiondict["refinedelay"]:
+    if (
+        optiondict["dolinfitfilt"]
+        or optiondict["docvrmap"]
+        or optiondict["refinedelay"]
+        or (optiondict["similaritymetric"] == "riptide")
+    ):
         if optiondict["refinedelay"]:
             derivaxissize = np.max([2, optiondict["regressderivs"] + 1])
         else:
@@ -1526,6 +1560,13 @@ def rapidtide_main(argparsingfunc):
         thesize, theunit = tide_util.format_bytes(optiondict["totalRefineDelaybytes"])
         print(f"allocated {thesize:.3f} {theunit} {ramlocation} for delay refinement")
         tide_util.logmem("after derivative delay/sLFO filter array allocation")
+    else:
+        sLFOfitmean = None
+        rvalue = None
+        r2value = None
+        fitNorm = None
+        fitcoeff = None
+        lagtc = None
 
     # prepare for regressor refinement, if we're doing it
     if (
@@ -1686,6 +1727,19 @@ def rapidtide_main(argparsingfunc):
     optiondict["currentstage"] = "preprocessingdone"
     tide_io.writedicttojson(optiondict, f"{outputname}_desc-runoptions_info.json")
 
+    # set up the pass options array
+    optiondict["passoptions"] = []
+    """optiondict["passoptions"].append(
+        {
+            "similaritymetric": "riptide"
+        }
+    )
+    optiondict["passoptions"].append(
+        {
+            "similaritymetric": optiondict["similaritymetric"]
+        }
+    )"""
+
     ####################################################
     #  Start the iterative fit and refinement
     ####################################################
@@ -1698,6 +1752,10 @@ def rapidtide_main(argparsingfunc):
             LGR.info("\n\n*********************")
             LGR.info(f"Pass number {thepass}")
 
+        # fetch the pass options
+        if len(optiondict["passoptions"]) >= thepass:
+            setpassoptions(optiondict["passoptions"][thepass - 1], optiondict)
+
         referencetc = tide_math.corrnormalize(
             resampref_y[osvalidsimcalcstart : osvalidsimcalcend + 1],
             detrendorder=optiondict["detrendorder"],
@@ -1756,13 +1814,6 @@ def rapidtide_main(argparsingfunc):
             LGR.info(f"\n\nSignificance estimation, pass {thepass}")
             if optiondict["checkpoint"]:
                 # bidsify
-                """tide_io.writebidstsv(
-                    f"{outputname}_desc-movingregressor_timeseries",
-                    tide_math.stdnormalize(resampnonosref_y),
-                    1.0 / fmritr,
-                    columns=["pass1"],
-                    append=False,
-                )"""
                 tide_io.writenpvecs(
                     cleaned_referencetc,
                     f"{outputname}_cleanedreference_pass" + str(thepass) + ".txt",
@@ -1903,8 +1954,9 @@ def rapidtide_main(argparsingfunc):
         optiondict["currentstage"] = f"precorrelation_pass{thepass}"
         tide_io.writedicttojson(optiondict, f"{outputname}_desc-runoptions_info.json")
 
-        # step 1 - do the initial delay estimation
-        internaldespeckleincludemask = tide_estimateDelayMap.estimateDelay(
+        # Step 1a - do the initial delay estimation
+        similaritytype = tide_calcSimFuncMap.calcSimFunc(
+            numvalidspatiallocs,
             fmri_data_valid,
             validsimcalcstart,
             validsimcalcend,
@@ -1916,12 +1968,81 @@ def rapidtide_main(argparsingfunc):
             theMutualInformationator,
             cleaned_referencetc,
             corrout,
+            riptideregressorset,
+            riptidedelays,
+            sLFOfitmean,
+            r2value,
+            fitcoeff,
+            fitNorm,
             meanval,
             corrscale,
             outputname,
             outcorrarray,
             validvoxels,
             nativecorrshape,
+            theinputdata,
+            theheader,
+            lagmininpts,
+            lagmaxinpts,
+            thepass,
+            optiondict,
+            LGR,
+            TimingLGR,
+            similaritymetric=optiondict["similaritymetric"],
+            simcalcoffset=optiondict["simcalcoffset"],
+            echocancel=optiondict["echocancel"],
+            checkpoint=optiondict["checkpoint"],
+            mklthreads=optiondict["mklthreads"],
+            nprocs=optiondict["nprocs_calcsimilarity"],
+            alwaysmultiproc=optiondict["alwaysmultiproc"],
+            oversampfactor=optiondict["oversampfactor"],
+            interptype=optiondict["interptype"],
+            showprogressbar=optiondict["showprogressbar"],
+            chunksize=optiondict["mp_chunksize"],
+            rt_floatset=rt_floatset,
+            rt_floattype=rt_floattype,
+            threaddebug=optiondict["threaddebug"],
+            debug=optiondict["focaldebug"],
+        )
+        if optiondict["similaritymetric"] == "riptide":
+            optiondict["despeckle_passes"] = 0
+            fitcorrscale = riptidedelays
+        else:
+            fitcorrscale = trimmedcorrscale
+
+        if optiondict["saveintermediatemaps"]:
+            theheader = theinputdata.copyheader(numtimepoints=1)
+            bidspasssuffix = f"_intermediatedata-pass{thepass}"
+            maplist = [
+                (lagtimes, "maxtimecoarse", "map", "second", "Lag time in seconds"),
+                (lagstrengths, "maxcorrcoarse", "map", None, "Maximum correlation strength"),
+            ]
+            tide_io.savemaplist(
+                f"{outputname}{bidspasssuffix}",
+                maplist,
+                validvoxels,
+                nativespaceshape,
+                theheader,
+                bidsbasedict,
+                filetype=theinputdata.filetype,
+                rt_floattype=rt_floattype,
+                cifti_hdr=theinputdata.cifti_hdr,
+            )
+
+        # Step 2a - fit the delay function
+        internaldespeckleincludemask = tide_fitSimFuncMap.fitSimFunc(
+            fmri_data_valid,
+            validsimcalcstart,
+            validsimcalcend,
+            osvalidsimcalcstart,
+            osvalidsimcalcend,
+            initial_fmri_x,
+            os_fmri_x,
+            theMutualInformationator,
+            cleaned_referencetc,
+            corrout,
+            outputname,
+            validvoxels,
             nativespaceshape,
             bidsbasedict,
             numspatiallocs,
@@ -1941,17 +2062,18 @@ def rapidtide_main(argparsingfunc):
             lagsigma,
             failreason,
             outmaparray,
-            lagmininpts,
-            lagmaxinpts,
+            fitcorrscale,
+            similaritytype,
             thepass,
             optiondict,
             LGR,
             TimingLGR,
+            simplefit=(optiondict["similaritymetric"] == "riptide"),
             rt_floatset=np.float64,
             rt_floattype="float64",
         )
 
-        # refine delay
+        # Step 2b - refine delay (optional)
         if optiondict["refinedelayeachpass"]:
             if optiondict["delayoffsetgausssigma"] < 0.0 and theinputdata.filetype != "text":
                 # set gausssigma automatically
@@ -2006,7 +2128,26 @@ def rapidtide_main(argparsingfunc):
             )
             lagtimes[:] = lagtimes + delayoffset
 
-        # Step 2d - make a rank order map
+            if optiondict["saveintermediatemaps"]:
+                theheader = theinputdata.copyheader(numtimepoints=1)
+                bidspasssuffix = f"_intermediatedata-pass{thepass}"
+                maplist = [
+                    (lagtimes, "maxtimerefined", "map", "second", "Lag time in seconds"),
+                    (lagstrengths, "maxcorrrefined", "map", None, "Maximum correlation strength"),
+                ]
+                tide_io.savemaplist(
+                    f"{outputname}{bidspasssuffix}",
+                    maplist,
+                    validvoxels,
+                    nativespaceshape,
+                    theheader,
+                    bidsbasedict,
+                    filetype=theinputdata.filetype,
+                    rt_floattype=rt_floattype,
+                    cifti_hdr=theinputdata.cifti_hdr,
+                )
+
+        # Step 2b - make a rank order map
         timepercentile = (
             100.0 * (rankdata(lagtimes, method="dense") - 1) / (numvalidspatiallocs - 1)
         )
@@ -2499,7 +2640,7 @@ def rapidtide_main(argparsingfunc):
                     nprocs_makelaggedtcs=optiondict["nprocs_makelaggedtcs"],
                     nprocs_regressionfilt=optiondict["nprocs_regressionfilt"],
                     regressderivs=optiondict["regressderivs"],
-                    mp_chunksize=optiondict["mp_chunksize"],
+                    chunksize=optiondict["mp_chunksize"],
                     showprogressbar=optiondict["showprogressbar"],
                     alwaysmultiproc=optiondict["alwaysmultiproc"],
                     debug=optiondict["debug"],
@@ -2987,7 +3128,7 @@ def rapidtide_main(argparsingfunc):
                 nprocs_makelaggedtcs=optiondict["nprocs_makelaggedtcs"],
                 nprocs_regressionfilt=optiondict["nprocs_regressionfilt"],
                 regressderivs=optiondict["regressderivs"],
-                mp_chunksize=optiondict["mp_chunksize"],
+                chunksize=optiondict["mp_chunksize"],
                 showprogressbar=optiondict["showprogressbar"],
                 alwaysmultiproc=optiondict["alwaysmultiproc"],
                 debug=optiondict["debug"],
@@ -3147,11 +3288,19 @@ def rapidtide_main(argparsingfunc):
     del fitmask
 
     # now do the 4D maps of the similarity function and friends
-    theheader = theinputdata.copyheader(
-        numtimepoints=np.shape(outcorrarray)[1],
-        tr=corrtr,
-        toffset=(corrscale[corrorigin - lagmininpts]),
-    )
+    if optiondict["similaritymetric"] == "riptide":
+        theheader = theinputdata.copyheader(
+            numtimepoints=np.shape(outcorrarray)[1],
+            tr=riptidedelays[1] - riptidedelays[0],
+            toffset=(riptidedelays[0]),
+        )
+    else:
+        theheader = theinputdata.copyheader(
+            numtimepoints=np.shape(outcorrarray)[1],
+            tr=corrtr,
+            toffset=(corrscale[corrorigin - lagmininpts]),
+        )
+
     if (
         optiondict["savecorrout"]
         or (optiondict["outputlevel"] != "min")

rapidtide/workflows/rapidtide_parser.py

@@ -96,6 +96,9 @@ DEFAULT_OUTPUTLEVEL = "normal"
 
 DEFAULT_SLFONOISEAMP_WINDOWSIZE = 40.0
 
+DEFAULT_COARSEDELAY_TYPE = "simfunc"
+DEFAULT_RIPTIDESTEP = 2.0
+
 DEFAULT_PATCHTHRESH = 3.0
 DEFAULT_REFINEDELAYMINDELAY = -5.0
 DEFAULT_REFINEDELAYMAXDELAY = 5.0
@@ -779,10 +782,10 @@ def _get_parser():
         dest="similaritymetric",
         action="store",
         type=str,
-        choices=["correlation", "mutualinfo", "hybrid"],
+        choices=["correlation", "mutualinfo", "hybrid", "riptide"],
         help=(
             "Similarity metric for finding delay values.  "
-            'Choices are "correlation", "mutualinfo", and "hybrid". '
+            'Choices are "correlation", "mutualinfo", "hybrid", and "riptide". '
             f"Default is {DEFAULT_SIMILARITYMETRIC}."
         ),
         default=DEFAULT_SIMILARITYMETRIC,
@@ -1442,6 +1445,17 @@ def _get_parser():
     experimental = parser.add_argument_group(
         "Experimental options (not fully tested, or not tested at all, may not work).  Beware!"
     )
+    output.add_argument(
+        "--riptidestep",  # was -h
+        dest="riptidestep",
+        action="store",
+        type=lambda x: pf.is_float(parser, x, maxval=5.0),
+        metavar="STEP",
+        help=(
+            f"Timestep between RIPTiDe regressors, in seconds.  Default is {DEFAULT_RIPTIDESTEP}."
+        ),
+        default=DEFAULT_RIPTIDESTEP,
+    )
     experimental.add_argument(
         "--refinedelayeachpass",
         dest="refinedelayeachpass",
@@ -2206,6 +2220,13 @@ def process_args(inputargs=None):
         print(f"illegal output level {args['outputlevel']}")
         sys.exit()
 
+    # make the pass options dictionary
+    args["passoptions"] = [
+        {"similaritymetric": "riptide",},
+        {"similaritymetric": "correlation", },
+        {"similaritymetric": "correlation", },
+    ]
+
     # dispersion calculation
     args["dispersioncalc_lower"] = args["lagmin"]
     args["dispersioncalc_upper"] = args["lagmax"]

rapidtide/workflows/regressfrommaps.py

@@ -49,11 +49,11 @@ def regressfrommaps(
     nprocs_makelaggedtcs=1,
     nprocs_regressionfilt=1,
     regressderivs=0,
-    mp_chunksize=50000,
+    chunksize=50000,
     showprogressbar=True,
     alwaysmultiproc=False,
     saveEVsandquit=False,
-    ratiosonly=False,
+    coefficientsonly=False,
     debug=False,
 ):
     if debug:
@@ -61,7 +61,7 @@ def regressfrommaps(
         print(f"\t{nprocs_makelaggedtcs=}")
         print(f"\t{nprocs_regressionfilt=}")
         print(f"\t{regressderivs=}")
-        print(f"\t{mp_chunksize=}")
+        print(f"\t{chunksize=}")
         print(f"\t{showprogressbar=}")
         print(f"\t{alwaysmultiproc=}")
         print(f"\t{mode=}")
@@ -88,7 +88,7 @@ def regressfrommaps(
         nprocs=nprocs_makelaggedtcs,
         alwaysmultiproc=alwaysmultiproc,
         showprogressbar=showprogressbar,
-        chunksize=mp_chunksize,
+        chunksize=chunksize,
         rt_floatset=rt_floatset,
         rt_floattype=rt_floattype,
         debug=debug,
@@ -146,12 +146,12 @@ def regressfrommaps(
         fitNorm,
         movingsignal,
         filtereddata,
-        ratiosonly=ratiosonly,
+        coefficientsonly=coefficientsonly,
         nprocs=nprocs_regressionfilt,
         alwaysmultiproc=alwaysmultiproc,
         showprogressbar=showprogressbar,
         verbose=(LGR is not None),
-        mp_chunksize=mp_chunksize,
+        chunksize=chunksize,
         rt_floatset=rt_floatset,
         rt_floattype=rt_floattype,
         debug=debug,
@@ -162,7 +162,7 @@ def regressfrommaps(
         fitcoeff *= 100.0
 
     # determine what was removed
-    if not ratiosonly:
+    if not coefficientsonly:
         removeddata = fmri_data_valid - filtereddata
         noiseremoved = np.var(removeddata, axis=0)
         if saveminimumsLFOfiltfiles:

rapidtide/workflows/tidepool.py

@@ -39,12 +39,17 @@ from rapidtide.simFuncClasses import SimilarityFunctionFitter
 from rapidtide.workflows.atlasaverage import summarizevoxels
 
 try:
-    from PyQt6.QtCore import QT_VERSION_STR
+    from PySide6.QtCore import __version__
 except ImportError:
-    pyqtversion = 5
+    try:
+        from PyQt6.QtCore import QT_VERSION_STR
+    except ImportError:
+        pyqtbinding = "pyqt5"
+    else:
+        pyqtbinding = "pyqt6"
 else:
-    pyqtversion = 6
-print(f"using {pyqtversion=}")
+    pyqtbinding = "pyside6"
+print(f"using {pyqtbinding=}")
 
 os.environ["QT_MAC_WANTS_LAYER"] = "1"
 
@@ -184,10 +189,14 @@ def updateFileMenu():
     global fileMenu, sel_open
     global sel_files
 
-    if pyqtversion == 5:
+    if pyqtbinding == "pyqt5":
         qactionfunc = QtWidgets.QAction
-    else:
+    elif pyqtbinding == "pyqt6":
         qactionfunc = QtGui.QAction
+    elif pyqtbinding == "pyside6":
+        qactionfunc = QtGui.QAction
+    else:
+        print("unsupported")
 
     # scrub file menu
     if sel_files is not None:
@@ -214,10 +223,14 @@ def datasetPicker():
     global verbosity
 
     mydialog = QtWidgets.QFileDialog()
-    if pyqtversion == 5:
+    if pyqtbinding == "pyqt5":
         options = mydialog.Options()
-    else:
+    elif pyqtbinding == "pyqt6":
         options = mydialog.options()
+    elif pyqtbinding == "pyside6":
+        options = mydialog.options()
+    else:
+        print("unsupported")
     lagfilename = mydialog.getOpenFileName(
         options=options,
         filter="Lag time files (*_lagtimes.nii.gz *_desc-maxtime_map.nii.gz)",
@@ -591,8 +604,14 @@ class xyztlocation(QtWidgets.QWidget):
 
 
 def logStatus(thetextbox, thetext):
-    if pyqtversion == 5:
+    if pyqtbinding == "pyqt5":
         thetextbox.moveCursor(QtGui.QTextCursor.End)
+    elif pyqtbinding == "pyqt6":
+        pass
+    elif pyqtbinding == "pyside6":
+        pass
+    else:
+        print("unsupported")
     thetextbox.insertPlainText(thetext + "\n")
     sb = thetextbox.verticalScrollBar()
     sb.setValue(sb.maximum())
@@ -1773,20 +1792,29 @@ def tidepool(args):
     uiinitialized = False
     sel_files = None
 
-    if pyqtversion == 5:
+    if pyqtbinding == "pyqt5":
         if args.uistyle == "normal":
             import rapidtide.tidepoolTemplate_alt as uiTemplate
         elif args.uistyle == "big":
             import rapidtide.tidepoolTemplate_big as uiTemplate
         else:
             import rapidtide.tidepoolTemplate as uiTemplate
-    else:
+    elif pyqtbinding == "pyqt6":
         if args.uistyle == "normal":
             import rapidtide.tidepoolTemplate_alt_qt6 as uiTemplate
         elif args.uistyle == "big":
             import rapidtide.tidepoolTemplate_big_qt6 as uiTemplate
         else:
             import rapidtide.tidepoolTemplate_qt6 as uiTemplate
+    elif pyqtbinding == "pyside6":
+        if args.uistyle == "normal":
+            import rapidtide.tidepoolTemplate_alt_qt6 as uiTemplate
+        elif args.uistyle == "big":
+            import rapidtide.tidepoolTemplate_big_qt6 as uiTemplate
+        else:
+            import rapidtide.tidepoolTemplate_qt6 as uiTemplate
+    else:
+        print("unsupported")
 
     verbosity = args.verbose
     print(f"verbosity: {verbosity}")
@@ -1839,10 +1867,14 @@ def tidepool(args):
     print("creating menu bar")
     menuBar = win.menuBar()
     fileMenu = menuBar.addMenu("File")
-    if pyqtversion == 5:
+    if pyqtbinding == "pyqt5":
         qactionfunc = QtWidgets.QAction
-    else:
+    elif pyqtbinding == "pyqt6":
         qactionfunc = QtGui.QAction
+    elif pyqtbinding == "pyside6":
+        qactionfunc = QtGui.QAction
+    else:
+        print("unsupported")
     sel_open = qactionfunc("Add dataset...", win)
     sel_open.triggered.connect(datasetPicker)
     fileMenu.addAction(sel_open)
@@ -2196,10 +2228,14 @@ def tidepool(args):
 
     # define things for the popup mask menu
     popMaskMenu = QtWidgets.QMenu(win)
-    if pyqtversion == 5:
+    if pyqtbinding == "pyqt5":
         qactionfunc = QtWidgets.QAction
-    else:
+    elif pyqtbinding == "pyqt6":
         qactionfunc = QtGui.QAction
+    elif pyqtbinding == "pyside6":
+        qactionfunc = QtGui.QAction
+    else:
+        print("unsupported")
     sel_nomask = qactionfunc("No mask", win)
     sel_lagmask = qactionfunc("Valid fit", win)
     sel_brainmask = qactionfunc("Externally provided brain mask", win)

{rapidtide-3.0.8.dist-info → rapidtide-3.0.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rapidtide
-Version: 3.0.8
+Version: 3.0.10
 Summary: Tools for performing correlation analysis on fMRI data.
 Author: Taylor Salo, Daniel M. Drucker, Ph.D., Jeffrey N Stout, Yaroslav O. Halchenko, Derek Monroe
 Author-email: "Blaise deB. Frederick" <blaise.frederick@gmail.com>
@@ -38,8 +38,8 @@ Requires-Dist: pyqt6
 Requires-Dist: requests
 Requires-Dist: statsmodels
 Requires-Dist: pywavelets
-Requires-Dist: tensorflow>=2.10.0
-Requires-Dist: tf-keras
+Requires-Dist: tensorflow>=2.18.0
+Requires-Dist: tf-keras>=2.18.0
 Requires-Dist: tqdm
 Requires-Dist: versioneer
 Provides-Extra: tests