@platforma-open/milaboratories.top-antibodies.workflow 1.16.0 → 1.17.1

package/.turbo/turbo-build.log

@@ -1,6 +1,6 @@
  WARN  Issue while reading "/home/runner/work/antibody-tcr-lead-selection/antibody-tcr-lead-selection/.npmrc". Failed to replace env in config: ${NPMJS_TOKEN}
 
-> @platforma-open/milaboratories.top-antibodies.workflow@1.16.0 build /home/runner/work/antibody-tcr-lead-selection/antibody-tcr-lead-selection/workflow
+> @platforma-open/milaboratories.top-antibodies.workflow@1.17.1 build /home/runner/work/antibody-tcr-lead-selection/antibody-tcr-lead-selection/workflow
 > rm -rf dist && pl-tengo check && pl-tengo build
 
 Processing "src/assembling-fasta.tpl.tengo"...

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # @platforma-open/milaboratories.top-antibodies.workflow
 
+## 1.17.1
+
+### Patch Changes
+
+- 0b57c1b: Show only specific columns be default: Clone, Cluster Id, AA sequence and filter/rank columns
+- Updated dependencies [0b57c1b]
+  - @platforma-open/milaboratories.top-antibodies.sample-clonotypes@1.9.1
+
+## 1.17.0
+
+### Minor Changes
+
+- b201aaf: Improve cluster ranking, improve performance
+
+### Patch Changes
+
+- Updated dependencies [b201aaf]
+  - @platforma-open/milaboratories.top-antibodies.anarci-kabat@1.3.0
+  - @platforma-open/milaboratories.top-antibodies.assembling-fasta@1.3.0
+  - @platforma-open/milaboratories.top-antibodies.sample-clonotypes@1.9.0
+  - @platforma-open/milaboratories.top-antibodies.spectratype@1.8.0
+
 ## 1.16.0
 
 ### Minor Changes

package/dist/tengo/lib/utils.lib.tengo

