@datagrok/proteomics 1.0.0

package/scripts/number_antibody_anarci.py

@@ -0,0 +1,200 @@
+#name: Number Antibody Sequences (ANARCI)
+#description: [Legacy] Assigns antibody numbering (IMGT/Kabat/Chothia/AHo) using ANARCI directly
+#language: python
+#environment: channels: [conda-forge, bioconda, defaults], dependencies: [python=3.9, pip, hmmer=3.3.2, anarci]
+#input: dataframe df
+#input: column seqCol {semType: Macromolecule}
+#input: string scheme {choices: ["imgt", "kabat", "chothia", "aho"]} [Numbering scheme]
+#output: dataframe result
+
+import json
+import pandas as pd
+
+try:
+    from anarci import anarci, number
+except ImportError:
+    raise ImportError(
+        'ANARCI is not installed. Please install it with:\n'
+        '  conda install -c bioconda anarci hmmer\n'
+        'or:\n'
+        '  pip install anarci\n'
+        'HMMER must also be available on PATH.'
+    )
+
+# IMGT region boundaries (used for all schemes after numbering)
+IMGT_REGIONS = {
+    'Heavy': [
+        ('FR1', 1, 26), ('CDR1', 27, 38), ('FR2', 39, 55),
+        ('CDR2', 56, 65), ('FR3', 66, 104), ('CDR3', 105, 117), ('FR4', 118, 128),
+    ],
+    'Light': [
+        ('FR1', 1, 26), ('CDR1', 27, 38), ('FR2', 39, 55),
+        ('CDR2', 56, 65), ('FR3', 66, 104), ('CDR3', 105, 117), ('FR4', 118, 127),
+    ],
+}
+
+KABAT_REGIONS = {
+    'Heavy': [
+        ('FR1', 1, 30), ('CDR1', 31, 35), ('FR2', 36, 49),
+        ('CDR2', 50, 65), ('FR3', 66, 94), ('CDR3', 95, 102), ('FR4', 103, 113),
+    ],
+    'Light': [
+        ('FR1', 1, 23), ('CDR1', 24, 34), ('FR2', 35, 49),
+        ('CDR2', 50, 56), ('FR3', 57, 88), ('CDR3', 89, 97), ('FR4', 98, 107),
+    ],
+}
+
+CHOTHIA_REGIONS = {
+    'Heavy': [
+        ('FR1', 1, 25), ('CDR1', 26, 32), ('FR2', 33, 51),
+        ('CDR2', 52, 56), ('FR3', 57, 94), ('CDR3', 95, 102), ('FR4', 103, 113),
+    ],
+    'Light': [
+        ('FR1', 1, 25), ('CDR1', 26, 32), ('FR2', 33, 49),
+        ('CDR2', 50, 52), ('FR3', 53, 90), ('CDR3', 91, 96), ('FR4', 97, 107),
+    ],
+}
+
+AHO_REGIONS = {
+    'Heavy': [
+        ('FR1', 1, 24), ('CDR1', 25, 40), ('FR2', 41, 55),
+        ('CDR2', 56, 78), ('FR3', 79, 108), ('CDR3', 109, 138), ('FR4', 139, 149),
+    ],
+    'Light': [
+        ('FR1', 1, 24), ('CDR1', 25, 40), ('FR2', 41, 55),
+        ('CDR2', 56, 78), ('FR3', 79, 108), ('CDR3', 109, 138), ('FR4', 139, 149),
+    ],
+}
+
+SCHEME_REGIONS = {
+    'imgt': IMGT_REGIONS,
+    'kabat': KABAT_REGIONS,
+    'chothia': CHOTHIA_REGIONS,
+    'aho': AHO_REGIONS,
+}
+
+
+def extract_sequence(raw_seq):
+    """Extract single-letter amino acid sequence from various formats."""
+    if not raw_seq or not isinstance(raw_seq, str):
+        return ''
+    s = raw_seq.strip()
+    # If it looks like FASTA single-letter (only AA chars and gaps)
+    s = s.replace('-', '').replace('.', '')
+    # Filter to valid amino acid characters
+    valid = set('ACDEFGHIKLMNPQRSTVWY')
+    return ''.join(c for c in s.upper() if c in valid)
+
+
+def number_sequences(sequences, scheme_name):
+    """Number a list of sequences using ANARCI."""
+    # Prepare input for ANARCI
+    seq_list = [(f'seq_{i}', seq) for i, seq in enumerate(sequences) if seq]
+
+    if not seq_list:
+        return [], [], []
+
+    # Run ANARCI
+    numbered_seqs, alignment_details, hit_tables = anarci(
+        seq_list,
+        scheme=scheme_name,
+        output=False,
+        allow=set(['H', 'K', 'L']),
+    )
+
+    return numbered_seqs, alignment_details, hit_tables
+
+
+# Extract sequences from the input column
+col_name = seqCol
+sequences = []
+for i in range(df.shape[0]):
+    raw = df[col_name].iloc[i]
+    sequences.append(extract_sequence(str(raw) if raw is not None else ''))
+
+# Number all sequences
+numbered_seqs, alignment_details, hit_tables = number_sequences(sequences, scheme)
+
+# Process results
+position_names_list = []
+chain_types = []
+region_annotations_list = []
+numbering_results = []
+
+regions_def = SCHEME_REGIONS.get(scheme, IMGT_REGIONS)
+
+for idx in range(len(sequences)):
+    if numbered_seqs[idx] is None or len(numbered_seqs[idx]) == 0:
+        position_names_list.append('')
+        chain_types.append('')
+        region_annotations_list.append('[]')
+        numbering_results.append('')
+        continue
+
+    # Get the best hit (first domain)
+    numbering = numbered_seqs[idx][0]
+    chain_info = alignment_details[idx][0]
+
+    if numbering is None or chain_info is None:
+        position_names_list.append('')
+        chain_types.append('')
+        region_annotations_list.append('[]')
+        numbering_results.append('')
+        continue
+
+    # Extract chain type
+    chain_type_code = chain_info['chain_type']
+    if chain_type_code == 'H':
+        chain_type = 'Heavy'
+    elif chain_type_code in ('K', 'L'):
+        chain_type = 'Light'
+    else:
+        chain_type = 'Unknown'
+
+    # Build position names from numbering
+    pos_names = []
+    for (pos_num, insertion_code), aa in numbering:
+        if aa != '-':
+            pos_name = str(pos_num)
+            if insertion_code != ' ':
+                pos_name += insertion_code
+            pos_names.append(pos_name)
+
+    position_names_list.append(', '.join(pos_names))
+    chain_types.append(chain_type)
+
+    # Build region annotations
+    chain_key = chain_type if chain_type in regions_def else 'Heavy'
+    region_defs = regions_def.get(chain_key, [])
+    annotations = []
+    for region_name, start, end in region_defs:
+        region_type = 'CDR' if 'CDR' in region_name else 'FR'
+        annotations.append({
+            'id': f'{scheme}-{chain_type}-{region_name}'.lower(),
+            'name': region_name,
+            'description': f'{region_name} ({scheme.upper()} {start}-{end})',
+            'start': str(start),
+            'end': str(end),
+            'visualType': 'region',
+            'category': 'structure',
+            'sourceScheme': scheme.upper(),
+            'autoGenerated': True,
+        })
+
+    region_annotations_list.append(json.dumps(annotations))
+
+    # Full numbering as JSON for debugging/reference
+    numbering_json = json.dumps([
+        {'position': f'{pos_num}{insertion_code.strip()}', 'aa': aa}
+        for (pos_num, insertion_code), aa in numbering
+        if aa != '-'
+    ])
+    numbering_results.append(numbering_json)
+
+# Build result DataFrame
+result = pd.DataFrame({
+    'position_names': position_names_list,
+    'chain_type': chain_types,
+    'annotations_json': region_annotations_list,
+    'numbering_detail': numbering_results,
+})

