Only generate tracks for available gff fields

Author: cmdcolin

eslint.config.mjs

@@ -70,6 +70,7 @@ export default tseslint.config(
       '@typescript-eslint/no-unsafe-assignment': 'off',
       '@typescript-eslint/restrict-template-expressions': 'off',
       '@typescript-eslint/no-empty-function': 'off',
+      '@typescript-eslint/no-deprecated': 'off',
 
       'unicorn/no-array-for-each': 'off',
       'unicorn/no-null': 'off',

src/LaunchProteinView/components/AlphaFoldDBSearch.tsx

@@ -187,7 +187,12 @@ const AlphaFoldDBSearch = observer(function ({
                   connectedViewId: view.id,
                 },
               ],
-              displayName: `Protein view ${uniprotId} - ${getGeneDisplayName(feature)} - ${getTranscriptDisplayName(selectedTranscript)}`,
+              displayName: [
+                'Protein view',
+                uniprotId,
+                getGeneDisplayName(feature),
+                getTranscriptDisplayName(selectedTranscript),
+              ].join(' - '),
             })
             handleClose()
           }}
@@ -201,113 +206,140 @@ const AlphaFoldDBSearch = observer(function ({
           }
           onClick={() => {
             if (uniprotId && isSessionWithAddTracks(session)) {
-              session.addTemporaryAssembly?.({
-                name: uniprotId,
-                sequence: {
-                  type: 'ReferenceSequenceTrack',
-                  trackId: `${uniprotId}-ReferenceSequenceTrack`,
-                  sequenceType: 'pep',
-                  adapter: {
-                    type: 'UnindexedFastaAdapter',
-                    rewriteRefNames: "jexl:split(refName,'|')[1]",
-                    fastaLocation: {
-                      uri: `https://rest.uniprot.org/uniprotkb/${uniprotId}.fasta`,
+              // eslint-disable-next-line @typescript-eslint/no-floating-promises
+              ;(async () => {
+                try {
+                  session.addTemporaryAssembly?.({
+                    name: uniprotId,
+                    sequence: {
+                      type: 'ReferenceSequenceTrack',
+                      trackId: `${uniprotId}-ReferenceSequenceTrack`,
+                      sequenceType: 'pep',
+                      adapter: {
+                        type: 'UnindexedFastaAdapter',
+                        rewriteRefNames: "jexl:split(refName,'|')[1]",
+                        fastaLocation: {
+                          uri: `https://rest.uniprot.org/uniprotkb/${uniprotId}.fasta`,
+                        },
+                      },
                     },
-                  },
-                },
-              })
-              ;[
-                'Alternative sequence',
-                'Beta strand',
-                'Binding site',
-                'Chain',
-                'Compositional bias',
-                'Cross-link',
-                'Disulfide bond',
-                'Domain',
-                'Glycosylation',
-                'Helix',
-                'Modified residue',
-                'Motif',
-                'Mutagenesis',
-                'Natural variant',
-                'Peptide',
-                'Region',
-                'Sequence conflict',
-                'Signal peptide',
-                'Site',
-                'Topological domain',
-                'Transmembrane',
-                'Turn',
-              ].forEach(type => {
-                const s = `${uniprotId}-${type}`
-                session.addTrackConf({
-                  type: 'FeatureTrack',
-                  trackId: s,
-                  name: type,
-                  adapter: {
-                    type: 'Gff3Adapter',
-                    gffLocation: {
-                      uri: `https://rest.uniprot.org/uniprotkb/${uniprotId}.gff`,
+                  })
+                  const url = `https://rest.uniprot.org/uniprotkb/${uniprotId}.gff`
+                  const res = await fetch(url)
+                  if (!res.ok) {
+                    throw new Error(`HTTP ${res.status} fetching ${url}`)
+                  }
+                  const data = await res.text()
+
+                  const types = [
+                    ...new Set(
+                      data
+                        .split('\n')
+                        .filter(f => !f.startsWith('#'))
+                        .map(f => f.trim())
+                        .filter(f => !!f)
+                        .map(f => f.split('\t')[2]),
+                    ),
+                  ]
+                  types.forEach(type => {
+                    const s = `${uniprotId}-${type}`
+                    session.addTrackConf({
+                      type: 'FeatureTrack',
+                      trackId: s,
+                      name: type,
+                      adapter: {
+                        type: 'Gff3Adapter',
+                        gffLocation: {
+                          uri: `https://rest.uniprot.org/uniprotkb/${uniprotId}.gff`,
+                        },
+                      },
+                      assemblyNames: [uniprotId],
+                      displays: [
+                        {
+                          displayId: `${type}-LinearBasicDisplay`,
+                          type: 'LinearBasicDisplay',
+                          jexlFilters: [`get(feature,'type')=='${type}'`],
+                        },
+                      ],
+                    })
+                  })
+                  session.addTrackConf({
+                    type: 'FeatureTrack',
+                    trackId: 'Antigen',
+                    name: 'Antigen',
+                    adapter: {
+                      type: 'Gff3Adapter',
+                      gffLocation: {
+                        uri: `https://www.ebi.ac.uk/proteins/api/antigen/${uniprotId}?format=gff`,
+                      },
                     },
-                  },
-                  assemblyNames: [uniprotId],
-                  displays: [
-                    {
-                      displayId: `${type}-LinearBasicDisplay`,
-                      type: 'LinearBasicDisplay',
-                      jexlFilters: [`get(feature,'type')=='${type}'`],
+                    assemblyNames: [uniprotId],
+                  })
+                  session.addTrackConf({
+                    type: 'FeatureTrack',
+                    trackId: 'Variation',
+                    name: 'Variation',
+                    adapter: {
+                      type: 'UniProtVariationAdapter',
+                      location: {
+                        uri: `https://www.ebi.ac.uk/proteins/api/variation/${uniprotId}.json`,
+                      },
                     },
-                  ],
-                })
-              })
-              session.addTrackConf({
-                type: 'QuantitativeTrack',
-                trackId: 'AlphaFold confidence',
-                name: 'AlphaFold confidence',
-                adapter: {
-                  type: 'AlphaFoldConfidenceAdapter',
-                  location: {
-                    uri: `https://alphafold.ebi.ac.uk/files/AF-${uniprotId}-F1-confidence_v4.json`,
-                    locationType: 'UriLocation',
-                  },
-                },
-                assemblyNames: [uniprotId],
-              })
-              session.addTrackConf({
-                type: 'MultiQuantitativeTrack',
-                trackId: 'AlphaMissense scores',
-                name: 'AlphaMissense scores',
-                assemblyNames: [uniprotId],
-                adapter: {
-                  type: 'AlphaMissensePathogenicityAdapter',
-                  location: {
-                    locationType: 'UriLocation',
-                    uri: `https://alphafold.ebi.ac.uk/files/AF-${uniprotId}-F1-aa-substitutions.csv`,
-                  },
-                },
-                displays: [
-                  {
-                    type: 'MultiLinearWiggleDisplay',
-                    displayId: 'AlphaMissense scores-MultiLinearWiggleDisplay',
-                    defaultRendering: 'multirowdensity',
-                    renderers: {
-                      MultiDensityRenderer: {
-                        type: 'MultiDensityRenderer',
-                        bicolorPivotValue: 0.5,
+                    assemblyNames: [uniprotId],
+                  })
+                  session.addTrackConf({
+                    type: 'QuantitativeTrack',
+                    trackId: 'AlphaFold confidence',
+                    name: 'AlphaFold confidence',
+                    adapter: {
+                      type: 'AlphaFoldConfidenceAdapter',
+                      location: {
+                        uri: `https://alphafold.ebi.ac.uk/files/AF-${uniprotId}-F1-confidence_v4.json`,
                       },
                     },
-                  },
-                ],
-              })
-              const view = session.addView('LinearGenomeView', {
-                type: 'LinearGenomeView',
-                displayName: `Protein view ${uniprotId} ${getGeneDisplayName(feature)} - ${getTranscriptDisplayName(selectedTranscript)}`,
-              }) as LinearGenomeViewModel
-              view.navToLocString(uniprotId, uniprotId).catch((e: unknown) => {
-                console.error(e)
-                session.notifyError(`${e}`, e)
-              })
+                    assemblyNames: [uniprotId],
+                  })
+                  session.addTrackConf({
+                    type: 'MultiQuantitativeTrack',
+                    trackId: 'AlphaMissense scores',
+                    name: 'AlphaMissense scores',
+                    assemblyNames: [uniprotId],
+                    adapter: {
+                      type: 'AlphaMissensePathogenicityAdapter',
+                      location: {
+                        uri: `https://alphafold.ebi.ac.uk/files/AF-${uniprotId}-F1-aa-substitutions.csv`,
+                      },
+                    },
+                    displays: [
+                      {
+                        type: 'MultiLinearWiggleDisplay',
+                        displayId:
+                          'AlphaMissense scores-MultiLinearWiggleDisplay',
+                        defaultRendering: 'multirowdensity',
+                        renderers: {
+                          MultiDensityRenderer: {
+                            type: 'MultiDensityRenderer',
+                            bicolorPivotValue: 0.5,
+                          },
+                        },
+                      },
+                    ],
+                  })
+                  const view = session.addView('LinearGenomeView', {
+                    type: 'LinearGenomeView',
+                    displayName: [
+                      'Protein view',
+                      uniprotId,
+                      getGeneDisplayName(feature),
+                      getTranscriptDisplayName(selectedTranscript),
+                    ].join(' - '),
+                  }) as LinearGenomeViewModel
+                  await view.navToLocString(uniprotId, uniprotId)
+                } catch (e) {
+                  console.error(e)
+                  session.notifyError(`${e}`, e)
+                }
+              })()
             }
             handleClose()
           }}

src/UniProtVariationAdapter/UniProtVariationAdapter.ts

@@ -0,0 +1,99 @@
+import {
+  BaseFeatureDataAdapter,
+  BaseOptions,
+} from '@jbrowse/core/data_adapters/BaseAdapter'
+import { openLocation } from '@jbrowse/core/util/io'
+import { ObservableCreate } from '@jbrowse/core/util/rxjs'
+import {
+  Region,
+  Feature,
+  doesIntersect2,
+  SimpleFeature,
+} from '@jbrowse/core/util'
+
+interface UniProtVariantFeature {
+  begin: string
+  end: string
+  wildType: string
+  mutatedType: string
+  xrefs: {
+    name: string
+    id: string
+    url: string
+    alternativeUrl: string
+  }[]
+  predictions?: {
+    score: number
+  }[]
+  descriptions?: {
+    value: string
+  }[]
+  populationFrequencies?: {
+    frequency?: number
+  }[]
+}
+
+export default class UniProtVariationAdapter extends BaseFeatureDataAdapter {
+  public static capabilities = ['getFeatures', 'getRefNames']
+
+  public feats:
+    | Promise<{ uniqueId: string; start: number; end: number }[]>
+    | undefined
+
+  private async loadDataP() {
+    const { features } = JSON.parse(
+      await openLocation(this.getConf('location')).readFile('utf8'),
+    ) as { features: UniProtVariantFeature[] }
+
+    const scoreField = this.getConf('scoreField')
+
+    return features.map(({ begin, end, ...rest }, idx) => ({
+      ...rest,
+      uniqueId: `feat-${idx}`,
+      start: +begin,
+      end: +end + 1,
+      score:
+        scoreField === 'population_frequency'
+          ? rest.populationFrequencies?.[0]?.frequency
+          : scoreField === 'variant_impact_score'
+            ? rest.predictions?.[0]?.score
+            : undefined,
+      description: rest.descriptions?.map(d => d.value).join(','),
+      name: [
+        rest.mutatedType
+          ? `${rest.wildType}->${rest.mutatedType}`
+          : `${rest.wildType}->del`,
+      ],
+    }))
+  }
+
+  private async loadData(_opts: BaseOptions = {}) {
+    if (!this.feats) {
+      this.feats = this.loadDataP().catch((e: unknown) => {
+        this.feats = undefined
+        throw e
+      })
+    }
+
+    return this.feats
+  }
+
+  public async getRefNames(_opts: BaseOptions = {}) {
+    return []
+  }
+
+  public getFeatures(query: Region, opts: BaseOptions = {}) {
+    return ObservableCreate<Feature>(async observer => {
+      const { start, end, refName } = query
+      const data = await this.loadData()
+      for (const f of data) {
+        if (doesIntersect2(f.start, f.end, start, end)) {
+          observer.next(new SimpleFeature({ ...f, refName }))
+        }
+      }
+      observer.complete()
+    }, opts.signal)
+  }
+
+  public freeResources(): void {}
+}

src/UniProtVariationAdapter/configSchema.ts

@@ -0,0 +1,25 @@
+import { ConfigurationSchema } from '@jbrowse/core/configuration'
+
+/**
+ * #config UniProtVariationAdapter
+ */
+function x() {} // eslint-disable-line @typescript-eslint/no-unused-vars
+
+const UniProtVariationAdapter = ConfigurationSchema(
+  'UniProtVariationAdapter',
+  {
+    /**
+     * #slot
+     */
+    location: {
+      type: 'fileLocation',
+      defaultValue: { uri: '/path/to/my.bed.gz', locationType: 'UriLocation' },
+    },
+    scoreField: {
+      type: 'string',
+      defaultValue: '',
+    },
+  },
+  { explicitlyTyped: true },
+)
+export default UniProtVariationAdapter