@platforma-open/milaboratories.mixcr-clonotyping-2.workflow 2.18.2 → 2.19.0

package/src/calculate-export-specs.lib.tengo

@@ -170,7 +170,7 @@ calculateExportSpecs := func(presetSpecForBack, blockId) {
 
 	columnsSpecPerSample := []
 	columnsSpecPerSampleSc := undefined
-	columnsSpecPerClonotype := []
+	columnsSpecPerClonotypeNoAggregates := []
 	columnsSpecPerClonotypeSc := undefined
 
 	// array of array of arg groups
@@ -209,7 +209,8 @@ calculateExportSpecs := func(presetSpecForBack, blockId) {
 				"pl7.app/abundance/unit": "reads",
 				"pl7.app/abundance/normalized": "true",
 				"pl7.app/abundance/isPrimary": !hasUmi ? "true" : undefined,
-				"pl7.app/label": "Fraction of reads"
+				"pl7.app/label": "Fraction of reads",
+				"pl7.app/format": ".2p"
 			})
 		}
 	} ]
@@ -220,8 +221,10 @@ calculateExportSpecs := func(presetSpecForBack, blockId) {
 
 	mainAbundanceColumnUnnormalized := "readCount"
 	mainAbundanceColumnNormalized := "readFraction"
+	mainAbundanceColumnUnnormalizedArgs := [ [ "-readCount" ] ]
+	mainAbundanceColumnNormalizedArgs := [ [ "-readFraction" ] ]
 
-	mainAbundanceColumnAggregates := [{
+	columnsSpecPerClonotypeAggregates := [{
 		column: mainAbundanceColumnUnnormalized + "Sum",
 		id: "read-count-total",
 		allowNA: false,
@@ -249,7 +252,8 @@ calculateExportSpecs := func(presetSpecForBack, blockId) {
 				"pl7.app/isAbundance": "true",
 				"pl7.app/abundance/unit": "reads",
 				"pl7.app/abundance/normalized": "true",
-				"pl7.app/label": "Mean Fraction of Reads"
+				"pl7.app/label": "Mean Fraction of Reads",
+				"pl7.app/format": ".2p"
 			})
 		}
 	}]
@@ -286,7 +290,8 @@ calculateExportSpecs := func(presetSpecForBack, blockId) {
 						"pl7.app/abundance/unit": "molecules",
 						"pl7.app/abundance/normalized": "true",
 						"pl7.app/abundance/isPrimary": "true",
-						"pl7.app/label": "Fraction of UMIs"
+						"pl7.app/label": "Fraction of UMIs",
+						"pl7.app/format": ".2p"
 					})
 				}
 			} ]
@@ -294,9 +299,13 @@ calculateExportSpecs := func(presetSpecForBack, blockId) {
 			[ "-uniqueTagCount", "Molecule" ],
 			[ "-uniqueTagFraction", "Molecule" ]
 		]
+
 		mainAbundanceColumnNormalized = "uniqueMoleculeFraction"
 		mainAbundanceColumnUnnormalized = "uniqueMoleculeCount"
-		mainAbundanceColumnAggregates = [ {
+		mainAbundanceColumnNormalizedArgs = [ [ "-uniqueTagFraction", "Molecule" ] ]
+		mainAbundanceColumnUnnormalizedArgs = [ [ "-uniqueTagCount", "Molecule" ] ]
+
+		columnsSpecPerClonotypeAggregates = [ {
 			column: mainAbundanceColumnUnnormalized + "Sum",
 			id: "umi-count-total",
 			allowNA: false,
@@ -324,7 +333,8 @@ calculateExportSpecs := func(presetSpecForBack, blockId) {
 					"pl7.app/isAbundance": "true",
 					"pl7.app/abundance/unit": "molecules",
 					"pl7.app/abundance/normalized": "true",
-					"pl7.app/label": "Mean Fraction of UMIs"
+					"pl7.app/label": "Mean Fraction of UMIs",
+					"pl7.app/format": ".2p"
 				})
 			}
 		} ]