@@ -100,6 +100,7 @@ processRankingColumn := func(colsSpec, datasetMainAxisName, linkerColumns, clust
 
         return {
             isClusterProperty: false,
+            isLinkerColumn: false,
             header: undefined,
             clusterAxisIdx: undefined,
             newClusterPropertyIdx: clusterPropertyIdx
@@ -112,11 +113,14 @@ processRankingColumn := func(colsSpec, datasetMainAxisName, linkerColumns, clust
     header := ""
     clusterAxisIdx := undefined
     newClusterPropertyIdx := clusterPropertyIdx
+    isLinkerColumn := false
     
     if linkerIdx != undefined {
 
+
         header = "Col_linker." + string(linkerIdx)
         clusterAxisIdx = linkerIdx
+        isLinkerColumn = true
     } else {
 
         header = "Col_cluster." + string(clusterPropertyIdx)
@@ -126,14 +130,430 @@ processRankingColumn := func(colsSpec, datasetMainAxisName, linkerColumns, clust
     
     return {
         isClusterProperty: true,
+        isLinkerColumn: isLinkerColumn,
         header: header,
         clusterAxisIdx: clusterAxisIdx,
         newClusterPropertyIdx: newClusterPropertyIdx
     }
 }
 
+
+
+
+
+
+
+
+buildSortedLinkers := func(columns, datasetSpec) {
+    allLinkersUnsorted := columns.getColumns("linkers")
+    
+
+    sortedLinkers := []
+
+    for col in allLinkersUnsorted {
+        if datasetSpec.axesSpec[1].name == col.spec.axesSpec[1].name {
+            sortedLinkers = append(sortedLinkers, col)
+        }
+    }
+
+    for col in allLinkersUnsorted {
+        if datasetSpec.axesSpec[1].name == col.spec.axesSpec[0].name {
+            sortedLinkers = append(sortedLinkers, col)
+        }
+    }
+    
+    return sortedLinkers
+}
+
+
+
+
+
+
+
+
+
+resolveClusterColumnHeader := func(args, columns, sortedLinkers) {
+    if is_undefined(args.clusterColumn) {
+        return undefined
+    }
+    
+
+    selectedLinkerSpec := columns.getSpec(args.clusterColumn)
+    if is_undefined(selectedLinkerSpec) {
+        return undefined
+    }
+    
+
+    selectedClusterIdAxis := undefined
+    for axis in selectedLinkerSpec.axesSpec {
+        if axis.name == "pl7.app/vdj/clusterId" {
+            selectedClusterIdAxis = axis
+            break
+        }
+    }
+    
+    if is_undefined(selectedClusterIdAxis) {
+        return undefined
+    }
+    
+
+    for linkerIdx, col in sortedLinkers {
+
+        for axis in col.spec.axesSpec {
+            if axis.name == "pl7.app/vdj/clusterId" {
+
+                if clusterAxisDomainsMatch(selectedClusterIdAxis, axis) {
+                    return "clusterAxis_" + string(linkerIdx) + "_0"
+                }
+            }
+        }
+    }
+    
+    return undefined
+}
+
+
+
+
+
+
+
+
+
+
+
+initializeCloneTable := func(pframes, columns, args, datasetSpec) {
+
+    cloneTable := pframes.parquetFileBuilder()
+    cloneTable.setAxisHeader(datasetSpec.axesSpec[1], "clonotypeKey")
+    
+
+    sortedLinkers := buildSortedLinkers(columns, datasetSpec)
+    
+
+    addedAxes := []
+    filterMap := {}
+    rankingMap := {}
+    addedCols := false
+    
+    if len(args.filters) > 0 {
+        for i, filter in args.filters {
+
+            if filter.value != undefined && columns.getColumn(filter.value.column).spec != undefined {
+
+                cloneTable.add(columns.getColumn(filter.value.column), 
+                                {header: "Filter_" + string(i), id: "filter_" + string(i)})
+                addedCols = true
+
+                filterMap["Filter_" + string(i)] = filter.filter
+                filterMap["Filter_" + string(i)]["valueType"] = columns.getSpec(filter.value.column).valueType
+            
+
+                colsSpec := columns.getSpec(filter.value.column)
+                axesNames := slices.map(colsSpec.axesSpec, func (a) { return a.name})
+                if !slices.hasElement(axesNames, datasetSpec.axesSpec[1].name) {
+                    for na, ax in colsSpec.axesSpec {
+                        if ax.name != datasetSpec.axesSpec[1].name {
+                            cloneTable.setAxisHeader(ax, "cluster_" + string(i) + string(na))
+                            addedAxes = append(addedAxes, ax.name)
+                        }
+                    }
+                }	
+            }
+        }
+    }
+
+
+    clusterPropertyIdx := 0
+    clonotypePropertyIdx := 0
+    linkerColumnCounters := {}  // Track column count per linker index
+    
+    if len(args.rankingOrder) > 0 {
+        for i, col in args.rankingOrder {
+
+            if col.value != undefined && columns.getColumn(col.value.column).spec != undefined {
+
+                colsSpec := columns.getSpec(col.value.column)
+
+                result := processRankingColumn(colsSpec, datasetSpec.axesSpec[1].name, sortedLinkers, clusterPropertyIdx)
+                
+                header := ""
+                if result.isClusterProperty {
+
+                    if result.isLinkerColumn {
+
+                        linkerKey := "linker_" + string(result.clusterAxisIdx)
+                        if is_undefined(linkerColumnCounters[linkerKey]) {
+                            linkerColumnCounters[linkerKey] = 0
+                        }
+                        counter := linkerColumnCounters[linkerKey]
+                        header = "Col_linker." + string(result.clusterAxisIdx) + "." + string(counter)
+                        linkerColumnCounters[linkerKey] = counter + 1
+                    } else {
+                        header = result.header
+                        clusterPropertyIdx = result.newClusterPropertyIdx
+                    }
+                    
+
+                    for na, ax in colsSpec.axesSpec {
+                        if ax.name != datasetSpec.axesSpec[1].name && !slices.hasElement(addedAxes, ax.name) {
+                            axisHeader := "cluster_" + string(result.clusterAxisIdx)
+                            cloneTable.setAxisHeader(ax, axisHeader)
+                            addedAxes = append(addedAxes, ax.name)
+                        }
+                    }
+                } else {
+                    header = "Col" + string(clonotypePropertyIdx)
+                    clonotypePropertyIdx = clonotypePropertyIdx + 1
+                }
+                
+                cloneTable.add(columns.getColumn(col.value.column), {header: header})
+                addedCols = true
+                rankingMap[header] = col.rankingOrder
+            }
+        }
+    }
+
+
+    linkerClusterIdAxesWithIdx := []
+    
+    for linkerIdx, col in sortedLinkers {
+        clusterIdAxis := undefined
+        if datasetSpec.axesSpec[1].name == col.spec.axesSpec[1].name {
+
+            cloneTable.add(col, {header: "linker." + string(linkerIdx)})
+            cloneTable.setAxisHeader(col.spec.axesSpec[0], "cluster_" + string(linkerIdx))
+            clusterIdAxis = col.spec.axesSpec[0]
+            addedCols = true
+        } else if datasetSpec.axesSpec[1].name == col.spec.axesSpec[0].name {
+
+            cloneTable.add(col, {header: "linker." + string(linkerIdx)})
+            cloneTable.setAxisHeader(col.spec.axesSpec[1], "cluster_" + string(linkerIdx))
+            clusterIdAxis = col.spec.axesSpec[1]
+            addedCols = true
+        }
+
+        if !is_undefined(clusterIdAxis) && clusterIdAxis.name == "pl7.app/vdj/clusterId" {
+            linkerClusterIdAxesWithIdx = append(linkerClusterIdAxesWithIdx, {
+                axis: clusterIdAxis,
+                linkerIdx: linkerIdx
+            })
+        }
+    }
+
+
+    if len(columns.getColumns("clusterSizes")) > 0 {
+        for col in columns.getColumns("clusterSizes") {
+
+            clusterSizeClusterIdAxis := undefined
+            for axis in col.spec.axesSpec {
+                if axis.name == "pl7.app/vdj/clusterId" {
+                    clusterSizeClusterIdAxis = axis
+                    break
+                }
+            }
+            
+
+            matchingLinkerIdx := -1
+            if len(linkerClusterIdAxesWithIdx) > 0 && !is_undefined(clusterSizeClusterIdAxis) {
+                for entry in linkerClusterIdAxesWithIdx {
+                    linkerAxis := entry.axis
+
+                    if clusterSizeClusterIdAxis.name == linkerAxis.name &&
+                       clusterSizeClusterIdAxis.type == linkerAxis.type &&
+                       clusterAxisDomainsMatch(clusterSizeClusterIdAxis, linkerAxis) {
+                        matchingLinkerIdx = entry.linkerIdx
+                        break
+                    }
+                }
+            }
+            
+
+            if matchingLinkerIdx >= 0 {
+                cloneTable.add(col, {header: "clusterSize." + string(matchingLinkerIdx)})
+                addedCols = true
+
+                for axisIdx, axis in col.spec.axesSpec {
+                    if axis.name != datasetSpec.axesSpec[1].name {
+                        cloneTable.setAxisHeader(axis, "clusterAxis_" + string(matchingLinkerIdx) + "_" + string(axisIdx))
+                    }
+                }
+            }
+        }
+    }
+
+
+    if !addedCols {
+        cdr3Sequences := columns.getColumns("cdr3Sequences")
+        if len(cdr3Sequences) > 0 {
+            cloneTable.add(cdr3Sequences[0], {header: "cdr3_fallback"})
+            addedCols = true
+        }
+    }
+
+
+    builtTable := undefined
+    clusterColumnHeader := undefined
+    if addedCols {
+        cloneTable.mem("16GiB")
+        cloneTable.cpu(1)
+        builtTable = cloneTable.build()
+        
+
+        clusterColumnHeader = resolveClusterColumnHeader(args, columns, sortedLinkers)
+    }
+    
+    return {
+        cloneTable: builtTable,
+        filterMap: filterMap,
+        rankingMap: rankingMap,
+        sortedLinkers: sortedLinkers,
+        clusterColumnHeader: clusterColumnHeader,
+        addedCols: addedCols
+    }
+}
+
+
+
+
+
+
+
+
+
+makeHeaderName := func(col, baseHeaderName, isSingleCell) {
+    chainMapping := {
+        "IG": { "A": "Heavy", "B": "Light" },
+        "TCRAB": { "A": "TRA", "B": "TRB" },
+        "TCRGD": { "A": "TRG", "B": "TRD" }
+    }
+    
+    if isSingleCell {
+        chain := col.spec.domain["pl7.app/vdj/scClonotypeChain"]  // e.g., "A", "B"
+        receptor := col.spec.axesSpec[0].domain["pl7.app/vdj/receptor"]  // e.g., "IG", "TCRAB", "TCRGD"
+        chainLabel := chainMapping[receptor][chain]
+        return baseHeaderName + "." + chainLabel // e.g., "cdr3Sequence.Heavy"
+    } else {
+
+        chainFromDomain := col.spec.axesSpec[0].domain["pl7.app/vdj/chain"] // e.g. "IGH", "IGK"
+        if chainFromDomain != undefined {
+            return baseHeaderName + "." + chainFromDomain // e.g., "cdr3Sequence.IGH"
+        }
+    }
+    return baseHeaderName
+}
+
+
+
+
+
+
+
+
+
+
+initializeCdr3SeqTable := func(pframes, columns, datasetSpec, isSingleCell) {
+    cdr3SeqTable := pframes.parquetFileBuilder()
+    cdr3SeqTable.setAxisHeader(datasetSpec.axesSpec[1].name, "clonotypeKey")
+
+
+    cdr3Sequences := columns.getColumns("cdr3Sequences")
+    for col in cdr3Sequences {
+        headerName := makeHeaderName(col, "cdr3Sequence", isSingleCell)
+        if isSingleCell {
+            if col.spec.domain["pl7.app/vdj/scClonotypeChain/index"] == "primary" {
+                cdr3SeqTable.add(col, {header: headerName})
+            }
+        } else {
+            cdr3SeqTable.add(col, {header: headerName})
+        }
+    }
+
+
+    vGenes := columns.getColumns("VGenes")
+    for col in vGenes {
+        headerName := makeHeaderName(col, "vGene", isSingleCell)
+        cdr3SeqTable.add(col, {header: headerName})
+    }
+
+
+    jGenes := columns.getColumns("JGenes")
+    for col in jGenes {
+        headerName := makeHeaderName(col, "jGene", isSingleCell)
+        cdr3SeqTable.add(col, {header: headerName})
+    }
+
+    cdr3SeqTable.mem("16GiB")
+    cdr3SeqTable.cpu(1)
+    return cdr3SeqTable.build()
+}
+
+
+
+
+
+
+
+detectBulkChain := func(seqCols) {
+    chainDetected := "KL"
+    for col in seqCols {
+        ch := col.spec.axesSpec[0].domain["pl7.app/vdj/chain"] // e.g., IGHeavy, IGLight
+        if ch == "IGHeavy" { 
+            chainDetected = "H"
+            break 
+        }
+        if ch == "IGLight" { 
+            chainDetected = "KL" 
+        }
+    }
+    return chainDetected
+}
+
+
+
+
+
+
+
+
+
+
+initializeAssemSeqTable := func(pframes, columns, datasetSpec, isSingleCell) {
+    assemSeqTable := pframes.parquetFileBuilder()
+    assemSeqTable.setAxisHeader(datasetSpec.axesSpec[1].name, "clonotypeKey")
+
+    seqCols := columns.getColumns("assemblingAaSeqs")
+    for col in seqCols {
+        headerName := makeHeaderName(col, "assemblingFeature", isSingleCell)
+        assemSeqTable.add(col, {header: headerName})
+    }
+
+    assemSeqTable.mem("16GiB")
+    assemSeqTable.cpu(1)
+    
+
+    bulkChain := undefined
+    if !isSingleCell {
+        bulkChain = detectBulkChain(seqCols)
+    }
+    
+    return {
+        assemSeqTable: assemSeqTable.build(),
+        bulkChain: bulkChain,
+        seqCols: seqCols
+    }
+}
+
 export {
     clusterAxisDomainsMatch: clusterAxisDomainsMatch,
     findMatchingLinkerIndex: findMatchingLinkerIndex,
-    processRankingColumn: processRankingColumn
+    processRankingColumn: processRankingColumn,
+    buildSortedLinkers: buildSortedLinkers,
+    resolveClusterColumnHeader: resolveClusterColumnHeader,
+    initializeCloneTable: initializeCloneTable,
+    makeHeaderName: makeHeaderName,
+    initializeCdr3SeqTable: initializeCdr3SeqTable,
+    detectBulkChain: detectBulkChain,
+    initializeAssemSeqTable: initializeAssemSeqTable
 }

package/package.json

@@ -1,25 +1,23 @@
 {
   "name": "@platforma-open/milaboratories.top-antibodies.workflow",
-  "version": "1.16.0",
+  "version": "1.17.1",
   "type": "module",
   "description": "Block Workflow",
   "dependencies": {
-    "@platforma-sdk/workflow-tengo": "^5.7.3",
+    "@platforma-sdk/workflow-tengo": "5.7.3",
     "@platforma-open/milaboratories.software-anarci": "^0.0.3",
-    "@platforma-open/milaboratories.top-antibodies.sample-clonotypes": "1.8.0",
+    "@platforma-open/milaboratories.top-antibodies.sample-clonotypes": "1.9.1",
+    "@platforma-open/milaboratories.top-antibodies.spectratype": "1.8.0",
     "@platforma-open/milaboratories.top-antibodies.umap": "1.2.1",
-    "@platforma-open/milaboratories.top-antibodies.assembling-fasta": "1.2.1",
-    "@platforma-open/milaboratories.top-antibodies.spectratype": "1.7.1",
-    "@platforma-open/milaboratories.top-antibodies.anarci-kabat": "1.2.1"
+    "@platforma-open/milaboratories.top-antibodies.assembling-fasta": "1.3.0",
+    "@platforma-open/milaboratories.top-antibodies.anarci-kabat": "1.3.0"
   },
   "devDependencies": {
-    "@platforma-sdk/tengo-builder": "^2.4.2",
-    "@platforma-sdk/test": "^1.48.8",
-    "vitest": "^2.1.8"
+    "@platforma-sdk/tengo-builder": "2.4.8"
   },
   "scripts": {
     "build": "rm -rf dist && pl-tengo check && pl-tengo build",
-    "test": "vitest",
-    "format": "/usr/bin/env emacs --script ./format.el"
+    "format": "/usr/bin/env emacs --script ./format.el",
+    "do-pack": "rm -f *.tgz && pnpm pack && mv *.tgz package.tgz"
   }
 }