@platforma-open/milaboratories.mixcr-clonotyping-2.workflow 2.18.3 → 2.19.1

package/.turbo/turbo-build.log

@@ -1,12 +1,13 @@
  WARN  Issue while reading "/home/runner/work/mixcr-clonotyping/mixcr-clonotyping/.npmrc". Failed to replace env in config: ${NPMJS_TOKEN}
 
-> @platforma-open/milaboratories.mixcr-clonotyping-2.workflow@2.18.3 build /home/runner/work/mixcr-clonotyping/mixcr-clonotyping/workflow
+> @platforma-open/milaboratories.mixcr-clonotyping-2.workflow@2.19.1 build /home/runner/work/mixcr-clonotyping/mixcr-clonotyping/workflow
 > rm -rf dist && pl-tengo check && pl-tengo build
 
   info: Skipping unknown file type: test/columns.test.ts
 Processing "src/aggregate-by-clonotype-key.tpl.tengo"...
 Processing "src/calculate-export-specs.lib.tengo"...
 Processing "src/calculate-preset-info.tpl.tengo"...
+Processing "src/clonotype-label.lib.tengo"...
 Processing "src/list-presets.tpl.tengo"...
 Processing "src/main.tpl.tengo"...
 Processing "src/mixcr-analyze.tpl.tengo"...
@@ -20,6 +21,7 @@ No syntax errors found.
   info: Skipping unknown file type: test/columns.test.ts
   info: Compiling 'dist'...
   info:   - writing /home/runner/work/mixcr-clonotyping/mixcr-clonotyping/workflow/dist/tengo/lib/calculate-export-specs.lib.tengo
+  info:   - writing /home/runner/work/mixcr-clonotyping/mixcr-clonotyping/workflow/dist/tengo/lib/clonotype-label.lib.tengo
   info:   - writing /home/runner/work/mixcr-clonotyping/mixcr-clonotyping/workflow/dist/tengo/tpl/aggregate-by-clonotype-key.plj.gz
   info:   - writing /home/runner/work/mixcr-clonotyping/mixcr-clonotyping/workflow/dist/tengo/tpl/calculate-preset-info.plj.gz
   info:   - writing /home/runner/work/mixcr-clonotyping/mixcr-clonotyping/workflow/dist/tengo/tpl/list-presets.plj.gz

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @platforma-open/milaboratories.mixcr-clonotyping.workflow
 
+## 2.19.1
+
+### Patch Changes
+
+- fdf3e57: SDK Upgrade to fixed redundant partitioning of exports
+
+## 2.19.0
+
+### Minor Changes
+
+- 4f09d25: - All table transformations migrated from ptransform and custop python scripts to universal PT API
+  - Enhance export specifications by adding format property for fraction and sequence columns
+
 ## 2.18.3
 
 ### Patch Changes

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

@@ -170,7 +170,7 @@ calculateExportSpecs := func(presetSpecForBack, blockId) {
 
 	columnsSpecPerSample := []
 	columnsSpecPerSampleSc := undefined
-	columnsSpecPerClonotype := []
+	columnsSpecPerClonotypeNoAggregates := []
 	columnsSpecPerClonotypeSc := undefined
 
 
@@ -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 {
 
 		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) {
 
 
 				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) {
 				}
 
 
-				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) {
 
 
 	]