package/src/package-api.ts

@@ -0,0 +1,37 @@
+/**
+This file is auto-generated by the grok api command.
+If you notice any changes, please push them to the repository.
+Do not edit this file manually.
+*/
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+
+
+export namespace scripts {
+  /**
+  [Legacy] Assigns antibody numbering (IMGT/Kabat/Chothia/AHo) using AbNumber
+  */
+  export async function numberAntibodySequencesAbNumber(df: DG.DataFrame , seqCol: DG.Column , scheme: string ): Promise<DG.DataFrame> {
+    return await grok.functions.call('Proteomics:NumberAntibodySequencesAbNumber', { df, seqCol, scheme });
+  }
+
+  /**
+  [Legacy] Assigns antibody numbering (IMGT/Kabat/Chothia/AHo) using ANARCI directly
+  */
+  export async function numberAntibodySequencesANARCI(df: DG.DataFrame , seqCol: DG.Column , scheme: string ): Promise<DG.DataFrame> {
+    return await grok.functions.call('Proteomics:NumberAntibodySequencesANARCI', { df, seqCol, scheme });
+  }
+
+  /**
+  Assigns antibody numbering (IMGT/Kabat/Chothia/AHo) using AntPack
+  */
+  export async function antpackAntibodyNumbering(df: DG.DataFrame , seqCol: DG.Column , scheme: string ): Promise<DG.DataFrame> {
+    return await grok.functions.call('Proteomics:AntpackAntibodyNumbering', { df, seqCol, scheme });
+  }
+}
+
+export namespace funcs {
+  export async function info(): Promise<void> {
+    return await grok.functions.call('Proteomics:Info', {});
+  }
+}

