consenrich 0.7.1b1__cp314-cp314-macosx_11_0_arm64.whl → 0.7.1b2__cp314-cp314-macosx_11_0_arm64.whl

consenrich/consenrich.py

@@ -346,9 +346,39 @@ def readConfig(config_path: str) -> Dict[str, Any]:
     minQ_default = (
         minR_default / (len(inputParams.bamFiles))
     ) + 0.10  # protect condition number
+
     matchingExcludeRegionsBedFile_default: Optional[str] = (
         genomeParams.blacklistFile
     )
+
+    # apply less aggressive *default* detrending/background removal
+    # ...IF input controls are present. In either case, respect
+    # ...user-specified params
+    detrendWindowLengthBP_: int = -1
+    detrendSavitzkyGolayDegree_: int = -1
+
+    if (
+        inputParams.bamFilesControl is not None
+        and len(inputParams.bamFilesControl) > 0
+    ):
+        detrendWindowLengthBP_ = config.get(
+            "detrendParams.detrendWindowLengthBP",
+            25_000,
+        )
+        detrendSavitzkyGolayDegree_ = config.get(
+            "detrendParams.detrendSavitzkyGolayDegree",
+            1,
+        )
+    else:
+        detrendWindowLengthBP_ = config.get(
+            "detrendParams.detrendWindowLengthBP",
+            10_000,
+        )
+        detrendSavitzkyGolayDegree_ = config.get(
+            "detrendParams.detrendSavitzkyGolayDegree",
+            2,
+        )
+
     return {
         "experimentName": config.get(
             "experimentName", "consenrichExperiment"
@@ -378,35 +408,44 @@ def readConfig(config_path: str) -> Dict[str, Any]:
             noGlobal=config.get("observationParams.noGlobal", False),
             numNearest=config.get("observationParams.numNearest", 25),
             localWeight=config.get(
-                "observationParams.localWeight", 0.333
+                "observationParams.localWeight",
+                0.333,
             ),
             globalWeight=config.get(
-                "observationParams.globalWeight", 0.667
+                "observationParams.globalWeight",
+                0.667,
             ),
             approximationWindowLengthBP=config.get(
-                "observationParams.approximationWindowLengthBP", 10000
+                "observationParams.approximationWindowLengthBP",
+                10000,
             ),
             lowPassWindowLengthBP=config.get(
-                "observationParams.lowPassWindowLengthBP", 20000
+                "observationParams.lowPassWindowLengthBP",
+                20000,
             ),
             lowPassFilterType=config.get(
-                "observationParams.lowPassFilterType", "median"
+                "observationParams.lowPassFilterType",
+                "median",
             ),
             returnCenter=config.get(
-                "observationParams.returnCenter", True
+                "observationParams.returnCenter",
+                True,
             ),
         ),
         "stateArgs": core.stateParams(
             stateInit=config.get("stateParams.stateInit", 0.0),
             stateCovarInit=config.get(
-                "stateParams.stateCovarInit", 100.0
+                "stateParams.stateCovarInit",
+                100.0,
             ),
             boundState=config.get("stateParams.boundState", True),
             stateLowerBound=config.get(
-                "stateParams.stateLowerBound", 0.0
+                "stateParams.stateLowerBound",
+                0.0,
             ),
             stateUpperBound=config.get(
-                "stateParams.stateUpperBound", 10000.0
+                "stateParams.stateUpperBound",
+                10000.0,
             ),
         ),
         "samArgs": core.samParams(
@@ -434,32 +473,37 @@ def readConfig(config_path: str) -> Dict[str, Any]:
                 else 0,
             ),
             countEndsOnly=config.get(
-                "samParams.countEndsOnly", False
+                "samParams.countEndsOnly",
+                False,
             ),
         ),
         "detrendArgs": core.detrendParams(
-            detrendWindowLengthBP=config.get(
-                "detrendParams.detrendWindowLengthBP", 10000
-            ),
+            detrendWindowLengthBP=detrendWindowLengthBP_,
             detrendTrackPercentile=config.get(
-                "detrendParams.detrendTrackPercentile", 75.0
+                "detrendParams.detrendTrackPercentile",
+                75,
             ),
             usePolyFilter=config.get(
-                "detrendParams.usePolyFilter", False
+                "detrendParams.usePolyFilter",
+                False,
             ),
             detrendSavitzkyGolayDegree=config.get(
-                "detrendParams.detrendSavitzkyGolayDegree", 2
+                "detrendParams.detrendSavitzkyGolayDegree",
+                detrendSavitzkyGolayDegree_,
             ),
             useOrderStatFilter=config.get(
-                "detrendParams.useOrderStatFilter", True
+                "detrendParams.useOrderStatFilter",
+                True,
             ),
         ),
         "matchingArgs": core.matchingParams(
             templateNames=config.get(
-                "matchingParams.templateNames", []
+                "matchingParams.templateNames",
+                [],
             ),
             cascadeLevels=config.get(
-                "matchingParams.cascadeLevels", [2]
+                "matchingParams.cascadeLevels",
+                [],
             ),
             iters=config.get("matchingParams.iters", 25_000),
             alpha=config.get("matchingParams.alpha", 0.05),
@@ -692,6 +736,9 @@ def main():
     scaleDown = countingArgs.scaleDown
     extendBP_ = core.resolveExtendBP(samArgs.extendBP, bamFiles)
     initialTreatmentScaleFactors = []
+    minMatchLengthBP_: Optional[int] = matchingArgs.minMatchLengthBP
+    mergeGapBP_: Optional[int] = matchingArgs.mergeGapBP
+
     if args.verbose:
         try:
             logger.info("Configuration:\n")
@@ -1021,6 +1068,18 @@ def main():
             )
         try:
             if matchingEnabled:
+                if (
+                    minMatchLengthBP_ is None
+                    or minMatchLengthBP_ <= 0
+                ):
+                    minMatchLengthBP_ = (
+                        matching.autoMinLengthIntervals(x_)
+                        * (intervals[1] - intervals[0])
+                    )
+
+                if mergeGapBP_ is None:
+                    mergeGapBP_ = int(minMatchLengthBP_ / 2) + 1
+
                 matchingDF = matching.matchWavelet(
                     chromosome,
                     intervals,
@@ -1029,7 +1088,7 @@ def main():
                     matchingArgs.cascadeLevels,
                     matchingArgs.iters,
                     matchingArgs.alpha,
-                    matchingArgs.minMatchLengthBP,
+                    minMatchLengthBP_,
                     matchingArgs.maxNumMatches,
                     matchingArgs.minSignalAtMaxima,
                     useScalingFunction=matchingArgs.useScalingFunction,
@@ -1055,10 +1114,11 @@ def main():
     if matchingEnabled and matchingArgs.merge:
         try:
             mergeGapBP_ = matchingArgs.mergeGapBP
-            if mergeGapBP_ is None:
+            if mergeGapBP_ is None or mergeGapBP_ <= 0:
                 mergeGapBP_ = (
-                    int(matchingArgs.minMatchLengthBP/2) + 1
-                    if matchingArgs.minMatchLengthBP is not None
+                    int(minMatchLengthBP_ / 2) + 1
+                    if minMatchLengthBP_ is not None
+                    and minMatchLengthBP_ >= 0
                     else 75
                 )
             matching.mergeMatches(

consenrich/core.py

@@ -317,10 +317,11 @@ class matchingParams(NamedTuple):
 
     See :ref:`matching` for an overview of the approach.
 
-    :param templateNames: A list of str values -- wavelet bases used for matching, e.g., `[haar, db2, sym4]`
+    :param templateNames: A list of str values -- each entry references a mother wavelet (or its corresponding scaling function). e.g., `[haar, db2]`
     :type templateNames: List[str]
-    :param cascadeLevels: A list of int values -- the number of cascade iterations used for approximating
-        the scaling/wavelet functions.
+    :param cascadeLevels: Number of cascade iterations used to approximate each template (wavelet or scaling function).
+        Must have the same length as `templateNames`, with each entry aligned to the
+        corresponding template. e.g., given templateNames `[haar, db2]`, then `[2,2]` would use 2 cascade levels for both templates.
     :type cascadeLevels: List[int]
     :param iters: Number of random blocks to sample in the response sequence while building
         an empirical null to test significance. See :func:`cconsenrich.csampleBlockStats`.
@@ -331,7 +332,8 @@ class matchingParams(NamedTuple):
     :type alpha: float
     :param minMatchLengthBP: Within a window of `minMatchLengthBP` length (bp), relative maxima in
         the signal-template convolution must be greater in value than others to qualify as matches.
-    :type minMatchLengthBP: int
+        If set to a value less than 1, the minimum length is determined via :func:`consenrich.matching.autoMinLengthIntervals`.
+        If set to `None`, defaults to 250 bp.
     :param minSignalAtMaxima: Secondary significance threshold coupled with `alpha`. Requires the *signal value*
         at relative maxima in the response sequence to be greater than this threshold. Comparisons are made in log-scale
         to temper genome-wide dynamic range. If a `float` value is provided, the minimum signal value must be greater

consenrich/matching.py

@@ -24,6 +24,45 @@ logging.basicConfig(
 logger = logging.getLogger(__name__)
 
 
+def autoMinLengthIntervals(
+    values: np.ndarray, initLen: int = 3
+) -> int:
+    r"""Determines a minimum matching length (in interval units) based on the input signal values.
+
+    Returns the mean length of non-zero contiguous segments in a log-scaled/centered version of `values`
+
+    :param values: A 1D array of signal-like values.
+    :type values: np.ndarray
+    :param initLen: Initial minimum length (in intervals). Defaults to 3.
+    :type initLen: int
+    :return: Estimated minimum matching length (in intervals)
+    :rtype: int
+
+    """
+    trValues = np.asinh(values) - signal.medfilt(
+        np.asinh(values),
+        kernel_size=
+            max(
+                (2 * initLen) + 1,
+                2 * (int(len(values) * 0.005)) + 1,
+            )
+    )
+    nz = trValues[trValues > 0]
+    if len(nz) == 0:
+        return initLen
+    thr = np.quantile(nz, 0.90, method="interpolated_inverted_cdf")
+    mask = nz >= thr
+    if not np.any(mask):
+        return initLen
+    idx = np.flatnonzero(np.diff(np.r_[False, mask, False]))
+    runs = idx.reshape(-1, 2)
+    widths = runs[:, 1] - runs[:, 0]
+    widths = widths[widths >= initLen]
+    if len(widths) == 0:
+        return initLen
+    return int(np.mean(widths))
+
+
 def scalarClip(value: float, low: float, high: float) -> float:
     return low if value < low else high if value > high else value
 
@@ -124,7 +163,7 @@ def matchExistingBedGraph(
     for chrom_ in sorted(bedGraphDF["chromosome"].unique()):
         df_ = bedGraphDF[bedGraphDF["chromosome"] == chrom_]
         if len(df_) < 5:
-            logger.info(f"Skipping {chrom_}: fewer than 5 rows.")
+            logger.info(f"Skipping {chrom_}: less than 5 intervals.")
             continue
 
         try:
@@ -234,17 +273,18 @@ def matchWavelet(
     excludeRegionsBedFile: Optional[str] = None,
     weights: Optional[npt.NDArray[np.float64]] = None,
 ) -> pd.DataFrame:
-    r"""Detect structured peaks by cross-correlating Consenrich tracks with wavelet- or scaling-function templates.
+    r"""Detect structured peaks in Consenrich tracks by matching wavelet- or scaling-function–based templates.
 
     :param chromosome: Chromosome name for the input intervals and values.
     :type chromosome: str
     :param values: A 1D array of signal-like values. In this documentation, we refer to values derived from Consenrich,
         but other continuous-valued tracks at evenly spaced genomic intervals may be suitable, too.
     :type values: npt.NDArray[np.float64]
-    :param templateNames: A list of str values -- wavelet bases used for matching, e.g., `[haar, db2, sym4]`
+    :param templateNames: A list of str values -- each entry references a mother wavelet (or its corresponding scaling function). e.g., `[haar, db2]`
     :type templateNames: List[str]
-    :param cascadeLevels: A list of int values -- the number of cascade iterations used for approximating
-        the scaling/wavelet functions.
+    :param cascadeLevels: Number of cascade iterations used to approximate each template (wavelet or scaling function).
+        Must have the same length as `templateNames`, with each entry aligned to the
+        corresponding template. e.g., given templateNames `[haar, db2]`, then `[2,2]` would use 2 cascade levels for both templates.
     :type cascadeLevels: List[int]
     :param iters: Number of random blocks to sample in the response sequence while building
         an empirical null to test significance. See :func:`cconsenrich.csampleBlockStats`.
@@ -255,7 +295,9 @@ def matchWavelet(
     :type alpha: float
     :param minMatchLengthBP: Within a window of `minMatchLengthBP` length (bp), relative maxima in
         the signal-template convolution must be greater in value than others to qualify as matches.
-    :type minMatchLengthBP: int
+        If set to a value less than 1, the minimum length is determined via :func:`consenrich.matching.autoMinLengthIntervals`.
+        If set to `None`, defaults to 250 bp.
+    :type minMatchLengthBP: Optional[int]
     :param minSignalAtMaxima: Secondary significance threshold coupled with `alpha`. Requires the *signal value*
         at relative maxima in the response sequence to be greater than this threshold. Comparisons are made in log-scale
         to temper genome-wide dynamic range. If a `float` value is provided, the minimum signal value must be greater
@@ -274,19 +316,47 @@ def matchWavelet(
     :return: A pandas DataFrame with detected matches
     :rtype: pd.DataFrame
     """
+
+    rng = np.random.default_rng(int(randSeed))
     if len(intervals) < 5:
         raise ValueError("`intervals` must be at least length 5")
+
     if len(values) != len(intervals):
         raise ValueError(
             "`values` must have the same length as `intervals`"
         )
+
+    if len(templateNames) != len(cascadeLevels):
+        raise ValueError(
+            "\n\t`templateNames` and `cascadeLevels` must have the same length."
+            "\n\tSet products are not supported, i.e., each template needs an explicitly defined cascade level."
+            "\t\ne.g., for `templateNames = [haar, db2]`, use `cascadeLevels = [2, 2]`, not `[2]`.\n"
+        )
+
     intervalLengthBp = intervals[1] - intervals[0]
+
+    if minMatchLengthBP is not None and minMatchLengthBP < 1:
+        minMatchLengthBP = (
+            autoMinLengthIntervals(values) * int(intervalLengthBp)
+        )
+    elif minMatchLengthBP is None:
+        minMatchLengthBP = 250
+
+    logger.info(
+        f"\n\tUsing minMatchLengthBP: {minMatchLengthBP}"
+    )
+
     if not np.all(np.abs(np.diff(intervals)) == intervalLengthBp):
         raise ValueError("`intervals` must be evenly spaced.")
-    rng = np.random.default_rng(int(randSeed))
-    cascadeLevels = sorted(list(set(cascadeLevels)))
-    if weights is not None and len(weights) == len(values):
-        values = values * weights
+    
+    if weights is not None:
+        if len(weights) != len(values):
+            logger.warning(
+                f"`weights` length {len(weights)} does not match `values` length {len(values)}. Ignoring..."
+            )
+        else:
+            values = values * weights
+    
     asinhValues = np.asinh(values, dtype=np.float32)
     asinhNonZeroValues = asinhValues[asinhValues > 0]
     iters = max(int(iters), 1000)
@@ -383,147 +453,142 @@ def matchWavelet(
         high = np.quantile(vals, 0.999)
         return vals[(vals > low) & (vals < high)]
 
-    for cascadeLevel in cascadeLevels:
-        for templateName in templateNames:
-            if templateName not in pw.wavelist(kind="discrete"):
-                logger.warning(
-                    f"Skipping unknown wavelet template: {templateName}"
-                )
-                continue
-
-            wav = pw.Wavelet(str(templateName))
-            scalingFunc, waveletFunc, _ = wav.wavefun(
-                level=int(cascadeLevel)
-            )
-            template = np.array(
-                scalingFunc if useScalingFunction else waveletFunc,
-                dtype=np.float64,
+    for templateName, cascadeLevel in zip(
+        templateNames, cascadeLevels
+    ):
+        if templateName not in pw.wavelist(kind="discrete"):
+            logger.warning(
+                f"Skipping unknown wavelet template: {templateName}"
             )
-            template /= np.linalg.norm(template)
+            continue
 
-            logger.info(
-                f"\n\tMatching template: {templateName}"
-                f"\n\tcascade level: {cascadeLevel}"
-                f"\n\ttemplate length: {len(template)}"
-            )
+        wav = pw.Wavelet(str(templateName))
+        scalingFunc, waveletFunc, _ = wav.wavefun(
+            level=int(cascadeLevel)
+        )
+        template = np.array(
+            scalingFunc if useScalingFunction else waveletFunc,
+            dtype=np.float64,
+        )
+        template /= np.linalg.norm(template)
 
-            # efficient FFT-based cross-correlation
-            # (OA may be better for smaller templates, TODO add a check)
-            response = signal.fftconvolve(
-                values, template[::-1], mode="same"
-            )
-            thisMinMatchBp = minMatchLengthBP
-            if thisMinMatchBp is None or thisMinMatchBp < 1:
-                thisMinMatchBp = len(template) * intervalLengthBp
-            if thisMinMatchBp % intervalLengthBp != 0:
-                thisMinMatchBp += intervalLengthBp - (
-                    thisMinMatchBp % intervalLengthBp
-                )
-            relWindowBins = int(
-                ((thisMinMatchBp / intervalLengthBp) / 2) + 1
+        logger.info(
+            f"\n\tMatching template: {templateName}"
+            f"\n\tcascade level: {cascadeLevel}"
+            f"\n\ttemplate length: {len(template)}"
+        )
+
+        # efficient FFT-based cross-correlation
+        # (OA may be better for smaller templates, TODO add a check)
+        response = signal.fftconvolve(
+            values, template[::-1], mode="same"
+        )
+        thisMinMatchBp = minMatchLengthBP
+        if thisMinMatchBp is None or thisMinMatchBp < 1:
+            thisMinMatchBp = len(template) * intervalLengthBp
+        if thisMinMatchBp % intervalLengthBp != 0:
+            thisMinMatchBp += intervalLengthBp - (
+                thisMinMatchBp % intervalLengthBp
             )
-            relWindowBins = max(relWindowBins, 1)
-            asinhThreshold = parseMinSignalThreshold(
-                minSignalAtMaxima
+        relWindowBins = int(
+            ((thisMinMatchBp / intervalLengthBp) / 2) + 1
+        )
+        relWindowBins = max(relWindowBins, 1)
+        asinhThreshold = parseMinSignalThreshold(minSignalAtMaxima)
+        for nullMask, testMask, tag in [
+            (halfLeftMask, halfRightMask, "R"),
+            (halfRightMask, halfLeftMask, "L"),
+        ]:
+            blockMaxima = sampleBlockMaxima(
+                response,
+                nullMask,
+                relWindowBins,
+                nsamp=max(iters, 1000),
+                seed=rng.integers(1, 10_000),
             )
-            for nullMask, testMask, tag in [
-                (halfLeftMask, halfRightMask, "R"),
-                (halfRightMask, halfLeftMask, "L"),
-            ]:
+            if len(blockMaxima) < 25:
+                pooledMask = ~excludeMaskGlobal.astype(bool)
                 blockMaxima = sampleBlockMaxima(
                     response,
-                    nullMask,
+                    pooledMask,
                     relWindowBins,
                     nsamp=max(iters, 1000),
                     seed=rng.integers(1, 10_000),
                 )
-                if len(blockMaxima) < 25:
-                    pooledMask = ~excludeMaskGlobal.astype(bool)
-                    blockMaxima = sampleBlockMaxima(
-                        response,
-                        pooledMask,
-                        relWindowBins,
-                        nsamp=max(iters, 1000),
-                        seed=rng.integers(1, 10_000),
-                    )
-                ecdfSf = stats.ecdf(blockMaxima).sf
-                candidateIdx = relativeMaxima(response, relWindowBins)
-
-                candidateMask = (
-                    (candidateIdx >= relWindowBins)
-                    & (candidateIdx < len(response) - relWindowBins)
-                    & (testMask[candidateIdx])
-                    & (excludeMaskGlobal[candidateIdx] == 0)
-                    & (asinhValues[candidateIdx] > asinhThreshold)
-                )
+            ecdfSf = stats.ecdf(blockMaxima).sf
+            candidateIdx = relativeMaxima(response, relWindowBins)
+
+            candidateMask = (
+                (candidateIdx >= relWindowBins)
+                & (candidateIdx < len(response) - relWindowBins)
+                & (testMask[candidateIdx])
+                & (excludeMaskGlobal[candidateIdx] == 0)
+                & (asinhValues[candidateIdx] > asinhThreshold)
+            )
 
-                candidateIdx = candidateIdx[candidateMask]
-                if len(candidateIdx) == 0:
-                    continue
-                if (
-                    maxNumMatches is not None
-                    and len(candidateIdx) > maxNumMatches
-                ):
-                    candidateIdx = candidateIdx[
-                        np.argsort(asinhValues[candidateIdx])[
-                            -maxNumMatches:
-                        ]
+            candidateIdx = candidateIdx[candidateMask]
+            if len(candidateIdx) == 0:
+                continue
+            if (
+                maxNumMatches is not None
+                and len(candidateIdx) > maxNumMatches
+            ):
+                candidateIdx = candidateIdx[
+                    np.argsort(asinhValues[candidateIdx])[
+                        -maxNumMatches:
                     ]
-                pEmp = np.clip(
-                    ecdfSf.evaluate(response[candidateIdx]),
-                    1.0e-10,
-                    1.0,
-                )
-                startsIdx = np.maximum(
-                    candidateIdx - relWindowBins, 0
+                ]
+            pEmp = np.clip(
+                ecdfSf.evaluate(response[candidateIdx]),
+                1.0e-10,
+                1.0,
+            )
+            startsIdx = np.maximum(candidateIdx - relWindowBins, 0)
+            endsIdx = np.minimum(
+                len(values) - 1, candidateIdx + relWindowBins
+            )
+            pointSourcesIdx = []
+            for s, e in zip(startsIdx, endsIdx):
+                pointSourcesIdx.append(
+                    np.argmax(values[s : e + 1]) + s
                 )
-                endsIdx = np.minimum(
-                    len(values) - 1, candidateIdx + relWindowBins
+            pointSourcesIdx = np.array(pointSourcesIdx)
+            starts = intervals[startsIdx]
+            ends = intervals[endsIdx]
+            pointSourcesAbs = (intervals[pointSourcesIdx]) + max(
+                1, intervalLengthBp // 2
+            )
+            if recenterAtPointSource:
+                starts = pointSourcesAbs - (
+                    relWindowBins * intervalLengthBp
                 )
-                pointSourcesIdx = []
-                for s, e in zip(startsIdx, endsIdx):
-                    pointSourcesIdx.append(
-                        np.argmax(values[s : e + 1]) + s
-                    )
-                pointSourcesIdx = np.array(pointSourcesIdx)
-                starts = intervals[startsIdx]
-                ends = intervals[endsIdx]
-                pointSourcesAbs = (intervals[pointSourcesIdx]) + max(
-                    1, intervalLengthBp // 2
+                ends = pointSourcesAbs + (
+                    relWindowBins * intervalLengthBp
                 )
-                if recenterAtPointSource:
-                    starts = pointSourcesAbs - (
-                        relWindowBins * intervalLengthBp
-                    )
-                    ends = pointSourcesAbs + (
-                        relWindowBins * intervalLengthBp
-                    )
-                pointSourcesRel = (
-                    intervals[pointSourcesIdx] - starts
-                ) + max(1, intervalLengthBp // 2)
-                sqScores = (1 + response[candidateIdx]) ** 2
-                minR, maxR = (
-                    float(np.min(sqScores)),
-                    float(np.max(sqScores)),
+            pointSourcesRel = (
+                intervals[pointSourcesIdx] - starts
+            ) + max(1, intervalLengthBp // 2)
+            sqScores = (1 + response[candidateIdx]) ** 2
+            minR, maxR = (
+                float(np.min(sqScores)),
+                float(np.max(sqScores)),
+            )
+            rangeR = max(maxR - minR, 1.0)
+            scores = (250 + 750 * (sqScores - minR) / rangeR).astype(int)
+            for i, idxVal in enumerate(candidateIdx):
+                allRows.append(
+                    {
+                        "chromosome": chromosome,
+                        "start": int(starts[i]),
+                        "end": int(ends[i]),
+                        "name": f"{templateName}_{cascadeLevel}_{idxVal}_{tag}",
+                        "score": int(scores[i]),
+                        "strand": ".",
+                        "signal": float(response[idxVal]),
+                        "p_raw": float(pEmp[i]),
+                        "pointSource": int(pointSourcesRel[i]),
+                    }
                 )
-                rangeR = max(maxR - minR, 1.0)
-                scores = (
-                    250 + 750 * (sqScores - minR) / rangeR
-                ).astype(int)
-                for i, idxVal in enumerate(candidateIdx):
-                    allRows.append(
-                        {
-                            "chromosome": chromosome,
-                            "start": int(starts[i]),
-                            "end": int(ends[i]),
-                            "name": f"{templateName}_{cascadeLevel}_{idxVal}_{tag}",
-                            "score": int(scores[i]),
-                            "strand": ".",
-                            "signal": float(response[idxVal]),
-                            "p_raw": float(pEmp[i]),
-                            "pointSource": int(pointSourcesRel[i]),
-                        }
-                    )
 
     if not allRows:
         logger.warning(

{consenrich-0.7.1b1.dist-info → consenrich-0.7.1b2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: consenrich
-Version: 0.7.1b1
+Version: 0.7.1b2
 Summary: Genome-wide estimation of signals hidden in noisy multi-sample HTS datasets
 Author-email: "Nolan H. Hamilton" <nolan.hamilton@unc.edu>
 Requires-Python: >=3.11