-	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) {
 
 
 
-	columnsSpecPerClonotype += [ {
+	columnsSpecPerClonotypeNoAggregates += [ {
 			column: "isotypePrimary",
 			id: "isotype",
 			naRegex: "",
@@ -724,9 +747,11 @@ calculateExportSpecs := func(presetSpecForBack, blockId) {
 		[ "-topChains" ]
 	]
 
+	columnsSpecPerClonotypeNoAggregates += [ clonotypeLabelColumn ]
+
 
 
-	columnsSpec := columnsSpecPerSample + columnsSpecPerClonotype
+	columnsSpec := columnsSpecPerSample + columnsSpecPerClonotypeNoAggregates + columnsSpecPerClonotypeAggregates
 
 
 	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/dist/tengo/lib/clonotype-label.lib.tengo

@@ -0,0 +1,121 @@
+generateClonotypeLabelSteps := func(clonotypeKeyCol, clonotypeLabelCol, targetTable) {
+    prefixTempCol := clonotypeLabelCol + "_prefix_temp"
+    rankTempCol := clonotypeLabelCol + "_rank_temp"
+
+    steps := []
+
+
+    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
+                }
+            }
+        }]
+    })
+
+
+
+    steps = append(steps, {
+        type: "add_columns",
+        table: targetTable,
+        columns: [{
+            name: rankTempCol,
+            expression: {
+                type: "rank",
+                partitionBy: [{ type: "col", name: prefixTempCol }],
+                orderBy: [{ type: "col", name: clonotypeKeyCol }]
+            }
+        }]
+    })
+
+
+    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"
+
+
+    df = df.withColumns(
+        pt.col(clonotypeKeyCol).
+            strReplace("\\d", "", { replaceAll: true }).
+            strSlice(0, 5).               // Take first 5 characters
+            strToUpper().                 // Convert to uppercase
+            alias(prefixTempCol)
+    )
+
+
+    df = df.withColumns(
+        pt.rank(pt.col(clonotypeKeyCol)).  // Rank based on clonotypeKeyCol (default ascending)
+            over(pt.col(prefixTempCol)).   // Partition by prefixTempCol
+            alias(rankTempCol)
+    )
+
+
+    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/package.json