package/src/package-test.ts

@@ -0,0 +1,20 @@
+import { runTests, tests, TestContext , initAutoTests as initTests } from '@datagrok-libraries/test/src/test';
+import * as DG from 'datagrok-api/dg';
+
+export let _package = new DG.Package();
+export { tests };
+
+//name: test
+//input: string category {optional: true}
+//input: string test {optional: true}
+//input: object testContext {optional: true}
+//output: dataframe result
+export async function test(category: string, test: string, testContext: TestContext): Promise<DG.DataFrame> {
+  const data = await runTests({ category, test, testContext });
+  return DG.DataFrame.fromObjects(data)!;
+}
+
+//name: initAutoTests
+export async function initAutoTests() {
+  await initTests(_package, _package.getModule('package-test.js'));
+}

package/src/package.g.ts

@@ -0,0 +1 @@
+import * as DG from 'datagrok-api/dg';

package/src/package.ts

@@ -0,0 +1,17 @@
+/* eslint-disable max-len */
+/* Do not change these import lines to match external modules in webpack configuration */
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+export * from './package.g';
+
+export const _package = new DG.Package();
+
+//name: info
+export function info() {
+  grok.shell.info(_package.webRoot);
+}
+
+export class PackageFunctions {
+  
+}

package/tsconfig.json