@@ -347,6 +357,20 @@ calculateExportSpecs := func(presetSpecForBack, blockId) {
 		}
 	}
 
+	columnsSpecPerClonotypeAggregates += [ sampleCountColumn ]
+
+	clonotypeLabelColumn := {
+		column: "clonotypeLabel",
+		id: "clonotype-label",
+		spec: {
+			name: "pl7.app/label",
+			valueType: "String",
+			annotations: a(100000, false, {
+				"pl7.app/label": "Clone label"
+			})
+		}
+	}
+
 	if isSingleCell {
 		// copying reads and umi counts and fraction removing isPrimary and isAnchor
 		columnsSpecPerSample = addSpec(columnsSpecPerSample, {
@@ -388,14 +412,12 @@ calculateExportSpecs := func(presetSpecForBack, blockId) {
 					"pl7.app/abundance/unit": "cells",
 					"pl7.app/abundance/normalized": "true",
 					"pl7.app/abundance/isPrimary": "true",
-					"pl7.app/label": "Fraction of Cells"
+					"pl7.app/label": "Fraction of Cells",
+					"pl7.app/format": ".2p"
 				})
 			}
 		} ]
-		columnsSpecPerClonotypeSc = [ sampleCountColumn ]
-	} else {
-		columnsSpecPerClonotype += [ sampleCountColumn ]
-		columnsSpecPerClonotype += mainAbundanceColumnAggregates
+		columnsSpecPerClonotypeSc = [ sampleCountColumn, clonotypeLabelColumn ]
 	}
 
 	orderP := 80000