@@ -1,18 +1,15 @@
 {
   "name": "@platforma-open/milaboratories.mixcr-clonotyping-2.workflow",
-  "version": "2.18.3",
+  "version": "2.19.1",
   "description": "Tengo-based template",
   "dependencies": {
-    "@platforma-sdk/workflow-tengo": "^4.4.5",
-    "@platforma-open/milaboratories.mixcr-clonotyping-2.single-cell-scripts": "1.1.3",
-    "@platforma-open/milaboratories.mixcr-clonotyping-2.hash-column": "1.1.1"
+    "@platforma-sdk/workflow-tengo": "^4.6.3",
+    "@platforma-open/milaboratories.software-mixcr": "4.7.0-169-develop"
   },
   "devDependencies": {
-    "@platforma-sdk/tengo-builder": "^2.1.3",
-    "@platforma-open/milaboratories.software-mixcr": "4.7.0-169-develop",
-    "@platforma-open/milaboratories.software-ptransform": "^1.4.3",
-    "@platforma-sdk/test": "^1.30.24",
-    "vitest": "~2.1.8",
+    "@platforma-sdk/tengo-builder": "^2.1.6",
+    "@platforma-sdk/test": "^1.32.4",
+    "vitest": "~2.1.9",
     "typescript": "~5.5.4"
   },
   "scripts": {

package/src/aggregate-by-clonotype-key.tpl.tengo

@@ -2,16 +2,14 @@ ll := import("@platforma-sdk/workflow-tengo:ll")
 self := import("@platforma-sdk/workflow-tengo:tpl")
 pConstants := import("@platforma-sdk/workflow-tengo:pframes.constants")
 slices := import("@platforma-sdk/workflow-tengo:slices")
-assets := import("@platforma-sdk/workflow-tengo:assets")
-exec := import("@platforma-sdk/workflow-tengo:exec")
 maps := import("@platforma-sdk/workflow-tengo:maps")
+clonotypeLabel := import(":clonotype-label")
+pt := import("@platforma-sdk/workflow-tengo:pt")
 
 json := import("json")
 
 self.defineOutputs("tsv")
 
-ptransformSw := assets.importSoftware("@platforma-open/milaboratories.software-ptransform:main")
-
 self.body(func(inputs) {
 	inputData := inputs[pConstants.VALUE_FIELD_NAME]
 	inputDataMeta := inputData.getDataAsJson()
@@ -21,48 +19,18 @@ self.body(func(inputs) {
 	params := inputs.params
 	mainAbundanceColumnNormalized := params.mainAbundanceColumnNormalized
 	mainAbundanceColumnUnnormalized := params.mainAbundanceColumnUnnormalized
-	clonotypeColumns := params.clonotypeColumns
-
-	pickCols := []
-	for col in clonotypeColumns {
-		if col == "sampleCount" || col == mainAbundanceColumnNormalized + "Mean" || col == mainAbundanceColumnUnnormalized + "Sum" {
-			continue
-		}
-		pickCols = append(pickCols, [col, col])
-	}
 
-	// Adding clonotypeKey column
-	pWorkflow := {
-		steps: [ {
-			type: "aggregate",
-			groupBy: ["clonotypeKey"],
-			aggregations: [ {
-				type: "max_by",
-				rankingCol: mainAbundanceColumnNormalized,
-				pickCols: pickCols
-			}, {
-				type: "count",
-				src: mainAbundanceColumnNormalized,
-				dst: "sampleCount"
-			}, {
-				type: "sum",
-				src: mainAbundanceColumnUnnormalized,
-				dst: mainAbundanceColumnUnnormalized + "Sum"
-			}, {
-				type: "mean",
-				src: mainAbundanceColumnNormalized,
-				dst: mainAbundanceColumnNormalized + "Mean"
-			}]
-		} ]
-	}
+	// { column: string; type: string }
+	schemaPerClonotypeNoAggregates := params.schemaPerClonotypeNoAggregates
+	schemaPerSample := params.schemaPerSample
 
-	aggregateBuilderCmd := exec.builder().
-		printErrStreamToStdout().
-		software(ptransformSw).
-		arg("--workflow").arg("wf.json").
-		writeFile("wf.json", json.encode(pWorkflow))
+	wf := pt.workflow()
+	dataFrames := []
 
 	inputMap := inputData.inputs()
+
+	baseSchemaForRead := schemaPerSample + [ { column: "clonotypeKey", type: "String" } ]
+
 	for sKey in maps.getKeys(inputMap) {
 		inputFile := inputMap[sKey]
 		key := json.decode(sKey)
@@ -70,16 +38,54 @@ self.body(func(inputs) {
 			ll.panic("malformed key: %v", sKey)
 		}
 		sampleId := key[0]
-		aggregateBuilderCmd.
-			arg(sampleId + ".tsv").
-			addFile(sampleId + ".tsv", inputFile)
+		dfId := "table_" + sampleId
+
+		df := wf.frame({
+			file: inputFile,
+			xsvType: "tsv",
+			schema: baseSchemaForRead
+		}, {
+			id: dfId,
+			inferSchema: false
+		})
+		dataFrames = append(dataFrames, df)
+	}
+
+	currentDf := undefined
+	if len(dataFrames) == 0 {
+		ll.panic("no input files found")
+	} else if len(dataFrames) == 1 {
+		currentDf = dataFrames[0]
+	} else {
+		currentDf = pt.concat(dataFrames)
+	}
+
+	aggExpressions := []
+
+	for colDef in schemaPerClonotypeNoAggregates {
+		if colDef.column == "clonotypeLabel" {
+			continue
+		}
+		aggExpressions = append(aggExpressions,
+			pt.col(colDef.column).maxBy(pt.col(mainAbundanceColumnNormalized)).alias(colDef.column)
+		)
 	}
 
-	aggregateCmd := aggregateBuilderCmd.
-		arg("output.tsv").saveFile("output.tsv").
-		run()
+	aggExpressions = append(aggExpressions,
+		pt.col(mainAbundanceColumnNormalized).count().alias("sampleCount"),
+		pt.col(mainAbundanceColumnUnnormalized).sum().alias(mainAbundanceColumnUnnormalized + "Sum"),
+		pt.col(mainAbundanceColumnNormalized).mean().alias(mainAbundanceColumnNormalized + "Mean")
+	)
+
+	aggregatedDf := currentDf.groupBy("clonotypeKey").agg(aggExpressions...)
+
+	aggregatedDf = clonotypeLabel.addClonotypeLabelColumnsPt(aggregatedDf, "clonotypeKey", "clonotypeLabel", pt)
+
+	aggregatedDf.save("output.tsv")
+
+	ptablerResult := wf.run()
 
-	processedTsv := aggregateCmd.getFile("output.tsv")
+	processedTsv := ptablerResult.getFile("output.tsv")
 
 	return {
 		tsv: processedTsv