@@ -0,0 +1,71 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig.json to read more about this file */
+
+    /* Basic Options */
+    // "incremental": true,                         /* Enable incremental compilation */
+    "target": "es6",                                /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */
+    "module": "es2020",                             /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */
+    "lib": ["ES2022", "dom"],                       /* Specify library files to be included in the compilation. */
+    // "allowJs": true,                             /* Allow javascript files to be compiled. */
+    // "checkJs": true,                             /* Report errors in .js files. */
+    // "jsx": "preserve",                           /* Specify JSX code generation: 'preserve', 'react-native', 'react', 'react-jsx' or 'react-jsxdev'. */
+    // "declaration": true,                         /* Generates corresponding '.d.ts' file. */
+    // "declarationMap": true,                      /* Generates a sourcemap for each corresponding '.d.ts' file. */
+    "sourceMap": true,                              /* Generates corresponding '.map' file. */
+    // "outFile": "./",                             /* Concatenate and emit output to single file. */
+    // "outDir": "./",                              /* Redirect output structure to the directory. */
+    // "rootDir": "./",                             /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
+    // "composite": true,                           /* Enable project compilation */
+    // "tsBuildInfoFile": "./",                     /* Specify file to store incremental compilation information */
+    // "removeComments": true,                      /* Do not emit comments to output. */
+    // "noEmit": true,                              /* Do not emit outputs. */
+    // "importHelpers": true,                       /* Import emit helpers from 'tslib'. */
+    // "downlevelIteration": true,                  /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
+    // "isolatedModules": true,                     /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
+
+    /* Strict Type-Checking Options */
+    "strict": true,                                 /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                       /* Raise error on expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,                    /* Enable strict null checks. */
+    // "strictFunctionTypes": true,                 /* Enable strict checking of function types. */
+    // "strictBindCallApply": true,                 /* Enable strict 'bind', 'call', and 'apply' methods on functions. */
+    // "strictPropertyInitialization": true,        /* Enable strict checking of property initialization in classes. */
+    // "noImplicitThis": true,                      /* Raise error on 'this' expressions with an implied 'any' type. */
+    // "alwaysStrict": true,                        /* Parse in strict mode and emit "use strict" for each source file. */
+
+    /* Additional Checks */
+    // "noUnusedLocals": true,                      /* Report errors on unused locals. */
+    // "noUnusedParameters": true,                  /* Report errors on unused parameters. */
+    // "noImplicitReturns": true,                   /* Report error when not all code paths in function return a value. */
+    // "noFallthroughCasesInSwitch": true,          /* Report errors for fallthrough cases in switch statement. */
+    // "noUncheckedIndexedAccess": true,            /* Include 'undefined' in index signature results */
+    // "noPropertyAccessFromIndexSignature": true,  /* Require undeclared properties from index signatures to use element accesses. */
+
+    /* Module Resolution Options */
+    "moduleResolution": "node",                     /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
+    // "baseUrl": "./",                             /* Base directory to resolve non-absolute module names. */
+    // "paths": {},                                 /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
+    // "rootDirs": [],                              /* List of root folders whose combined content represents the structure of the project at runtime. */
+    // "typeRoots": [],                             /* List of folders to include type definitions from. */
+    // "types": [],                                 /* Type declaration files to be included in compilation. */
+    // "allowSyntheticDefaultImports": true,        /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
+    "esModuleInterop": true,                        /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
+    // "preserveSymlinks": true,                    /* Do not resolve the real path of symlinks. */
+    // "allowUmdGlobalAccess": true,                /* Allow accessing UMD globals from modules. */
+
+    /* Source Map Options */
+    // "sourceRoot": "",                            /* Specify the location where debugger should locate TypeScript files instead of source locations. */
+    // "mapRoot": "",                               /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSourceMap": true,                     /* Emit a single file with source maps instead of having a separate file. */
+    // "inlineSources": true,                       /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
+
+    /* Experimental Options */
+    "experimentalDecorators": true,                 /* Enables experimental support for ES7 decorators. */
+    "emitDecoratorMetadata": true,                  /* Enables experimental support for emitting type metadata for decorators. */
+
+    /* Advanced Options */
+    "skipLibCheck": true,                          /* Skip type checking of declaration files. */
+    "forceConsistentCasingInFileNames": true,        /* Disallow inconsistently-cased references to the same file. */
+  }
+}

package/webpack.config.js

@@ -0,0 +1,45 @@
+const path = require('path');
+const FuncGeneratorPlugin = require('datagrok-tools/plugins/func-gen-plugin');
+const packageName = path.parse(require('./package.json').name).name.toLowerCase().replace(/-/g, '');
+
+module.exports = {
+  cache: {
+    type: 'filesystem',
+  },
+  mode: 'development',
+  entry: {
+    test: {filename: 'package-test.js', library: {type: 'var', name: `${packageName}_test`}, import: './src/package-test.ts'},
+    package: './src/package.ts',
+  },
+  resolve: {
+    extensions: ['.wasm', '.mjs', '.ts', '.json', '.js', '.tsx'],
+  },
+  module: {
+    rules: [
+      {test: /\.tsx?$/, loader: 'ts-loader', options: {allowTsInNodeModules: true}},
+    ],
+  },
+  plugins: [
+    new FuncGeneratorPlugin({outputPath: './src/package.g.ts'}),
+  ],
+  devtool: 'source-map',
+  externals: {
+    'datagrok-api/dg': 'DG',
+    'datagrok-api/grok': 'grok',
+    'datagrok-api/ui': 'ui',
+    'openchemlib/full.js': 'OCL',
+    'rxjs': 'rxjs',
+    'rxjs/operators': 'rxjs.operators',
+    'cash-dom': '$',
+    'dayjs': 'dayjs',
+    'wu': 'wu',
+    'exceljs': 'ExcelJS',
+    'html2canvas': 'html2canvas',
+  },
+  output: {
+    filename: '[name].js',
+    library: packageName,
+    libraryTarget: 'var',
+    path: path.resolve(__dirname, 'dist'),
+  },
+};