@@ -423,7 +445,7 @@ calculateExportSpecs := func(presetSpecForBack, blockId) {
 				alphabetShortMixcr := isAminoAcid ? "aa" : "n"
 				columnName := alphabetShortMixcr + "Seq" + imputedU + featureInFrameU
 				visibility := featureU == "CDR3" && (!isSingleCell || isAminoAcid) // isSingleCell ? (featureU == "CDR3") && isAminoAcid : (featureU == "CDR3") || (featureU == assemblingFeature)
-				columnsSpecPerClonotype += [ {
+				columnsSpecPerClonotypeNoAggregates += [ {
 						column: columnName,
 						id: alphabetShortMixcr + "-seq-" + featureInFrameL + (isImputed ? "-imputed" : ""),
 						naRegex: "region_not_covered",
@@ -438,6 +460,7 @@ calculateExportSpecs := func(presetSpecForBack, blockId) {
 								"pl7.app/vdj/isAssemblingFeature": featureU == anchorFeature ? "true" : "false",
 								"pl7.app/vdj/isMainSequence": featureU == anchorFeature ? "true" : "false",
 								"pl7.app/vdj/imputed": string(isImputed),
+								"pl7.app/table/fontFamily": "monospace",
 								"pl7.app/label": featureInFrameU + " " + alphabetShort
 							})
 						}
@@ -449,7 +472,7 @@ calculateExportSpecs := func(presetSpecForBack, blockId) {
 				if !isImputed && featureU == assemblingFeature {
 					for annotationType in annotationTypes {
 						columnName := alphabetShortMixcr + "AnnotationOf" + annotationType + "For" + featureInFrameU
-						columnsSpecPerClonotype += [ {
+						columnsSpecPerClonotypeNoAggregates += [ {
 							column: columnName,
 							id: alphabetShortMixcr + "-annotation-" + annotationType + "-" + featureInFrameL,
 							naRegex: "region_not_covered",
@@ -475,7 +498,7 @@ calculateExportSpecs := func(presetSpecForBack, blockId) {
 
 				// For now calculate length only for CDR3 to keep the number of columns manageable
 				if featureU == "CDR3" {
-					columnsSpecPerClonotype += [ {
+					columnsSpecPerClonotypeNoAggregates += [ {
 						column: alphabetShortMixcr + "Length" + featureU,
 						id: alphabetShortMixcr + "-length-" + featureL,
 						naRegex: "region_not_covered",
@@ -495,24 +518,24 @@ calculateExportSpecs := func(presetSpecForBack, blockId) {
 				}
 
 				// label column
-				if isAminoAcid && !isSingleCell && featureU == "CDR3" {
-					columnsSpecPerClonotype += [ {
-						column: columnName,
-						id: "clonotype-label",
-						preProcess: [{
-							type: "regexpReplace",
-							pattern: "^region_not_covered$",
-							replacement: "Unlabelled"
-						}],
-						spec: {
-							name: "pl7.app/label",
-							valueType: "String",
-							annotations: a(100000, false, {
-								"pl7.app/label": "Clone label"
-							})
-						}
-					} ]
-				}
+				// if isAminoAcid && !isSingleCell && featureU == "CDR3" {
+				// 	columnsSpecPerClonotype += [ {
+				// 		column: columnName,
+				// 		id: "clonotype-label",
+				// 		preProcess: [{
+				// 			type: "regexpReplace",
+				// 			pattern: "^region_not_covered$",
+				// 			replacement: "Unlabelled"
+				// 		}],
+				// 		spec: {
+				// 			name: "pl7.app/label",
+				// 			valueType: "String",
+				// 			annotations: a(100000, false, {
+				// 				"pl7.app/label": "Clone label"
+				// 			})
+				// 		}
+				// 	} ]
+				// }
 			}
 		}
 	}
@@ -537,7 +560,7 @@ calculateExportSpecs := func(presetSpecForBack, blockId) {
 	for vdjcU in ["V", "D", "J", "C"] {
 		vdjcL := text.to_lower(vdjcU)
 		for variant in geneHitColumnVariants {
-			columnsSpecPerClonotype += [ {
+			columnsSpecPerClonotypeNoAggregates += [ {
 					column: "best" + vdjcU + variant.columnNameSuffix,
 					id: "best-" + vdjcL + variant.idSuffix,
 					naRegex: "",
@@ -596,7 +619,7 @@ calculateExportSpecs := func(presetSpecForBack, blockId) {
 			}
 
 			for variant in mutationColumnVariants {
-				columnsSpecPerClonotype += [ {
+				columnsSpecPerClonotypeNoAggregates += [ {
 						column: alphabetShortMixcr + variant.name + coreFeature,
 						id: alphabetShortMixcr + variant.idPart + geneL,
 						allowNA: true,
@@ -644,10 +667,10 @@ calculateExportSpecs := func(presetSpecForBack, blockId) {
 		// 	visibility: false
 		// }
 	]
-	mainProductiveColumn := flagColumnVariants[0].columnPrefix + productiveFeature
-	mainProductiveArgs := [ flagColumnVariants[0].arg, productiveFeature ]
+	mainIsProductiveColumn := flagColumnVariants[0].columnPrefix + productiveFeature
+	mainIsProductiveArgs := [ [ flagColumnVariants[0].arg, productiveFeature ] ]
 	for variant in flagColumnVariants {
-		columnsSpecPerClonotype += [ {
+		columnsSpecPerClonotypeNoAggregates += [ {
 				column: variant.columnPrefix + productiveFeature,
 				id: variant.id,
 				allowNA: false,
@@ -692,7 +715,7 @@ calculateExportSpecs := func(presetSpecForBack, blockId) {
 
 	// Isotype and chain
 
-	columnsSpecPerClonotype += [ {
+	columnsSpecPerClonotypeNoAggregates += [ {
 			column: "isotypePrimary",
 			id: "isotype",
 			naRegex: "",
@@ -724,9 +747,11 @@ calculateExportSpecs := func(presetSpecForBack, blockId) {
 		[ "-topChains" ]
 	]
 
+	columnsSpecPerClonotypeNoAggregates += [ clonotypeLabelColumn ]
+
 	// All columns are added
 
-	columnsSpec := columnsSpecPerSample + columnsSpecPerClonotype
+	columnsSpec := columnsSpecPerSample + columnsSpecPerClonotypeNoAggregates + columnsSpecPerClonotypeAggregates
 
 	// Creating a column map for fast search
 	columnsByName := {}
@@ -767,8 +792,9 @@ calculateExportSpecs := func(presetSpecForBack, blockId) {
 					"pl7.app/vdj/clonotypingRunId": blockId
 				},
 				annotations: {
-					"pl7.app/label": "Clonotype key",
-					"pl7.app/table/visibility": "optional",
+					"pl7.app/label": "Clonotype ID",
+					"pl7.app/table/fontFamily": "monospace",
+					"pl7.app/table/visibility": "default",
 					"pl7.app/table/orderPriority": "110000",
 					"pl7.app/segmentedBy": string(json.encode(["pl7.app/vdj/clonotypingRunId"]))
 				}
@@ -791,8 +817,9 @@ calculateExportSpecs := func(presetSpecForBack, blockId) {
 						"pl7.app/vdj/clonotypingRunId": blockId
 					},
 					annotations: {
-						"pl7.app/label": "Clone label",
-						"pl7.app/table/visibility": "optional",
+						"pl7.app/label": "Clonotype ID",
+						"pl7.app/table/fontFamily": "monospace",
+						"pl7.app/table/visibility": "default",
 						"pl7.app/table/orderPriority": "110000",
 						"pl7.app/segmentedBy": string(json.encode(["pl7.app/vdj/clonotypingRunId"]))
 					}
@@ -825,16 +852,19 @@ calculateExportSpecs := func(presetSpecForBack, blockId) {
 
 		columnsSpecPerSample: columnsSpecPerSample,
 		columnsSpecPerSampleSc: columnsSpecPerSampleSc,
-		columnsSpecPerClonotype: columnsSpecPerClonotype,
+		columnsSpecPerClonotypeNoAggregates: columnsSpecPerClonotypeNoAggregates,
+		columnsSpecPerClonotypeAggregates: columnsSpecPerClonotypeAggregates,
 		columnsSpecPerClonotypeSc: columnsSpecPerClonotypeSc,
 
 		columnsSpec: columnsSpec,
 
 		mainAbundanceColumnNormalized: mainAbundanceColumnNormalized,
+		mainAbundanceColumnNormalizedArgs: mainAbundanceColumnNormalizedArgs,
 		mainAbundanceColumnUnnormalized: mainAbundanceColumnUnnormalized,
+		mainAbundanceColumnUnnormalizedArgs: mainAbundanceColumnUnnormalizedArgs,
 
-		mainProductiveColumn: mainProductiveColumn,
-		mainProductiveArgs: mainProductiveArgs,
+		mainIsProductiveColumn: mainIsProductiveColumn,
+		mainIsProductiveArgs: mainIsProductiveArgs,
 
 		exportArgs: exportArgs
 	}

package/src/clonotype-label.lib.tengo

@@ -0,0 +1,121 @@
+generateClonotypeLabelSteps := func(clonotypeKeyCol, clonotypeLabelCol, targetTable) {
+    prefixTempCol := clonotypeLabelCol + "_prefix_temp"
+    rankTempCol := clonotypeLabelCol + "_rank_temp"
+
+    steps := []
+
+    // Add prefix_temp column (digits removed, first 5 chars, uppercased)
+    steps = append(steps, {
+        type: "add_columns",
+        table: targetTable,
+        columns: [{
+            name: prefixTempCol,
+            expression: {
+                type: "to_upper",
+                value: {
+                    type: "substring",
+                    value: {
+                        type: "str_replace",
+                        value: { type: "col", name: clonotypeKeyCol },
+                        pattern: "\\d", // Regex for digits
+                        replacement: "",
+                        replaceAll: true
+                    },
+                    start: 0,
+                    length: 5
+                }
+            }
+        }]
+    })
+
+    // Add rank_temp column - rank of the clonotype in the prefixTempCol,
+	// used to diversify repeated clonotype labels (due to the birthday paradox)
+    steps = append(steps, {
+        type: "add_columns",
+        table: targetTable,
+        columns: [{
+            name: rankTempCol,
+            expression: {
+                type: "rank",
+                partitionBy: [{ type: "col", name: prefixTempCol }],
+                orderBy: [{ type: "col", name: clonotypeKeyCol }]
+            }
+        }]
+    })
+
+    // Add final clonotypeLabelCol column (C-XXXXX or C-XXXXX-RANK)
+    steps = append(steps, {
+        type: "add_columns",
+        table: targetTable,
+        columns: [{
+            name: clonotypeLabelCol,
+            expression: {
+                type: "when_then_otherwise",
+                conditions: [
+                    {
+                        when: {
+                            type: "gt",
+                            lhs: { type: "col", name: rankTempCol },
+                            rhs: { type: "const", value: 1 }
+                        },
+                        then: {
+                            type: "str_join",
+                            operands: [
+                                { type: "const", value: "C" },
+                                { type: "col", name: prefixTempCol },
+                                { type: "col", name: rankTempCol }
+                            ],
+                            delimiter: "-"
+                        }
+                    }
+                ],
+                otherwise: {
+                    type: "str_join",
+                    operands: [
+                        { type: "const", value: "C" },
+                        { type: "col", name: prefixTempCol }
+                    ],
+                    delimiter: "-"
+                }
+            }
+        }]
+    })
+
+    return steps
+}
+
+addClonotypeLabelColumnsPt := func(df, clonotypeKeyCol, clonotypeLabelCol, pt) {
+    prefixTempCol := clonotypeLabelCol + "_prefix_temp"
+    rankTempCol := clonotypeLabelCol + "_rank_temp"
+
+    // Add prefix_temp column (digits removed, first 5 chars, uppercased)
+    df = df.withColumns(
+        pt.col(clonotypeKeyCol).
+            strReplace("\\d", "", { replaceAll: true }).
+            strSlice(0, 5).               // Take first 5 characters
+            strToUpper().                 // Convert to uppercase
+            alias(prefixTempCol)
+    )
+
+    // Add rank_temp column - rank of the clonotypeKeyCol within each prefixTempCol group
+    df = df.withColumns(
+        pt.rank(pt.col(clonotypeKeyCol)).  // Rank based on clonotypeKeyCol (default ascending)
+            over(pt.col(prefixTempCol)).   // Partition by prefixTempCol
+            alias(rankTempCol)
+    )
+
+    // Add final clonotypeLabelCol column (C-XXXXX or C-XXXXX-RANK)
+    df = df.withColumns(
+        pt.when(pt.col(rankTempCol).gt(pt.lit(1))).
+            then(pt.concatStr([pt.lit("C"), pt.col(prefixTempCol), pt.col(rankTempCol).cast("String")], { delimiter: "-" })).
+            otherwise(pt.concatStr([pt.lit("C"), pt.col(prefixTempCol)], { delimiter: "-" })).
+            alias(clonotypeLabelCol)
+    )
+
+    return df.withoutColumns(prefixTempCol, rankTempCol)
+}
+
+export {
+	generateClonotypeLabelSteps: generateClonotypeLabelSteps,
+    addClonotypeLabelColumnsPt: addClonotypeLabelColumnsPt
+}

package/src/mixcr-export.tpl.tengo

@@ -2,16 +2,17 @@ ll := import("@platforma-sdk/workflow-tengo:ll")
 self := import("@platforma-sdk/workflow-tengo:tpl.light")
 pConstants := import("@platforma-sdk/workflow-tengo:pframes.constants")
 smart := import("@platforma-sdk/workflow-tengo:smart")
+slices := import("@platforma-sdk/workflow-tengo:slices")
 assets := import("@platforma-sdk/workflow-tengo:assets")
 exec := import("@platforma-sdk/workflow-tengo:exec")
+pt := import("@platforma-sdk/workflow-tengo:pt")
 
 json := import("json")
 
 self.defineOutputs("tsv", "tsvForSingleCell")
 
 mixcrSw := assets.importSoftware("@platforma-open/milaboratories.software-mixcr:low-memory")
-ptransformSw := assets.importSoftware("@platforma-open/milaboratories.software-ptransform:main")
-hashColumnSw := assets.importSoftware("@platforma-open/milaboratories.mixcr-clonotyping-2.hash-column:main")
+ptablerSw := assets.importSoftware("@platforma-open/milaboratories.software-ptabler:main")
 
 self.body(func(inputs) {
 	clnsFile := inputs[pConstants.VALUE_FIELD_NAME]
@@ -24,8 +25,19 @@ self.body(func(inputs) {
 
 	clonotypeKeyColumns := params.clonotypeKeyColumns
 	clonotypeKeyArgs := params.clonotypeKeyArgs
+
 	cellTagColumns := params.cellTagColumns
 
+	mainAbundanceColumnUnnormalizedArgs := params.mainAbundanceColumnUnnormalizedArgs
+	mainIsProductiveArgs := params.mainIsProductiveArgs
+
+	hashKeyDerivationExpressionPt := func(sourceColumns) {
+		return pt.concatStr(
+			slices.map(sourceColumns, func(colName) { return pt.col(colName) }),
+			{delimiter: "#"}
+		).hash("sha256", "base64_alphanumeric", 120)
+	}
+
 	// Exporting clones from clns file
 
 	createExport := func(additionalAction) {
@@ -76,124 +88,57 @@ self.body(func(inputs) {
 	}
 
 	if is_undefined(clonotypeKeyColumns) {
-		result.tsv = unprocessedTsv
-
-	} else if is_undefined(cellTagColumns) {
-		hashCmdBuilder := exec.builder().
-			printErrStreamToStdout().
-			software(hashColumnSw).
-			arg("--input-table").arg("input.tsv").
-			addFile("input.tsv", unprocessedTsv).
-			arg("--output-table").arg("output.tsv").
-			arg("--calculate")
-
-		for col in clonotypeKeyColumns {
-			hashCmdBuilder.arg(col)
-		}
-
-		hashCmdBuilder.arg("clonotypeKey")
-
-		hashCmd := hashCmdBuilder.
-			saveFile("output.tsv").
-			run()
-
-		processedTsv := hashCmd.getFile("output.tsv")
-
-		result.tsv = processedTsv
-
-	} else {
-		pWorkflow := {
-			steps: [ {
-				type: "combine_columns_as_json",
-				src: clonotypeKeyColumns,
-				dst: "clonotypeKey"
-			} ]
-		}
+		ll.panic("clonotypeKeyColumns is undefined")
+	}
 
-		aggregateCmd := exec.builder().
-			printErrStreamToStdout().
-			software(ptransformSw).
-			arg("--workflow").arg("wf.json").
-			writeFile("wf.json", json.encode(pWorkflow)).
-			arg("input.tsv").addFile("input.tsv", unprocessedTsv).
-			arg("output.tsv").saveFile("output.tsv").
-			run()
+	// PTabler processing for main TSV output
+	wfMain := pt.workflow()
+	frameInputMap := {
+		file: unprocessedTsv,
+		xsvType: "tsv",
+		schema: [ { column: "readCount", type: "Double" } ]
+	}
+	dfMain := wfMain.frame(frameInputMap, { inferSchema: false, id: "input_table" })
 
-		processedTsv := aggregateCmd.getFile("output.tsv")
+	dfMain.addColumns(
+		pt.col("readCount").round().cast("Long").alias("readCount")
+	)
+	dfMain.addColumns(
+		hashKeyDerivationExpressionPt(clonotypeKeyColumns).alias("clonotypeKey")
+	)
 
-		result.tsv = processedTsv
-	}
+	dfMain.save("output.tsv")
+	ptablerResultMain := wfMain.run()
+	processedTsv := ptablerResultMain.getFile("output.tsv")
+	result.tsv = processedTsv
 
 	if !is_undefined(cellTagColumns) {
 		mixcrForSingleCell := createExport(func(mixcrCmdBuilder) {
 			mixcrCmdBuilder.
 				arg("--split-by-tags").arg("Cell").
-				arg("-tags").arg("Cell").
-				arg("-readCount").
-				arg("-isProductive").arg("CDR3")
+				arg("-tags").arg("Cell")
 
-			for argGrp in clonotypeKeyArgs {
+			for argGrp in (clonotypeKeyArgs + mainIsProductiveArgs + mainAbundanceColumnUnnormalizedArgs) {
 				for arg in argGrp {
 					mixcrCmdBuilder.arg(arg)
 				}
 			}
 		})
 
-		if is_undefined(clonotypeKeyColumns) {
-			ll.panic("clonotypeKeyColumns is undefined")
-		}
-
 		unprocessedTsvForSingleCell := mixcrForSingleCell.getFile("clones.tsv")
 
-		pWorkflow := {
-			steps: [ {
-				type: "combine_columns_as_json",
-				src: clonotypeKeyColumns,
-				dst: "clonotypeKey"
-			}, {
-				type: "combine_columns_as_json",
-				src: cellTagColumns,
-				dst: "cellTag"
-			} ]
-		}
-
-		aggregateCmd := exec.builder().
-			printErrStreamToStdout().
-			software(ptransformSw).
-			arg("--workflow").arg("wf.json").
-			writeFile("wf.json", json.encode(pWorkflow)).
-			arg("input.tsv").addFile("input.tsv", unprocessedTsvForSingleCell).
-			arg("output.tsv").saveFile("output.tsv").
-			run()
-
-		result.tsvForSingleCell = aggregateCmd.getFile("output.tsv")
-
-		// uncomment this to use hashes
-
-		// hashCmdBuilderSingleCell := exec.builder().
-		// 	printErrStreamToStdout().
-		// 	software(hashColumnSw).
-		// 	arg("--input-table").arg("input.tsv").
-		// 	addFile("input.tsv", unprocessedTsvForSingleCell).
-		// 	arg("--output-table").arg("output.tsv")
-
-		// hashCmdBuilderSingleCell.arg("--calculate")
-		// for col in clonotypeKeyColumns {
-		// 	hashCmdBuilderSingleCell.arg(col)
-		// }
-		// hashCmdBuilderSingleCell.arg("clonotypeKey")
-
-		// hashCmdBuilderSingleCell.arg("--calculate")
-		// for col in cellTagColumns {
-		// 	hashCmdBuilderSingleCell.arg(col)
-		// }
-		// hashCmdBuilderSingleCell.arg("cellTag")
+		// PTabler processing for single-cell TSV output
+		wfSingleCell := pt.workflow()
+		dfSingleCell := wfSingleCell.frame(unprocessedTsvForSingleCell, { xsvType: "tsv", inferSchema: false })
 
-		// hashCmdSingleCell := hashCmdBuilderSingleCell.
-		// 	saveFile("output.tsv").
-		// 	run()
+		dfSingleCell.addColumns(
+			hashKeyDerivationExpressionPt(clonotypeKeyColumns).alias("clonotypeKey"),
+			hashKeyDerivationExpressionPt(cellTagColumns).alias("cellKey")
+		)
 
-		// result.tsvForSingleCell = hashCmdSingleCell.getFile("output.tsv")
+		dfSingleCell.save("output.tsv")
+		ptablerResultSingleCell := wfSingleCell.run()
+		result.tsvForSingleCell = ptablerResultSingleCell.getFile("output.tsv")
 	}
 
 	return result