@datagrok/bio 1.2.1 → 1.4.0

package/src/package.ts

@@ -2,12 +2,18 @@
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
+
 import {SequenceAlignment, Aligned} from './seq_align';
 
 export const _package = new DG.Package();
 
 import {WebLogo} from '@datagrok-libraries/bio/src/viewers/web-logo';
 import {VdRegionsViewer} from './viewers/vd-regions-viewer';
+import {runKalign, testMSAEnoughMemory} from './utils/multiple-sequence-alignment';
+import {TableView} from 'datagrok-api/dg';
+import {mmSemType} from './const';
+import {Nucleotides} from '@datagrok-libraries/bio/src/nucleotides';
+import {Aminoacids} from '@datagrok-libraries/bio/src/aminoacids';
 
 //name: sequenceAlignment
 //input: string alignType {choices: ['Local alignment', 'Global alignment']}
@@ -38,3 +44,97 @@ export function webLogoViewer() {
 export function vdRegionViewer() {
   return new VdRegionsViewer();
 }
+
+//top-menu: Bio | Activity Cliffs...
+//name: Activity Cliffs
+//description: detect activity cliffs
+//input: dataframe df [Input data table]
+//input: column smiles {type:categorical; semType: Macromolecule}
+//input: column activities
+//input: double similarity = 80 [Similarity cutoff]
+//input: string methodName { choices:["UMAP", "t-SNE", "SPE"] }
+export async function activityCliffs(df: DG.DataFrame, smiles: DG.Column, activities: DG.Column,
+  similarity: number, methodName: string): Promise<void> {
+}
+
+//top-menu: Bio | Sequence Space...
+//name: Sequence Space
+//input: dataframe table
+//input: column smiles { semType: Macromolecule }
+//input: string methodName { choices:["UMAP", "t-SNE", "SPE", "pSPE", "OriginalSPE"] }
+//input: string similarityMetric { choices:["Tanimoto", "Asymmetric", "Cosine", "Sokal"] }
+//input: bool plotEmbeddings = true
+export async function chemSpaceTopMenu(table: DG.DataFrame, smiles: DG.Column, methodName: string,
+  similarityMetric: string = 'Tanimoto', plotEmbeddings: boolean): Promise<void> {
+};
+
+//top-menu: Bio | MSA...
+//name: MSA
+//input: dataframe table
+//input: column sequence { semType: Macromolecule }
+export async function multipleSequenceAlignmentAny(table: DG.DataFrame, col: DG.Column): Promise<void> {
+  const msaCol = await runKalign(col, false);
+  table.columns.add(msaCol);
+}
+
+//name: Composition Analysis
+//top-menu: Bio | Composition Analysis
+//output: viewer result
+export async function compositionAnalysis(): Promise<void> {
+  const col = grok.shell.t.columns.bySemType('Macromolecule');//DG.SEMTYPE.MACROMOLECULE);
+  if (col === null) {
+    grok.shell.error('Current table does not contain sequences');
+    return;
+  }
+
+  const wl = await col.dataFrame.plot.fromType('WebLogo', {});
+
+  for (const v of grok.shell.views) {
+    if (v instanceof TableView && (v as DG.TableView).dataFrame.name === col.dataFrame.name) {
+      (v as DG.TableView).dockManager.dock(wl.root, 'down');
+      break;
+    }
+  }
+}
+
+//name: importFasta
+//description: Opens FASTA file
+//tags: file-handler
+//meta.ext: fasta, fna, ffn, faa, frn, fa
+//input: string content
+//output: list tables
+export function importFasta(content: string): DG.DataFrame [] {
+  const regex = /^>(.*)$/gm;
+  const descriptions = [];
+  const sequences = [];
+  let index = 0;
+  let match;
+  while (match = regex.exec(content)) {
+    descriptions.push(content.substring(match.index + 1, regex.lastIndex));
+    if (index !== 0)
+      sequences.push(content.substring(index, regex.lastIndex));
+    index = regex.lastIndex + 1;
+  }
+  sequences.push(content.substring(index));
+  const descriptionsCol = DG.Column.fromStrings('description', descriptions);
+  const sequenceCol = DG.Column.fromStrings('sequence', sequences);
+
+  const stats: { freq: { [m: string]: number }, sameLength: boolean } = WebLogo.getStats(sequenceCol, 5, WebLogo.splitterAsFasta);
+  const seqType = stats.sameLength ? 'SEQ.MSA' : 'SEQ';
+  const alphabetCandidates: [string, Set<string>][] = [
+    ['NT', new Set(Object.keys(Nucleotides.Names)),],
+    ['PT', new Set(Object.keys(Aminoacids.Names)),],
+  ];
+  // Calculate likelihoods for alphabet_candidates
+  const alphabetCandidatesSim: number[] = alphabetCandidates.map(
+    (c) => WebLogo.getAlphabetSimilarity(stats.freq, c[1]));
+  const maxCos = Math.max(...alphabetCandidatesSim);
+  const alphabet = maxCos > 0.65 ? alphabetCandidates[alphabetCandidatesSim.indexOf(maxCos)][0] : 'UN';
+  sequenceCol.semType = mmSemType;
+  sequenceCol.setTag(DG.TAGS.UNITS, `fasta:${seqType}:${alphabet}`);
+
+  return [DG.DataFrame.fromColumns([
+    descriptionsCol,
+    sequenceCol,
+  ])];
+}

package/src/tests/{Palettes.test.ts → Palettes-test.ts}

@@ -7,6 +7,6 @@ import * as DG from 'datagrok-api/dg';
 import {_testPaletteN, _testPaletteAA} from '@datagrok-libraries/bio/src/tests/palettes.test';
 
 category('Palettes', () => {
-  test('testPaletteN', async () => { _testPaletteN(); });
-  test('testPaletteAA', async () => { _testPaletteAA(); });
+  test('testPaletteN', async () => { await _testPaletteN(); });
+  test('testPaletteAA', async () => { await _testPaletteAA(); });
 });

package/src/tests/WebLogo-test.ts

@@ -0,0 +1,130 @@
+import {after, before, category, test, expect, expectObject} from '@datagrok-libraries/utils/src/test';
+
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {Nucleotides, NucleotidesPalettes} from '@datagrok-libraries/bio/src/nucleotides';
+import {Aminoacids, AminoacidsPalettes} from '@datagrok-libraries/bio/src/aminoacids';
+import {WebLogo} from '@datagrok-libraries/bio/src/viewers/web-logo';
+import {SeqPalette} from '@datagrok-libraries/bio/src/seq-palettes';
+import {UnknownSeqPalette} from '@datagrok-libraries/bio/src/unknown';
+
+category('WebLogo', () => {
+  const csvDfN1: string = `seq
+ACGTCT
+CAGTGT
+TTCAAC
+`;
+
+  /** 2 - is an error monomer
+   * This sequence set should be classified as nucleotides sequences.
+   * Small error, not similar to amino acids.
+   */
+  const csvDfN1e: string = `seq
+ACGTAT
+CAGTTG
+TTCG2C
+`;
+
+  /** Pure amino acids sequence */
+  const csvDfAA1: string = `seq
+FWPHEYV
+YNRQWYV
+MKPSEYV
+`;
+
+  /** A - alanine, G - glycine, T -= threonine, C - cysteine, W - tryptophan
+   * This sequence set should be detected as amino acids more than nucleotides.
+   */
+  const csvDfAA2: string = `seq
+AGTCAT
+AGTCGC
+AGTCATW
+`;
+
+  /** This sequence set should be recognized as unknown. */
+  const csvDfX: string = `seq
+XZJ{}2
+5Z4733
+3Z6></
+675687
+`;
+
+  // anonymous functions specified in test() registering must return Promise<any>
+  test('testGetStats', async () => { await _testGetStats(csvDfN1); });
+  test('testGetAlphabetSimilarity', async () => { await _testGetAlphabetSimilarity(); });
+
+  test('testPickupPaletteN1', async () => { await _testPickupPaletteN1(csvDfN1); });
+  test('testPickupPaletteN1e', async () => { await _testPickupPaletteN1e(csvDfN1e); });
+  test('testPickupPaletteAA1', async () => { await _testPickupPaletteAA1(csvDfAA1); });
+  test('testPickupPaletteX', async () => { await _testPickupPaletteX(csvDfX); });
+});
+
+
+export async function _testGetStats(csvDfN1: string) {
+  const dfN1: DG.DataFrame = DG.DataFrame.fromCsv(csvDfN1);
+  const seqCol: DG.Column = dfN1.col('seq')!;
+  const stats = WebLogo.getStats(seqCol, 5, WebLogo.splitterAsFasta);
+
+  expectObject(stats.freq, {
+    'A': 4,
+    'C': 5,
+    'G': 3,
+    'T': 6
+  });
+  expect(stats.sameLength, true);
+}
+
+export async function _testGetAlphabetSimilarity() {
+  const freq: { [m: string]: number } = {
+    'A': 2041,
+    'C': 3015,
+    'G': 3015,
+    'T': 2048,
+    '-': 1000
+  };
+  const alphabet: Set<string> = new Set(Object.keys(Nucleotides.Names));
+  const res = WebLogo.getAlphabetSimilarity(freq, alphabet);
+
+  expect(res > 0.6, true);
+}
+
+export async function _testPickupPaletteN1(csvDfN1: string) {
+  const df: DG.DataFrame = DG.DataFrame.fromCsv(csvDfN1);
+  const col: DG.Column = df.col('seq')!;
+  const cp = WebLogo.pickUpPalette(col);
+
+  expect(cp instanceof NucleotidesPalettes, true);
+}
+
+export async function _testPickupPaletteN1e(csvDfN1e: string) {
+  const df: DG.DataFrame = DG.DataFrame.fromCsv(csvDfN1e);
+  const col: DG.Column = df.col('seq')!;
+  const cp = WebLogo.pickUpPalette(col);
+
+  expect(cp instanceof NucleotidesPalettes, true);
+}
+
+export async function _testPickupPaletteAA1(csvDfAA1: string) {
+  const df: DG.DataFrame = DG.DataFrame.fromCsv(csvDfAA1);
+  const col: DG.Column = df.col('seq')!;
+  const cp = WebLogo.pickUpPalette(col);
+
+  expect(cp instanceof AminoacidsPalettes, true);
+}
+
+export async function _testPickupPaletteX(csvDfX: string) {
+  const df: DG.DataFrame = DG.DataFrame.fromCsv(csvDfX);
+  const col: DG.Column = df.col('seq')!;
+  const cp = WebLogo.pickUpPalette(col);
+
+  expect(cp instanceof UnknownSeqPalette, true);
+}
+
+export async function _testPickupPaletteAA2(dfAA2: DG.DataFrame) {
+  const seqCol: DG.Column = dfAA2.col('seq')!;
+  const cp = WebLogo.pickUpPalette(seqCol);
+
+  expect(cp instanceof AminoacidsPalettes, true);
+}

package/src/tests/detectors-test.ts

@@ -0,0 +1,213 @@
+import {after, before, category, test, expect, expectObject} from '@datagrok-libraries/utils/src/test';
+
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {mmSemType} from '../const';
+import {importFasta} from '../package';
+
+category('detectors', () => {
+  const csvDf1: string = `col1
+1
+2
+3`;
+
+  const csvDf2: string = `col1
+4
+5
+6
+7`;
+
+  const csvDf3: string = `col1
+8
+9
+10
+11
+12`;
+
+  const csvDfSmiles: string = `col1
+CCCCN1C(=O)CN=C(c2cc(F)ccc12)C3CCCCC3
+C1CCCCC1
+CCCCCC
+`;
+
+  const csvDfN1: string = `seq
+ACGTC
+CAGTGT
+TTCAAC
+`;
+
+  /** Pure amino acids sequence */
+  const csvDfAA1: string = `seq
+FWPHEY
+YNRQWYV
+MKPSEYV
+`;
+
+  const csvDfSepNt: string = `seq
+A*C*G*T*C
+C*A*G*T*G*T
+T*T*C*A*A*C
+`;
+
+  const csvDfSepPt: string = `seq
+F-W-P-H-E-Y
+Y-N-R-Q-W-Y-V
+M-K-P-S-E-Y-V
+`;
+
+  const csvDfSepUn1: string = `seq
+abc-dfgg-abc1-cfr3-rty-wert
+rut12-her2-rty-wert-abc-abc1-dfgg
+rut12-rty-her2-abc-cfr3-wert-rut12
+`;
+
+  const csvDfSepUn2: string = `seq
+abc/dfgg/abc1/cfr3/rty/wert
+rut12/her2/rty/wert//abc/abc1/dfgg
+rut12/rty/her2/abc/cfr3//wert/rut12
+`;
+
+  const csvDfSepMsaN1: string = `seq
+A-C--G-T--C-T
+C-A-C--T--G-T
+A-C-C-G-T-A-C-T
+`;
+
+  const csvDfMsaN1: string = `seq
+AC-GT-CT
+CAC-T-GT
+ACCGTACT
+`;
+
+  const csvDfMsaAA1: string = `seq
+FWR-WYV-KHP
+YNR-WYV-KHP
+MWRSWY-CKHP
+`;
+
+  test('testDetectorsNegative1', async () => { await _testDetectorsNegative(csvDf1); });
+  test('testDetectorsNegative2', async () => { await _testDetectorsNegative(csvDf2); });
+  test('testDetectorsNegative3', async () => { await _testDetectorsNegative(csvDf3); });
+  test('testDetectorsNegativeSmiles', async () => { await _testDetectorsNegative(csvDfSmiles); });
+
+  test('testDetectorsN1', async () => { await _testDetectorsN1(csvDfN1); });
+  test('testDetectorsAA1', async () => { await _testDetectorsAA1(csvDfAA1); });
+  test('testDetectorsMsaN1', async () => { await _testDetectorsMsaN1(csvDfMsaN1); });
+  test('testDetectorsMsaAA1', async () => { await _testDetectorsMsaAA1(csvDfMsaAA1); });
+
+  test('testDetectorsSepNt', async () => { await _testDetectorsSepNt(csvDfSepNt, '*'); });
+  test('testDetectorsSepPt', async () => { await _testDetectorsSepPt(csvDfSepPt, '-'); });
+  test('testDetectorsSepUn1', async () => { await _testDetectorsSepUn(csvDfSepUn1, '-'); });
+  test('testDetectorsSepUn2', async () => { await _testDetectorsSepUn(csvDfSepUn2, '/'); });
+
+  test('testDetectorsSepMsaN1', async () => { await _testDetectorsSepMsaN1(csvDfSepMsaN1); });
+
+  test('testDetectorsSamplesFastaCsvPt', async () => { await _testDetectorsSamplesFastaCsvPt(); });
+  test('testDetectorsSamplesFastaFastaPt', async () => { await _testDetectorsSamplesFastaFastaPt(); });
+});
+
+export async function _testDetectorsNegative(csvDf: string) {
+  const df: DG.DataFrame = DG.DataFrame.fromCsv(csvDf);
+  await grok.data.detectSemanticTypes(df);
+
+  const col1: DG.Column = df.col('col1')!;
+  expect(col1.semType == mmSemType, false);
+}
+
+export async function _testDetectorsN1(csvDfN1: string) {
+  const dfN1: DG.DataFrame = DG.DataFrame.fromCsv(csvDfN1);
+  await grok.data.detectSemanticTypes(dfN1);
+
+  const col: DG.Column = dfN1.col('seq')!;
+  expect(col.semType, mmSemType);
+  expect(col.getTag(DG.TAGS.UNITS), 'fasta:SEQ:NT');
+}
+
+export async function _testDetectorsAA1(csvDfAA1: string) {
+  const dfAA1: DG.DataFrame = DG.DataFrame.fromCsv(csvDfAA1);
+  await grok.data.detectSemanticTypes(dfAA1);
+
+  const col: DG.Column = dfAA1.col('seq')!;
+  expect(col.semType, mmSemType);
+  expect(col.getTag(DG.TAGS.UNITS), 'fasta:SEQ:PT');
+}
+
+export async function _testDetectorsMsaN1(csvDfMsaN1: string) {
+  const dfMsaN1: DG.DataFrame = DG.DataFrame.fromCsv(csvDfMsaN1);
+  await grok.data.detectSemanticTypes(dfMsaN1);
+
+  const col: DG.Column = dfMsaN1.col('seq')!;
+  expect(col.semType, mmSemType);
+  expect(col.getTag(DG.TAGS.UNITS), 'fasta:SEQ.MSA:NT');
+}
+
+export async function _testDetectorsMsaAA1(csvDfMsaAA1: string) {
+  const dfMsaAA1: DG.DataFrame = DG.DataFrame.fromCsv(csvDfMsaAA1);
+  await grok.data.detectSemanticTypes(dfMsaAA1);
+
+  const col: DG.Column = dfMsaAA1.col('seq')!;
+  expect(col.semType, mmSemType);
+  expect(col.getTag(DG.TAGS.UNITS), 'fasta:SEQ.MSA:PT');
+}
+
+export async function _testDetectorsSepNt(csv: string, separator: string) {
+  const df: DG.DataFrame = DG.DataFrame.fromCsv(csv);
+  await grok.data.detectSemanticTypes(df);
+
+  const col: DG.Column = df.col('seq')!;
+  expect(col.semType, mmSemType);
+  expect(col.getTag(DG.TAGS.UNITS), 'separator:SEQ:NT');
+  expect(col.getTag('separator'), separator);
+}
+
+export async function _testDetectorsSepPt(csv: string, separator: string) {
+  const df: DG.DataFrame = DG.DataFrame.fromCsv(csv);
+  await grok.data.detectSemanticTypes(df);
+
+  const col: DG.Column = df.col('seq')!;
+  expect(col.semType, mmSemType);
+  expect(col.getTag(DG.TAGS.UNITS), 'separator:SEQ:PT');
+  expect(col.getTag('separator'), separator);
+}
+
+export async function _testDetectorsSepUn(csv: string, separator: string) {
+  const df: DG.DataFrame = DG.DataFrame.fromCsv(csv);
+  await grok.data.detectSemanticTypes(df);
+
+  const col: DG.Column = df.col('seq')!;
+  expect(col.semType, mmSemType);
+  expect(col.getTag(DG.TAGS.UNITS), 'separator:SEQ:UN');
+  expect(col.getTag('separator'), separator);
+}
+
+export async function _testDetectorsSepMsaN1(csvDfSepMsaN1: string) {
+  const dfSepMsaN1: DG.DataFrame = DG.DataFrame.fromCsv(csvDfSepMsaN1);
+  await grok.data.detectSemanticTypes(dfSepMsaN1);
+
+  const col: DG.Column = dfSepMsaN1.col('seq')!;
+  expect(col.semType, mmSemType);
+  expect(col.getTag(DG.TAGS.UNITS), 'separator:SEQ.MSA:NT');
+}
+
+export async function _testDetectorsSamplesFastaCsvPt() {
+  const csv: string = await grok.dapi.files.readAsText('System:AppData/Bio/samples/sample_FASTA.csv');
+  const df: DG.DataFrame = DG.DataFrame.fromCsv(csv);
+  await grok.data.detectSemanticTypes(df);
+
+  const col: DG.Column = df.col('sequence')!;
+  expect(col.semType, mmSemType);
+  expect(col.getTag(DG.TAGS.UNITS), 'fasta:SEQ:PT');
+  expect(col.getTag('separator'), null);
+}
+
+export async function _testDetectorsSamplesFastaFastaPt() {
+  const fasta: string = await grok.dapi.files.readAsText('System:AppData/Bio/samples/sample_FASTA.fasta');
+  const df: DG.DataFrame = importFasta(fasta)[0];
+
+  const col: DG.Column = df.col('sequence')!;
+  expect(col.semType, mmSemType);
+  expect(col.getTag(DG.TAGS.UNITS), 'fasta:SEQ:PT');
+  expect(col.getTag('separator'), null);
+}

package/src/tests/msa-tests.ts

@@ -0,0 +1,34 @@
+import {category, test} from '@datagrok-libraries/utils/src/test';
+import {
+  _testMSAIsCorrect,
+  _testTableIsNotEmpty,
+} from './utils';
+
+import * as DG from 'datagrok-api/dg';
+//import * as grok from 'datagrok-api/grok';
+
+export const _package = new DG.Package();
+
+
+category('MSA', async () => {
+  //table = await grok.data.files.openTable('Demo:Files/bio/peptides.csv');
+  const fromCsv = `seq
+  FWRWYVKHP
+  YNRWYVKHP
+  MWRSWYCKHP`;
+  const toCsv = `seq
+  -F-W-R--W-Y-V-K-H-P
+  -Y-N-R--W-Y-V-K-H-P
+  -M-W-R-S-W-Y-C-K-H-P`;
+  const table: DG.DataFrame = DG.DataFrame.fromCsv(fromCsv);
+  const toTable: DG.DataFrame = DG.DataFrame.fromCsv(toCsv);
+  const alignedSequencesColumn = toTable.getCol('seq');
+
+  test('test_table.is_not_empty', async () => {
+    await _testTableIsNotEmpty(table);
+  });
+
+  test('is_correct', async () => {
+    await _testMSAIsCorrect(alignedSequencesColumn);
+  });
+});

package/src/tests/utils.ts

@@ -0,0 +1,26 @@
+import * as DG from 'datagrok-api/dg';
+
+import {expect} from '@datagrok-libraries/utils/src/test';
+import {runKalign} from '../utils/multiple-sequence-alignment';
+
+/**
+ * Tests if a table has non zero rows and columns.
+ *
+ * @param {DG.DataFrame} table Target table.
+ */
+export function _testTableIsNotEmpty(table: DG.DataFrame): void {
+  expect(table.columns.length > 0 && table.rowCount > 0, true);
+}
+
+
+/**
+ * Tests if MSA works and returns consistent result.
+ *
+ * @export
+ * @param {DG.Column} col Aligned sequences column.
+ */
+export async function _testMSAIsCorrect(col: DG.Column): Promise<void> {
+  const msaCol = await runKalign(col, true);
+  expect(msaCol.toList().every((v, i) => (v == col.get(i) || v == null)), true);
+
+}

package/src/utils/constants.ts

@@ -0,0 +1,62 @@
+export enum COLUMNS_NAMES {
+  SPLIT_COL = '~split',
+  ACTIVITY = '~activity',
+  ACTIVITY_SCALED = 'activity_scaled',
+  ALIGNED_SEQUENCE = '~aligned_sequence',
+  AMINO_ACID_RESIDUE = 'AAR',
+  POSITION = 'Pos',
+  P_VALUE = 'pValue',
+  MEAN_DIFFERENCE = 'Mean difference',
+}
+
+export enum CATEGORIES {
+  OTHER = 'Other',
+  ALL = 'All',
+}
+
+export enum TAGS {
+  AAR = 'AAR',
+  POSITION = 'Pos',
+  SEPARATOR = 'monomer-separator',
+  SELECTION = 'selection',
+}
+
+export enum SEM_TYPES {
+  AMINO_ACIDS = 'aminoAcids',
+  ALIGNED_SEQUENCE = 'alignedSequence',
+  ALIGNED_SEQUENCE_DIFFERENCE = 'alignedSequenceDifference',
+  ACTIVITY = 'activity',
+  ACTIVITY_SCALED = 'activityScaled',
+  Macro_Molecule = 'Macromolecule',
+}
+
+export const STATS = 'stats';
+
+export const EMBEDDING_STATUS = 'embeddingStatus';
+
+export const PEPTIDES_ANALYSIS = 'isPeptidesAnalysis';
+
+export enum FLAGS {
+  CELL_CHANGING = 'isCellChanging',
+}
+
+export const aarGroups = {
+  'R': 'PC', 'H': 'PC', 'K': 'PC',
+  'D': 'NC', 'E': 'NC',
+  'S': 'U', 'T': 'U', 'N': 'U', 'Q': 'U',
+  'C': 'SC', 'U': 'SC', 'G': 'SC', 'P': 'SC',
+  'A': 'H', 'V': 'H', 'I': 'H', 'L': 'H', 'M': 'H', 'F': 'H', 'Y': 'H', 'W': 'H',
+  '-': '-',
+};
+
+export const groupDescription: {[key: string]: {'description': string, aminoAcids: string[]}} = {
+  'PC': {'description': 'Positive Amino Acids, with Electrically Charged Side Chains', 'aminoAcids': ['R', 'H', 'K']},
+  'NC': {'description': 'Negative Amino Acids, with Electrically Charged Side Chains', 'aminoAcids': ['D', 'E']},
+  'U': {'description': 'Amino Acids with Polar Uncharged Side Chains', 'aminoAcids': ['S', 'T', 'N', 'Q']},
+  'SC': {'description': 'Special Cases', 'aminoAcids': ['C', 'U', 'G', 'P']},
+  'H': {
+    'description': 'Amino Acids with Hydrophobic Side Chain',
+    'aminoAcids': ['A', 'V', 'I', 'L', 'M', 'F', 'Y', 'W'],
+  },
+  '-': {'description': 'Unknown Amino Acid', 'aminoAcids': ['-']},
+};