Update

abnumber/__init__.py

@@ -0,0 +1,6 @@
+from abnumber.__version__ import __version__
+from abnumber.chain import Chain
+from abnumber.position import Position, sort_positions
+from abnumber.alignment import Alignment
+from abnumber.common import SUPPORTED_SCHEMES, SUPPORTED_CDR_DEFINITIONS
+from abnumber.exceptions import ChainParseError

abnumber/__version__.py

@@ -0,0 +1 @@
+__version__ = '0.3.0'

abnumber/alignment.py

@@ -0,0 +1,195 @@
+from typing import Union
+
+from abnumber.common import is_similar_residue, is_integer
+from abnumber.position import Position
+
+
+class Alignment:
+    """Antibody chain alignment of two or more chains
+
+    >>> from abnumber import Chain
+    >>>
+    >>> seq1 = 'QVQLQQSGAELARPGASVKMSCKASGYTFTRYTMHWVKQRPGQGLEWIGYINPSRGYTNYNQKFKDKATLTTDKSSSTAYMQLSSLTSEDSAVYYCARYYDDHYCLDYWGQGTTLTVSSAKTTAP'
+    >>> chain1 = Chain(seq1, scheme='imgt')
+    >>>
+    >>> seq2 = 'QVQLVQSGAELDRPGATVKMSCKASGYTTTRYTMHWVKQRPGQGLDWIGYINPSDRSYTNYNQKFKDKATLTTDKSSSTAYMQKTSLTSEDSAVYYCARYYDDYLDRWGQGTTLTVSSAKTTAP'
+    >>> chain2 = Chain(seq2, scheme='imgt')
+    >>> alignment = chain1.align(chain2)
+
+    Alignment can be sliced and iterated:
+
+    >>> for pos, (aa, bb) in alignment[:'5']:
+    >>>     print(pos, aa, bb)
+    H1  Q Q
+    H2  V V
+    H3  Q Q
+    H4  L L
+    H5  Q V
+    ...
+
+    """
+    def __init__(self, positions, residues, scheme, chain_type):
+        assert isinstance(positions, list), 'Expected list of positions and residues. ' \
+                                            'Use chain.align(other) to create an alignment.'
+        assert len(positions) == len(residues)
+        unique_cdr_definitions = set(pos.cdr_definition for pos in positions)
+        assert len(unique_cdr_definitions) <= 1, f'Aligned chains should use the same CDR definitions, got: {unique_cdr_definitions}'
+        self.positions = positions
+        self.residues = residues
+        self.scheme = scheme
+        self.chain_type = chain_type
+        self._zipped = list(zip(self.positions, self.residues))
+
+    def __repr__(self):
+        return self.format()
+
+    def __iter__(self):
+        yield from self._zipped.__iter__()
+
+    def __len__(self):
+        return len(self.positions)
+
+    def __getitem__(self, item):
+        if isinstance(item, slice):
+            if item.step is not None and item.step != 1:
+                raise IndexError(f'Slicing with step != 1 is not implemented, got: {item}')
+            return self.slice(start=item.start, stop=item.stop)
+        pos = self._parse_position(item)
+        raw_pos = self.positions.index(pos)
+        return self.residues[raw_pos]
+
+    def slice(self, start: Union[str, int, 'Position'] = None, stop: Union[str, int, 'Position'] = None,
+              stop_inclusive: bool = True, allow_raw: bool = False):
+        """Create a slice of this alignment
+
+        You can also slice directly using ``alignment['111':'112A']`` or ``alignment.raw[10:20]``.
+
+        :param start: Slice start position (inclusive), :class:`Position` or string (e.g. '111A')
+        :param stop: Slice stop position (inclusive), :class:`Position` or string (e.g. '112A')
+        :param stop_inclusive: Include stop position in slice
+        :param allow_raw: Allow unaligned numeric indexing from 0 to length of sequence - 1
+        :return: new sliced Alignment object
+        """
+
+        start = self._parse_position(start, allow_raw=allow_raw) if start is not None else None
+        stop = self._parse_position(stop, allow_raw=allow_raw) if stop is not None else None
+
+        new_positions = []
+        new_residues = []
+        for pos, residues in zip(self.positions, self.residues):
+            if start is not None and pos < start:
+                continue
+            if stop is not None and (pos > stop or (not stop_inclusive and pos >= stop)):
+                break
+            new_positions.append(pos)
+            new_residues.append(residues)
+
+        return Alignment(positions=new_positions, residues=new_residues, scheme=self.scheme, chain_type=self.chain_type)
+
+    def _parse_position(self, position: Union[int, str, 'Position'], allow_raw=False):
+        """Create :class:`Position` key object from string or int.
+
+        Note: The position should only be used for indexing, CDR definition is not preserved!
+
+        :param position: Numeric or string position representation
+        :param allow_raw: Also allow unaligned numeric (int) indexing from 0 to length of sequence - 1
+        :return: new Position object, should only be used for indexing, CDR definition is not preserved!
+        """
+        if isinstance(position, str):
+            return Position.from_string(position, chain_type=self.chain_type, scheme=self.scheme)
+        if isinstance(position, Position):
+            return position
+        try:
+            position = int(position)
+        except TypeError:
+            raise IndexError(f'Invalid position key, expected Position, string or integer, got {type(position)}: "{position}"')
+        if not allow_raw:
+            raise IndexError("Use chain.raw[i] for raw numeric indexing or pass allow_raw=True. "
+                             "For named position indexing, use string (e.g. chain['111A'] or chain['H111A'])")
+        if position >= len(self.positions):
+            return None
+        return self.positions[position]
+
+    def format(self, mark_identity=True, mark_cdrs=True):
+        """Format alignment to string
+
+        :param mark_identity: Add BLAST style middle line showing identity (``|``), similar residue (``+``) or different residue (``.``)
+        :param mark_cdrs: Add line highlighting CDR regions using ``^``
+        :return: formatted string
+        """
+
+        def _identity_symbol(a, b):
+            return '|' if a == b else ('+' if is_similar_residue(a, b) else '.')
+
+        lines = []
+        for i in range(len(self.residues[0])):
+            if mark_identity and i != 0:
+                lines.append(''.join(_identity_symbol(aas[i], aas[i-1]) for pos, aas in self))
+            lines.append(''.join(aas[i] for pos, aas in self))
+        if mark_cdrs:
+            if self.positions[0].cdr_definition == 'kabat':
+                lines.append(''.join('^' if pos.is_in_cdr() else ("°" if pos.is_in_vernier() else ' ') for pos in self.positions))
+            else:
+                lines.append(''.join('^' if pos.is_in_cdr() else ' ' for pos in self.positions))
+        return '\n'.join(lines)
+
+    def print(self, mark_identity=True, mark_cdrs=True):
+        """Print string representation of alignment created using :meth:`Alignment.format`
+
+        >>> alignment.print()
+        QVQLQQSGAELARPGASVKMSCKASGYTFTRYTMHWVKQRPGQGLEWIGYINPS-RGYTNYNQKFKDKATLTTDKSSSTAYMQLSSLTSEDSAVYYCARYYDDHYCLDYWGQGTTLTVSS
+        ||||.||||||.||||+|||||||||||.||||||||||||||||+||||||||.|.||||||||||||||||||||||||||.+|||||||||||||||||....||.|||||||||||
+        QVQLVQSGAELDRPGATVKMSCKASGYTTTRYTMHWVKQRPGQGLDWIGYINPSDRSYTNYNQKFKDKATLTTDKSSSTAYMQKTSLTSEDSAVYYCARYYD--DYLDRWGQGTTLTVSS
+                                 ^^^^^^^^                 ^^^^^^^^^                                      ^^^^^^^^^^^^
+        >>> alignment.print(mark_identity=False, mark_cdrs=False)
+        QVQLQQSGAELARPGASVKMSCKASGYTFTRYTMHWVKQRPGQGLEWIGYINPS-RGYTNYNQKFKDKATLTTDKSSSTAYMQLSSLTSEDSAVYYCARYYDDHYCLDYWGQGTTLTVSS
+        QVQLVQSGAELDRPGATVKMSCKASGYTTTRYTMHWVKQRPGQGLDWIGYINPSDRSYTNYNQKFKDKATLTTDKSSSTAYMQKTSLTSEDSAVYYCARYYD--DYLDRWGQGTTLTVSS
+
+        :param mark_identity: Add BLAST style middle line showing identity (``|``), similar residue (``+``) or different residue (``.``)
+        :param mark_cdrs: Add line highlighting CDR regions using ``^``
+        """
+        print(self.format(mark_identity=mark_identity, mark_cdrs=mark_cdrs))
+
+    def has_mutation(self):
+        """Check if there is a mutation in the alignment or not"""
+        return any(len(set(aas)) != 1 for aas in self.residues)
+
+    def num_mutations(self):
+        """Get number of mutations (positions with more than one type of residue)"""
+        return sum(len(set(aas)) != 1 for aas in self.residues)
+
+    @property
+    def raw(self):
+        """Access raw representation of this alignment to allow unaligned numeric indexing and slicing
+
+        >>> # Numbering of ``chain.raw`` starts at 0
+        >>> alignment.raw[0]
+        'H1'
+        >>> # Slicing with string is based on schema numbering, the end is inclusive
+        >>> chain['1':'10']
+        'QVQLQQSGAE'
+        >>> # Slicing with ``chain.raw`` starts at 0, the end is exclusive (Python style)
+        >>> chain.raw[0:10]
+        'QVQLQQSGAE'
+        :return: Raw alignment accessor that can be sliced or indexed to produce a new :class:`Alignment` object
+        """
+        return RawAlignmentAccessor(self)
+
+
+class RawAlignmentAccessor:
+    def __init__(self, alignment: Alignment):
+        self.alignment = alignment
+
+    def __getitem__(self, item):
+        if isinstance(item, slice):
+            if item.step is not None and item.step != 1:
+                raise IndexError(f'Slicing with step != 1 is not implemented, got: {item}')
+            if item.start is not None and not is_integer(item.start):
+                raise IndexError(f'Expected int start index for alignment.raw, got {type(item.start)}: {item.start}')
+            if item.stop is not None and not is_integer(item.stop):
+                raise IndexError(f'Expected int end index for alignment.raw, got {type(item.stop)}: {item.stop}')
+            return self.alignment.slice(start=item.start, stop=item.stop, stop_inclusive=False, allow_raw=True)
+        if not is_integer(item):
+            raise IndexError(f'Expected int indexing for alignment.raw, got {type(item)}: {item}')
+        pos = self.alignment.positions[item]
+        return self.alignment[pos]

abnumber/chain.py

@@ -0,0 +1,781 @@
+from collections import OrderedDict
+from typing import Union, List, Generator, Tuple
+from Bio import SeqIO
+from Bio.SeqRecord import SeqRecord
+import pandas as pd
+
+from abnumber.alignment import Alignment
+from abnumber.common import _anarci_align, _validate_chain_type, SUPPORTED_SCHEMES, SUPPORTED_CDR_DEFINITIONS, \
+    is_integer, SCHEME_BORDERS, _get_unique_chains
+from abnumber.exceptions import ChainParseError
+import numpy as np
+from Bio.Seq import Seq
+
+from abnumber.position import Position
+
+
+class Chain:
+    """
+    Antibody chain aligned to a chosen antibody numbering scheme
+
+    :example:
+
+    >>> from abnumber import Chain
+    >>>
+    >>> seq = 'QVQLQQSGAELARPGASVKMSCKASGYTFTRYTMHWVKQRPGQGLEWIGYINPSRGYTNYNQKFKDKATLTTDKSSSTAYMQLSSLTSEDSAVYYCARYYDDHYCLDYWGQGTTLTVSSAKTTAPSVYPLA'
+    >>> chain = Chain(seq, scheme='imgt')
+    >>> chain
+    QVQLQQSGAELARPGASVKMSCKASGYTFTRYTMHWVKQRPGQGLEWIGYINPSRGYTNYNQKFKDKATLTTDKSSSTAYMQLSSLTSEDSAVYYCARYYDDHYCLDYWGQGTTLTVSS
+                             ^^^^^^^^                 ^^^^^^^^                                      ^^^^^^^^^^^^
+
+    Chain can be iterated:
+
+    >>> for pos, aa in chain:
+    >>>     print(pos, aa)
+    H1  Q
+    H2  V
+    H3  Q
+    H4  L
+    H5  Q
+    ...
+
+    Chain can also be indexed and sliced using scheme numbering:
+
+    >>> chain['5']
+    'Q'
+    >>> for pos, aa in chain['H2':'H5']:
+    >>>     print(pos, aa)
+    H2  V
+    H3  Q
+    H4  L
+    H5  Q
+
+    :param sequence: Unaligned string sequence
+    :param name: Optional sequence identifier
+    :param scheme: Numbering scheme: One of ``imgt``, ``chothia``, ``kabat``, ``aho``
+    :param cdr_definition: Numbering scheme to be used for definition of CDR regions. Same as ``scheme`` by default.
+                           One of ``imgt``, ``chothia``, ``kabat``, ``north``. Required for ``aho``.
+    :param assign_germline: Assign germline name using ANARCI based on best sequence identity
+    :param allowed_species: Allowed species for germline assignment. Use ``None`` to allow all species, or one or more of: ``'human', 'mouse','rat','rabbit','rhesus','pig','alpaca'``
+    :param aa_dict: (Internal use only) Create Chain object directly from dictionary of region objects (internal use)
+    :param tail: (Internal use only) Constant region sequence
+    :param species: (Internal use only) Species as identified by ANARCI
+    :param germline: (Internal use only) Germline as identified by ANARCI
+    """
+
+    def __init__(self, sequence, scheme, cdr_definition=None, name=None, assign_germline=False, allowed_species=None, **kwargs):
+        aa_dict = kwargs.pop('aa_dict', None)
+        chain_type = kwargs.pop('chain_type', None)
+        tail = kwargs.pop('tail', None)
+        species = kwargs.pop('species', None)
+        v_gene = kwargs.pop('v_gene', None)
+        j_gene = kwargs.pop('j_gene', None)
+        if isinstance(allowed_species, str):
+            allowed_species = [allowed_species]
+        if len(kwargs):
+            raise TypeError(f'Argument not recognized: {", ".join(kwargs)}')
+        if aa_dict is not None:
+            if sequence is not None:
+                raise ChainParseError('Only one of aa_dict= and sequence= can be provided')
+            assert isinstance(aa_dict, dict), f'Expected dict, got: {type(aa_dict)}'
+            assert tail is not None
+            assert chain_type is not None
+        else:
+            if sequence is None:
+                raise ChainParseError('Expected sequence, got None')
+            if not isinstance(sequence, str) and not isinstance(sequence, Seq):
+                raise ChainParseError(f'Expected string or Seq, got {type(sequence)}: {sequence}')
+            if '-' in sequence:
+                raise ChainParseError(f'Please provide an unaligned sequence, got: {sequence}')
+            if chain_type is not None:
+                raise ChainParseError('Do not use chain_type= when providing sequence=, it will be inferred automatically')
+            if tail is not None:
+                raise ChainParseError('Do not use tail= when providing sequence=, it will be inferred automatically')
+            if isinstance(sequence, Seq):
+                sequence = str(sequence)
+            results = _anarci_align(sequence, scheme=scheme, allowed_species=allowed_species, assign_germline=assign_germline)
+            if len(results) > 1:
+                raise ChainParseError(f'Found {len(results)} antibody domains in sequence: "{sequence}"')
+            aa_dict, chain_type, tail, species, v_gene, j_gene = results[0]
+
+        _validate_chain_type(chain_type)
+
+        self.name: str = name
+        """User-provided sequence identifier"""
+        self.chain_type: str = chain_type
+        """Chain type as identified by ANARCI: ``H`` (heavy), ``K`` (kappa light) or ``L`` (lambda light)
+        
+        See also :meth:`Chain.is_heavy_chain` and :meth:`Chain.is_light_chain`.
+        """
+        self.scheme: str = scheme
+        """Numbering scheme used to align the sequence"""
+        self.cdr_definition: str = cdr_definition or scheme
+        """Numbering scheme to be used for definition of CDR regions (same as ``scheme`` by default)"""
+        self.tail: str = tail
+        """Constant region sequence"""
+        self.species: str = species
+        """Species as identified by ANARCI"""
+        self.v_gene: str = v_gene
+        """V gene germline as identified by ANARCI (if assign_germline is True)"""
+        self.j_gene: str = j_gene
+        """J gene germline as identified by ANARCI (if assign_germline is True)"""
+
+        self.fr1_dict = OrderedDict()
+        self.cdr1_dict = OrderedDict()
+        self.fr2_dict = OrderedDict()
+        self.cdr2_dict = OrderedDict()
+        self.fr3_dict = OrderedDict()
+        self.cdr3_dict = OrderedDict()
+        self.fr4_dict = OrderedDict()
+
+        self._init_from_dict(aa_dict, allowed_species=allowed_species)
+
+    def _init_from_dict(self, aa_dict, allowed_species):
+        if self.scheme not in SUPPORTED_SCHEMES:
+            raise NotImplementedError(f'Scheme "{self.scheme}" is not supported. Available schemes: {", ".join(SUPPORTED_SCHEMES)}')
+        if self.cdr_definition in ['aho']:
+            raise ValueError('CDR regions are not defined for AHo, '
+                             'you need to specify cdr_definition="chothia" or another scheme for CDR extraction.')
+        if self.cdr_definition not in SUPPORTED_CDR_DEFINITIONS:
+            raise NotImplementedError(f'CDR definition "{self.scheme}" is not supported. Available definitions: {", ".join(SUPPORTED_SCHEMES)}')
+        # list of region start positions
+        borders = SCHEME_BORDERS[self.cdr_definition] if self.cdr_definition in SCHEME_BORDERS else SCHEME_BORDERS[f'{self.cdr_definition}_{self.chain_type}']
+
+        regions_list = [self.fr1_dict, self.cdr1_dict, self.fr2_dict, self.cdr2_dict, self.fr3_dict, self.cdr3_dict, self.fr4_dict]
+        region_idx = 0
+
+        sorted_positions = sorted(aa_dict.keys())
+
+        cdr_definition_ready = True
+        for pos in sorted_positions:
+            assert pos.scheme == self.scheme, f'Schemes of provided position ({pos.scheme}) does not match Chain scheme ({self.scheme})'
+            if pos.cdr_definition != self.cdr_definition:
+                cdr_definition_ready = False
+
+        if cdr_definition_ready:
+            combined_aa_dict = aa_dict
+        else:
+            seq = ''.join(aa_dict[pos] for pos in sorted_positions)
+            renumbered_aa_dict = _anarci_align(
+                seq,
+                scheme=self.cdr_definition if self.cdr_definition != 'north' else 'chothia',
+                allowed_species=allowed_species
+            )[0][0]
+            cdr_definition_positions = [pos.number for pos in sorted(renumbered_aa_dict.keys())]
+            combined_aa_dict = {}
+            for orig_pos, cdr_definition_position in zip(sorted_positions, cdr_definition_positions):
+                aa = aa_dict[orig_pos]
+                pos = orig_pos.copy()
+                pos.set_cdr_definition(self.cdr_definition, cdr_definition_position)
+                combined_aa_dict[pos] = aa
+
+        for pos in sorted(combined_aa_dict.keys()):
+            assert isinstance(pos, Position), f'Expected Position object, got {type(pos)}: {pos}'
+            aa = combined_aa_dict[pos].upper().strip()
+            if aa in [None, '*', '-', '', '.']:
+                continue
+            while pos.cdr_definition_position >= borders[region_idx]:
+                region_idx += 1
+            regions_list[region_idx][pos] = aa
+
+    def __repr__(self):
+        return self.format()
+
+    def __str__(self):
+        return self.seq
+
+    def __iter__(self):
+        yield from self.positions.items().__iter__()
+
+    def __getitem__(self, item):
+        if isinstance(item, slice):
+            if item.step is not None and item.step != 1:
+                raise IndexError(f'Slicing with step != 1 is not implemented, got: {item}')
+            return self.slice(start=item.start, stop=item.stop)
+        pos = self._parse_position(item)
+        return self.positions[pos]
+
+    def __len__(self):
+        return len(self.positions)
+
+    def __hash__(self):
+        return hash(self.positions)
+
+    def __eq__(self, other):
+        """Check chain equality. Only checks scheme, aligned sequence and tail sequence, ignores name, metadata and CDR definitions."""
+        assert isinstance(other, Chain), f'Can only compare Chain to another Chain, got {type(other)}: {other}'
+        return self.positions == other.positions and self.tail == other.tail
+
+    @classmethod
+    def to_fasta(cls, chains, path_or_fd, keep_tail=False, description=''):
+        """Save multiple chains to FASTA"""
+        if isinstance(chains, Chain):
+            records = chains.to_seq_record(keep_tail=keep_tail, description=description)
+        else:
+            records = (chain.to_seq_record(keep_tail=keep_tail, description=description) for chain in chains)
+        return SeqIO.write(records, path_or_fd, 'fasta-2line')
+
+    @classmethod
+    def from_fasta(cls, path_or_handle, scheme, cdr_definition=None, as_series=False, as_generator=False, **kwargs) -> Union[List['Chain'], pd.Series, Generator['Chain', None, None]]:
+        """Read multiple chains from FASTA"""
+        generator = (cls(record.seq, name=record.name, scheme=scheme, cdr_definition=cdr_definition, **kwargs)
+                     for record in SeqIO.parse(path_or_handle, 'fasta'))
+        if as_generator:
+            return generator
+        chains = list(generator)
+        if as_series:
+            return pd.Series(chains, index=[c.name for c in chains])
+        return chains
+
+    def to_seq_record(self, keep_tail=False, description=''):
+        """Create BioPython SeqRecord object from this Chain"""
+        if not self.name:
+            raise ValueError('Name needs to be present to convert to a SeqRecord')
+        seq = Seq(self.seq + self.tail if keep_tail else self.seq)
+        return SeqRecord(seq, id=self.name, description=description)
+
+    @classmethod
+    def to_anarci_csv(cls, chains: List['Chain'], path):
+        """Save multiple chains to ANARCI-like CSV"""
+        df = cls.to_dataframe(chains)
+        df.to_csv(path)
+
+    @classmethod
+    def to_dataframe(cls, chains: List['Chain']):
+        """Produce a Pandas dataframe with aligned chain sequences in the columns
+
+        Note: Contains only positions (columns) that are present in the provided chains,
+        so number of columns can differ based on the input.
+        """
+        series_list = [chain.to_series() for chain in chains]
+
+        # Each chain can have a different set of positions
+        # so we need to sort the columns to make sure they are in the right order
+        # this is using the correct Position sorting
+        columns = set(c for series in series_list for c in series.index)
+        prop_columns = [c for c in columns if not isinstance(c, Position)]
+        position_columns = sorted([c for c in columns if isinstance(c, Position)])
+        # Columns can come from K and L chain, so we need to convert them to string and remove duplicates here
+        position_columns_str = pd.Series(
+            [pos.format(chain_type=False) for pos in position_columns]
+        ).drop_duplicates().to_list()
+
+        # Get full list of string columns
+        columns_str = prop_columns + position_columns_str
+
+        # Reindex each series using ordered list of string columns
+        series_list_ordered = []
+        for series in series_list:
+            series.index = series.index.map(lambda pos: pos.format(chain_type=False))
+            series_list_ordered.append(series.reindex(columns_str))
+
+        df = pd.DataFrame(series_list_ordered)[columns_str].fillna('-')
+        df.index.name = 'Id'
+
+        return df
+
+    def to_series(self):
+        props = {
+            'chain_type': self.chain_type,
+            'species': self.species
+        }
+        return pd.Series({**props, **self.positions}, name=self.name)
+
+    @classmethod
+    def from_series(cls, series, scheme, cdr_definition=None) -> 'Chain':
+        chain_type = series['chain_type']
+        species = series.get('species')
+        position_index = [c for c in series.index if c[:1].isnumeric()]
+        aa_dict = {Position.from_string(pos, chain_type=chain_type, scheme=scheme): aa
+                   for pos, aa in series[position_index].items() if aa != '-' and not pd.isna(aa)}
+        return cls(sequence=None, aa_dict=aa_dict, name=series.name, scheme=scheme, cdr_definition=cdr_definition,
+                   chain_type=chain_type, species=species, tail='')
+
+    @classmethod
+    def from_anarci_csv(cls, path, scheme, cdr_definition=None, as_series=False) -> Union[List['Chain'], pd.Series]:
+        df = pd.read_csv(path, index_col=0)
+        return cls.from_dataframe(df, scheme=scheme, cdr_definition=cdr_definition, as_series=as_series)
+
+    @classmethod
+    def from_dataframe(cls, df, scheme, cdr_definition=None, as_series=False) -> Union[List['Chain'], pd.Series]:
+        chains = [cls.from_series(series, scheme=scheme, cdr_definition=cdr_definition) for i, series in df.iterrows()]
+        if as_series:
+            return pd.Series(chains, index=[c.name for c in chains])
+        return chains
+
+    def format(self, method='wide', **kwargs):
+        """Format sequence to string
+
+        :param method: use ``"wide"`` for :meth:`Chain.format_wide` or ``"tall"`` for :meth:`Chain.format_tall()`
+        :return: formatted string
+        """
+        if method == 'wide':
+            return self.format_wide(**kwargs)
+        elif method == 'tall':
+            return self.format_tall(**kwargs)
+        raise ValueError(f'Use method="wide" or method="tall", unknown method: "{method}"')
+    
+    def print(self, method='wide', **kwargs):
+        """Print string representation using :meth:`Chain.format`
+
+        By default, produces "wide" format with sequence on first line and CDR regions higlighted with ``^`` on second line:
+
+        >>> chain.print()
+        QVQLQQSGAELARPGASVKMSCKASGYTFTRYTMHWVKQRPGQGLEWIGYINPSRGYTNYNQKFKDKATLTTDKSSSTAYMQLSSLTSEDSAVYYCARYYDDHYCLDYWGQGTTLTVSS
+                                 ^^^^^^^^                 ^^^^^^^^                                      ^^^^^^^^^^^^
+
+        :param method: use ``"wide"`` for :meth:`Chain.format_wide` or ``"tall"`` for :meth:`Chain.format_tall()`
+        """
+        print(self.format(method=method, **kwargs))
+
+    def format_tall(self, columns=5):
+        """Create string with one position per line, showing position numbers and amino acids
+
+        :return: formatted string
+        """
+        height = int(np.ceil(len(self) / columns))
+        rows = [''] * height
+        for column, start in enumerate(range(0, len(self), height)):
+            chain_slice = self.raw[start:start+height]
+            for row, (pos, aa) in enumerate(chain_slice):
+                rows[row] = rows[row].ljust(column * 15)
+                pos_format = (pos.get_region() + ' ' if pos.is_in_cdr() else '') + pos.format()
+                rows[row] += f'{pos_format.rjust(9)} {aa}'
+
+        return '\n'.join(rows)
+
+    def print_tall(self, columns=5):
+        """Print string representation using :meth:`Chain.format_tall`
+
+        >>> chain.print_tall()
+        FR1 H1    Q
+        FR1 H2    V
+        FR1 H3    Q
+        FR1 H4    L
+        FR1 H5    Q
+        FR1 H6    Q
+        FR1 H7    S
+        ...
+        """
+        print(self.format_tall(columns=columns))
+
+    def format_wide(self, numbering=False):
+        """Create string with sequence on first line and CDR regions higlighted with `^` on second line
+
+        :param numbering: Add position numbers on top
+        :return: formatted string
+        """
+        lines = []
+        if numbering:
+
+            first_order = ''
+            prev_number = None
+            after_double_digit = False
+            for pos in self.positions:
+                number = str(pos.number // 10)
+                if number != prev_number:
+                    if after_double_digit:
+                        # Special case: when double digits follow another double digits, do not print the first digit
+                        number = number[1:]
+                    first_order += number
+                    if len(number) > 1:
+                        after_double_digit = True
+                else:
+                    if after_double_digit:
+                        # Special case: After 10, 11, etc, skip adding the space
+                        after_double_digit = False
+                    else:
+                        first_order += ' '
+                prev_number = number
+
+            lines.append(first_order)
+            lines.append(''.join(str(pos.number % 10) for pos in self.positions))
+            letters = ''.join(pos.letter or ' ' for pos in self.positions)
+            if letters.strip():
+                lines.append(letters)
+        lines.append(self.seq)
+        if self.cdr_definition == 'kabat':
+            lines.append(''.join('^' if pos.is_in_cdr() else ("°" if pos.is_in_vernier() else ' ') for pos in self.positions))
+        else:
+            lines.append(''.join('^' if pos.is_in_cdr() else ' ' for pos in self.positions))
+        return '\n'.join(lines)
+
+    def print_wide(self, numbering=False):
+        """Print string representation using :meth:`Chain.format_wide`
+
+        >>> chain.print_wide()
+        QVQLQQSGAELARPGASVKMSCKASGYTFTRYTMHWVKQRPGQGLEWIGYINPSRGYTNYNQKFKDKATLTTDKSSSTAYMQLSSLTSEDSAVYYCARYYDDHYCLDYWGQGTTLTVSS
+                                 ^^^^^^^^                 ^^^^^^^^                                      ^^^^^^^^^^^^
+        """
+        print(self.format_wide(numbering=numbering))
+
+    def is_heavy_chain(self):
+        """Check if this chain is heavy chain (``chain_type=="H"``)"""
+        return self.chain_type == 'H'
+
+    def is_light_chain(self):
+        """Check if this chain is light chain (``chain_type=="K" or chain_type=="L"``)"""
+        return self.is_lambda_light_chain() or self.is_kappa_light_chain()
+
+    def is_lambda_light_chain(self):
+        """Check if this chain is lambda light chain (``chain_type=="L"``)"""
+        return self.chain_type == 'L'
+
+    def is_kappa_light_chain(self):
+        """Check if this chain is kappa light chain (``chain_type=="K"``)"""
+        return self.chain_type == 'K'
+
+    def align(self, *other) -> 'Alignment':
+        """Align this chain to other chains by using their existing numbering
+
+        >>> from abnumber import Chain
+        >>>
+        >>> seq1 = 'QVQLQQSGAELARPGASVKMSCKASGYTFTRYTMHWVKQRPGQGLEWIGYINPSRGYTNYNQKFKDKATLTTDKSSSTAYMQLSSLTSEDSAVYYCARYYDDHYCLDYWGQGTTLTVSSAKTTAP'
+        >>> chain1 = Chain(seq1, scheme='imgt')
+        >>>
+        >>> seq2 = 'QVQLVQSGAELDRPGATVKMSCKASGYTTTRYTMHWVKQRPGQGLDWIGYINPSDRSYTNYNQKFKDKATLTTDKSSSTAYMQKTSLTSEDSAVYYCARYYDDYLDRWGQGTTLTVSSAKTTAP'
+        >>> chain2 = Chain(seq2, scheme='imgt')
+        >>>
+        >>> alignment = chain1.align(chain2)
+        >>> print(alignment.format())
+        QVQLQQSGAELARPGASVKMSCKASGYTFTRYTMHWVKQRPGQGLEWIGYINPS-RGYTNYNQKFKDKATLTTDKSSSTAYMQLSSLTSEDSAVYYCARYYDDHYCLDYWGQGTTLTVSS
+        ||||.||||||.||||+|||||||||||.||||||||||||||||+||||||||.|.||||||||||||||||||||||||||.+|||||||||||||||||....||.|||||||||||
+        QVQLVQSGAELDRPGATVKMSCKASGYTTTRYTMHWVKQRPGQGLDWIGYINPSDRSYTNYNQKFKDKATLTTDKSSSTAYMQKTSLTSEDSAVYYCARYYD--DYLDRWGQGTTLTVSS
+                                 ^^^^^^^^                 ^^^^^^^^^                                      ^^^^^^^^^^^^
+
+        :param other: The :class:`Chain` object to align, can be repeated to create a multiple sequence alignment
+        :return: :class:`Alignment` object
+        """
+        pos_dicts = [self.positions]
+        for chain in other:
+            assert isinstance(chain, Chain), f'Expected Chain object, got {type(chain)}: {chain}'
+            pos_dicts.append(chain.positions)
+
+        unique_cdr_definitions = set(pos.cdr_definition for pos_dict in pos_dicts for pos in pos_dict.keys())
+        assert len(unique_cdr_definitions) <= 1, f'Aligned chains should use the same CDR definitions, got: {unique_cdr_definitions}'
+
+        shared_pos = sorted(set(pos for pos_dict in pos_dicts for pos in pos_dict.keys()))
+        residues = [tuple(pos_dict.get(pos, '-') for pos_dict in pos_dicts) for pos in shared_pos]
+        return Alignment(shared_pos, residues, chain_type=self.chain_type, scheme=self.scheme)
+
+    def clone(self, replace_seq: str = None):
+        """Create a copy of this chain, optionally with a replacement sequence
+        
+        :param replace_seq: Optional replacement sequence, needs to be the same length
+        :return: new Chain object
+        """
+        return self.slice(replace_seq=replace_seq)
+
+    def slice(self, replace_seq: str = None, start: Union[str, int, 'Position'] = None,
+              stop: Union[str, int, 'Position'] = None, stop_inclusive: bool = True, allow_raw: bool = False):
+        """Create a slice of this chain, optionally with a replacement sequence that is placed into the same numbering
+
+        You can also slice directly using ``chain['111':'112A']`` or ``chain.raw[10:20]``.
+
+        :param replace_seq: Optional replacement sequence, needs to be the same length
+        :param start: Optional slice start position (inclusive), :class:`Position` or string (e.g. '111A')
+        :param stop: Optional slice stop position (inclusive), :class:`Position` or string (e.g. '112A')
+        :param stop_inclusive: Include stop position in slice
+        :param allow_raw: Allow unaligned numeric indexing from 0 to length of sequence - 1
+        :return: new Chain object
+        """
+        aa_dict = {}
+        positions = self.positions
+        if replace_seq is not None:
+            assert len(replace_seq) == len(positions), 'Sequence needs to be the same length'
+
+        start = self._parse_position(start, allow_raw=allow_raw) if start is not None else None
+        stop = self._parse_position(stop, allow_raw=allow_raw) if stop is not None else None
+
+        for i, (pos, aa) in enumerate(positions.items()):
+            if start is not None and pos < start:
+                continue
+            if stop is not None and (pos > stop or (not stop_inclusive and pos >= stop)):
+                break
+            aa_dict[pos] = replace_seq[i] if replace_seq is not None else aa
+
+        return Chain(
+            sequence=None,
+            aa_dict=aa_dict,
+            name=self.name,
+            scheme=self.scheme,
+            chain_type=self.chain_type,
+            cdr_definition=self.cdr_definition,
+            tail=self.tail,
+            species=self.species,
+            v_gene=self.v_gene,
+            j_gene=self.j_gene
+        )
+
+    def renumber(self, scheme=None, cdr_definition=None, allowed_species=None):
+        """Return copy of this chain aligned using a different numbering scheme or CDR definition
+
+        :param scheme: Change numbering scheme: One of ``imgt``, ``chothia``, ``kabat``, ``aho``.
+        :param cdr_definition: Change CDR definition scheme: One of ``imgt``, ``chothia``, ``kabat``, ``north``.
+        :param allowed_species: ``None`` to allow all species, or one or more of: ``'human', 'mouse','rat','rabbit','rhesus','pig','alpaca'``
+        """
+
+        return Chain(
+            self.seq + self.tail,
+            name=self.name,
+            allowed_species=allowed_species,
+            scheme=scheme or self.scheme,
+            cdr_definition=cdr_definition or scheme or self.cdr_definition,
+            assign_germline=self.v_gene is not None
+        )
+
+    def graft_cdrs_onto(self, other: 'Chain', backmutate_vernier=False, backmutations: List[Union['Position',str]] = [], name: str = None) -> 'Chain':
+        """Graft CDRs from this Chain onto another chain
+
+        :param other: Chain to graft CDRs into (source of frameworks and tail sequence)
+        :param backmutate_vernier: Also graft all Kabat Vernier positions from this chain (perform backmutations)
+        :param backmutations: List of positions that should additionally be grafted from this chain (str or or :class:`Position`)
+        :param name: Name of new Chain. If not provided, use name of this chain.
+        :return: Chain with CDRs grafted from this chain and frameworks from the given chain
+        """
+        assert self.scheme == other.scheme, \
+            f'Sequences need to have the same numbering scheme, got {self.scheme} and {other.scheme}'
+        assert self.cdr_definition == other.cdr_definition, \
+            f'Sequences need to have the same CDR definition, got {self.cdr_definition} and {other.cdr_definition}'
+        assert self.chain_type == other.chain_type, \
+            f'Sequences need to have the same chain type, got {self.chain_type} and {other.chain_type}'
+
+        backmutations = [self._parse_position(pos) for pos in backmutations]
+
+        grafted_dict = {pos: aa for pos, aa in other if not pos.is_in_cdr()}
+        for pos, aa in self:
+            if pos.is_in_cdr() or (backmutate_vernier and pos.is_in_vernier()) or pos in backmutations:
+                grafted_dict[pos] = aa
+
+        return Chain(sequence=None, aa_dict=grafted_dict, name=name or self.name, chain_type=self.chain_type,
+                     scheme=self.scheme, cdr_definition=self.cdr_definition, tail=other.tail,
+                     v_gene=other.v_gene, j_gene=other.j_gene)
+
+    def graft_cdrs_onto_human_germline(self, v_gene=None, j_gene=None,
+                                       backmutate_vernier=False, backmutations: List[Union['Position',str]] = []):
+        """Graft CDRs from this Chain onto the nearest human germline sequence
+
+        :param v_gene: Use defined V germline allele (e.g. IGHV1-18*01), gene (e.g. IGHV1-18) or family (e.g. IGHV1)
+        :param j_gene: Use defined J germline allele (e.g. IGHJ1*01) or gene (e.g. IGHJ1)
+        :param backmutate_vernier: Also graft all Kabat Vernier positions from this chain (perform backmutations)
+        :param backmutations: List of positions that should additionally be grafted from this chain (str or or :class:`Position`)
+        :return: Chain with CDRs grafted from this chain and frameworks from TODO
+        """
+        germline_chain = self.find_merged_human_germline(v_gene=v_gene, j_gene=j_gene)
+
+        if self.scheme != 'imgt' or self.cdr_definition != 'imgt':
+            germline_chain = germline_chain.renumber(self.scheme, self.cdr_definition)
+
+        return self.graft_cdrs_onto(germline_chain, backmutate_vernier=backmutate_vernier, backmutations=backmutations)
+
+    def _parse_position(self, position: Union[int, str, 'Position'], allow_raw=False):
+        """Create :class:`Position` key object from string or int.
+
+        Note: The position should only be used for indexing, CDR definition is not preserved!
+
+        :param position: Numeric or string position representation
+        :param allow_raw: Also allow unaligned numeric (int) indexing from 0 to length of sequence - 1
+        :return: new Position object, should only be used for indexing, CDR definition is not preserved!
+        """
+        if isinstance(position, str):
+            return Position.from_string(position, chain_type=self.chain_type, scheme=self.scheme)
+        if isinstance(position, Position):
+            return position
+        try:
+            position = int(position)
+        except TypeError:
+            raise IndexError(f'Invalid position key, expected Position, string or integer, got {type(position)}: "{position}"')
+        if not allow_raw:
+            raise IndexError("Use chain.raw[i] for raw numeric indexing or pass allow_raw=True. "
+                             "For named position indexing, use string (e.g. chain['111A'] or chain['H111A'])")
+        if position >= len(self.positions):
+            return None
+        return self.get_position_by_raw_index(position)
+
+    def get_position_by_raw_index(self, index):
+        """Get Position object at corresponding raw numeric position"""
+        return list(self.positions.keys())[index]
+
+    def find_human_germlines(self, limit=10, v_gene=None, j_gene=None, unique=True) -> Tuple[List['Chain'], List['Chain']]:
+        """Find most identical V and J germline sequences based on IMGT alignment
+
+        :param limit: Number of best matching germlines to return
+        :param v_gene: Filter germlines to specific V gene name
+        :param j_gene: Filter germlines to specific J gene name
+        :param unique: Skip germlines with duplicate amino acid sequence
+        :return: list of top V chains, list of top J chains
+        """
+        from abnumber.germlines import get_imgt_v_chains, get_imgt_j_chains
+
+        chain = self if self.scheme == 'imgt' and self.cdr_definition == 'imgt' else self.renumber('imgt')
+        v_chains = list(get_imgt_v_chains(chain.chain_type).values())
+        j_chains = list(get_imgt_j_chains(chain.chain_type).values())
+
+        if v_gene:
+            if v_gene.startswith('IGKV') and self.chain_type == 'L':
+                raise NotImplementedError('Cannot graft lambda chain into kappa chain')
+            if v_gene.startswith('IGLV') and self.chain_type == 'K':
+                raise NotImplementedError('Cannot graft kappa chain into lambda chain')
+            v_chains = [chain for chain in v_chains if chain.name.startswith(v_gene)]
+            if not v_chains:
+                print('Available V genes:', get_imgt_v_chains(chain.chain_type).keys())
+                raise ValueError(f'No V genes found for "{chain.chain_type}" chain gene name "{v_gene}"')
+
+        if j_gene:
+            j_chains = [chain for chain in j_chains if chain.name.startswith(j_gene)]
+            if not j_chains:
+                print('Available J genes:', get_imgt_j_chains(chain.chain_type).keys())
+                raise ValueError(f'No J genes found for "{chain.chain_type}" chain gene name "{j_gene}"')
+            
+        if unique:
+            v_chains = _get_unique_chains(v_chains)
+            j_chains = _get_unique_chains(j_chains)
+
+        v_alignments = [chain.align(germline) for germline in v_chains]
+        v_ranks = np.array([alignment.num_mutations() for alignment in v_alignments]).argsort(kind='stable')[:limit]
+        top_v_chains = [v_chains[r] for r in v_ranks]
+
+        j_alignments = [chain.align(germline) for germline in j_chains]
+        j_ranks = np.array([alignment.num_mutations() for alignment in j_alignments]).argsort(kind='stable')[:limit]
+        top_j_chains = [j_chains[r] for r in j_ranks]
+
+        return top_v_chains, top_j_chains
+
+    def find_merged_human_germline(self, top=0, v_gene=None, j_gene=None) -> 'Chain':
+        """Find n-th most identical V and J germline sequence based on IMGT alignment and merge them into one Chain
+
+        :param top: Return top N most identical germline (0-indexed)
+        :param v_gene: Filter germlines to specific V gene name
+        :param j_gene: Filter germlines to specific J gene name
+        :return: merged germline sequence Chain object
+        """
+        v_chains, j_chains = self.find_human_germlines(limit=top+1, v_gene=v_gene, j_gene=j_gene)
+        v_chain = v_chains[top]
+        j_chain = j_chains[top]
+
+        merged_dict = {
+            **{pos: aa for pos, aa in j_chain},
+            **{pos: aa for pos, aa in v_chain}
+        }
+
+        return Chain(
+            sequence=None,
+            aa_dict=merged_dict,
+            chain_type=self.chain_type,
+            scheme='imgt',
+            tail=''
+        )
+
+    @property
+    def raw(self):
+        """Access raw representation of this chain to allow unaligned numeric indexing and slicing
+
+        >>> # String numbering is based on schema numbering
+        >>> chain['1']
+        'QVQLQQSGAE'
+        >>> # Numbering of ``chain.raw`` starts at 0
+        >>> chain.raw[0]
+        'QVQLQQSGAE'
+        >>> # Slicing with string is based on schema numbering, the end is inclusive
+        >>> chain['1':'10']
+        'QVQLQQSGAE'
+        >>> # Slicing with ``chain.raw`` starts at 0, the end is exclusive (Python style)
+        >>> chain.raw[0:10]
+        'QVQLQQSGAE'
+
+        :return: Raw chain accessor that can be sliced or indexed to produce a new :class:`Chain` object
+        """
+        return RawChainAccessor(self)
+
+    @property
+    def regions(self):
+        """Dictionary of region dictionaries
+
+        Region is an uppercase string, one of: ``"FR1", "CDR1", "FR2", "CDR2", "FR3", "CDR3", "FR4"``
+
+        :return: Dictionary of Region name -> Dictionary of (:class:`Position` -> Amino acid)
+        """
+        return OrderedDict(
+            FR1=self.fr1_dict,
+            CDR1=self.cdr1_dict,
+            FR2=self.fr2_dict,
+            CDR2=self.cdr2_dict,
+            FR3=self.fr3_dict,
+            CDR3=self.cdr3_dict,
+            FR4=self.fr4_dict
+        )
+
+    @property
+    def positions(self):
+        """Dictionary of :class:`Position` -> Amino acid"""
+        positions = OrderedDict()
+        for region, aa_dict in self.regions.items():
+            for pos, aa in aa_dict.items():
+                positions[pos] = aa
+        return positions
+
+    @property
+    def seq(self):
+        """Unaligned string representation of the variable chain sequence
+
+        :return: Unaligned string representation of the variable chain sequence
+        """
+        return ''.join(self.positions.values())
+
+    @property
+    def fr1_seq(self):
+        """Unaligned string representation of the Framework 1 region sequence"""
+        return ''.join(self.fr1_dict.values())
+
+    @property
+    def cdr1_seq(self):
+        """Unaligned string representation of the CDR 1 region sequence"""
+        return ''.join(self.cdr1_dict.values())
+
+    @property
+    def fr2_seq(self):
+        """Unaligned string representation of the Framework 2 region sequence"""
+        return ''.join(self.fr2_dict.values())
+
+    @property
+    def cdr2_seq(self):
+        """Unaligned string representation of the CDR 2 region sequence"""
+        return ''.join(self.cdr2_dict.values())
+
+    @property
+    def fr3_seq(self):
+        """Unaligned string representation of the Framework 3 region sequence"""
+        return ''.join(self.fr3_dict.values())
+
+    @property
+    def cdr3_seq(self):
+        """Unaligned string representation of the CDR 3 region sequence"""
+        return ''.join(self.cdr3_dict.values())
+
+    @property
+    def fr4_seq(self):
+        """Unaligned string representation of the Framework 4 region sequence"""
+        return ''.join(self.fr4_dict.values())
+
+
+class RawChainAccessor:
+    def __init__(self, chain: Chain):
+        self.chain = chain
+
+    def __getitem__(self, item):
+        if isinstance(item, slice):
+            if item.step is not None and item.step != 1:
+                raise IndexError(f'Slicing with step != 1 is not implemented, got: {item}')
+            if item.start is not None and not is_integer(item.start):
+                raise IndexError(f'Expected int start index for chain.raw, got {type(item.start)}: {item.start}')
+            if item.stop is not None and not is_integer(item.stop):
+                raise IndexError(f'Expected int end index for chain.raw, got {type(item.stop)}: {item.stop}')
+            return self.chain.slice(start=item.start, stop=item.stop, stop_inclusive=False, allow_raw=True)
+        if not is_integer(item):
+            raise IndexError(f'Expected int indexing for chain.raw, got {type(item)}: {item}')
+        pos = self.chain.get_position_by_raw_index(item)
+        return self.chain[pos]
+
+
+
+

abnumber/common.py

@@ -0,0 +1,133 @@
+import sys
+from typing import List, Tuple
+import re
+import numpy as np
+from abnumber.exceptions import ChainParseError
+try:
+    from anarci.anarci import anarci
+except ImportError:
+    # Only print the error without failing - required to import
+    print('ANARCI module not available. Please install it separately or install AbNumber through Bioconda')
+    print('See: https://abnumber.readthedocs.io/')
+    sys.exit(1)
+
+POS_REGEX = re.compile(r'([HL]?)(\d+)([A-Z]?)')
+WHITESPACE = re.compile(r'\s+')
+
+
+def _validate_chain_type(chain_type):
+    assert chain_type in ['H', 'L', 'K'], \
+        f'Invalid chain type "{chain_type}", it should be "H" (heavy),  "L" (lambda light chian) or "K" (kappa light chain)'
+
+
+def _anarci_align(sequence, scheme, allowed_species, assign_germline=False) -> List[Tuple]:
+    from abnumber.position import Position
+    sequence = re.sub(WHITESPACE, '', sequence)
+    all_numbered, all_ali, all_hits = anarci(
+        [('id', sequence)],
+        scheme=scheme,
+        allowed_species=allowed_species,
+        assign_germline=assign_germline
+    )
+    seq_numbered = all_numbered[0]
+    seq_ali = all_ali[0]
+    if seq_numbered is None:
+        raise ChainParseError(f'Variable chain sequence not recognized: "{sequence}"')
+    assert len(seq_numbered) == len(seq_ali), 'Unexpected ANARCI output'
+    results = []
+    for (positions, start, end), ali in zip(seq_numbered, seq_ali):
+        chain_type = ali['chain_type']
+        species = ali['species']
+        v_gene = ali['germlines']['v_gene'][0][1] if assign_germline else None
+        j_gene = ali['germlines']['j_gene'][0][1] if assign_germline else None
+        aa_dict = {Position(chain_type=chain_type, number=num, letter=letter, scheme=scheme): aa
+                   for (num, letter), aa in positions if aa != '-'}
+        tail = sequence[end+1:]
+        results.append((aa_dict, chain_type, tail, species, v_gene, j_gene))
+    return results
+
+
+def _get_unique_chains(chains):
+    seqs = set()
+    chains_filtered = []
+    for chain in chains:
+        if chain.seq in seqs:
+            continue
+        seqs.add(chain.seq)
+        chains_filtered.append(chain)
+    return chains_filtered
+
+
+# Based on positive score in Blosum62
+SIMILAR_PAIRS = {'AA', 'AS', 'CC', 'DD', 'DE', 'DN', 'ED', 'EE', 'EK', 'EQ', 'FF', 'FW', 'FY', 'GG', 'HH', 'HN', 'HY',
+                 'II', 'IL', 'IM', 'IV', 'KE', 'KK', 'KQ', 'KR', 'LI', 'LL', 'LM', 'LV', 'MI', 'ML', 'MM', 'MV', 'ND',
+                 'NH', 'NN', 'NS', 'PP', 'QE', 'QK', 'QQ', 'QR', 'RK', 'RQ', 'RR', 'SA', 'SN', 'SS', 'ST', 'TS', 'TT',
+                 'VI', 'VL', 'VM', 'VV', 'WF', 'WW', 'WY', 'YF', 'YH', 'YW', 'YY'}
+
+
+def is_similar_residue(a, b):
+    if a == '-' or b == '-':
+        return a == b
+    return a+b in SIMILAR_PAIRS
+
+
+def is_integer(object):
+    return isinstance(object, int) or isinstance(object, np.integer)
+
+
+SUPPORTED_SCHEMES = ['imgt', 'aho', 'chothia', 'kabat']
+SUPPORTED_CDR_DEFINITIONS = ['imgt', 'chothia', 'kabat', 'north']
+
+SCHEME_BORDERS = {
+               # Start coordinates
+               # CDR1, FR2, CDR2, FR3, CDR3, FR4
+         'imgt': [27,  39,  56,   66,  105,  118, 129],
+      'kabat_H': [31,  36,  50,   66,  95,   103, 114],
+      'kabat_K': [24,  35,  50,   57,  89,    98, 108],
+      'kabat_L': [24,  35,  50,   57,  89,    98, 108],
+    'chothia_H': [26,  33,  52,   57,  95,   103, 114],
+    'chothia_K': [24,  35,  50,   57,  89,    98, 108],
+    'chothia_L': [24,  35,  50,   57,  89,    98, 108],
+      'north_H': [23,  36,  50,   59,  93,   103, 114],
+      'north_K': [24,  35,  49,   57,  89,    98, 108],
+      'north_L': [24,  35,  49,   57,  89,    98, 108],
+}
+
+# { scheme -> { region -> list of position numbers } }
+SCHEME_REGIONS = {
+    scheme: {
+        'FR1': list(range(1, borders[0])),
+        'CDR1': list(range(borders[0], borders[1])),
+        'FR2': list(range(borders[1], borders[2])),
+        'CDR2': list(range(borders[2], borders[3])),
+        'FR3': list(range(borders[3], borders[4])),
+        'CDR3': list(range(borders[4], borders[5])),
+        'FR4': list(range(borders[5], borders[6])),
+    } for scheme, borders in SCHEME_BORDERS.items()
+}
+
+# { scheme -> { position number -> region } }
+SCHEME_POSITION_TO_REGION = {
+    scheme: {pos_num: region for region, positions in regions.items() for pos_num in positions} \
+    for scheme, regions in SCHEME_REGIONS.items()
+}
+
+# { scheme -> set of vernier position numbers }
+SCHEME_VERNIER = {
+    #    'imgt_H': frozenset([2,                 52, 53, 54, 76, 78, 80, 82, 87,         118]),
+    # 'chothia_H': frozenset([2,                 47, 48, 49, 67, 69, 71, 73, 78, 93, 94, 103]),
+    #   'north_H': frozenset([2,                 47, 48, 49, 67, 69, 71, 73, 78, 93, 94, 103]),
+      'kabat_H': frozenset([2, 27, 28, 29, 30, 47, 48, 49, 67, 69, 71, 73, 78, 93, 94, 103]),
+
+    #    'imgt_K': frozenset([2, 4, 41, 42, 52, 53, 54, 55, 78, 80, 84, 85, 87, 118]),
+    #    'imgt_L': frozenset([2, 4, 41, 42, 52, 53, 54, 55, 78, 80, 84, 85, 87, 118]),
+    # 'chothia_K': frozenset([2, 4, 35, 36, 46, 47, 48, 49, 64, 66, 68, 69, 71, 98]),
+    # 'chothia_L': frozenset([2, 4, 35, 36, 46, 47, 48, 49, 64, 66, 68, 69, 71, 98]),
+    #   'north_K': frozenset([2, 4, 35, 36, 46, 47, 48, 49, 64, 66, 68, 69, 71, 98]),
+    #   'north_L': frozenset([2, 4, 35, 36, 46, 47, 48, 49, 64, 66, 68, 69, 71, 98]),
+      'kabat_K': frozenset([2, 4, 35, 36, 46, 47, 48, 49, 64, 66, 68, 69, 71, 98]),
+      'kabat_L': frozenset([2, 4, 35, 36, 46, 47, 48, 49, 64, 66, 68, 69, 71, 98]),
+}
+
+#'kabat_H': 31-35, 50-65, 95-102
+#'kabat_K': 24-34, 50-56, 89-97

abnumber/exceptions.py

@@ -0,0 +1,2 @@
+class ChainParseError(Exception):
+    pass

abnumber/germlines.py

@@ -0,0 +1,684 @@
+_HUMAN_IMGT_V_CHAINS = None
+_HUMAN_IMGT_J_CHAINS = None
+
+
+def get_imgt_chain(gene_name):
+    if gene_name.startswith('IGH'):
+        chain_type = 'H'
+    elif gene_name.startswith('IGK'):
+        chain_type = 'K'
+    elif gene_name.startswith('IGL'):
+        chain_type = 'L'
+    else:
+        raise ValueError(f'Gene name should start with IG(H/K/L), got: {gene_name}')
+
+    if gene_name.startswith(f'IG{chain_type}V'):
+        chains = get_imgt_v_chains(chain_type)
+    elif gene_name.startswith(f'IG{chain_type}J'):
+        chains = get_imgt_j_chains(chain_type)
+    else:
+        raise ValueError(f'Expected V or J gene name, got: {gene_name}')
+
+    if gene_name not in chains:
+        suffixes = [chain_name for chain_name in chains if chain_name.startswith(gene_name)]
+        if suffixes:
+            raise ValueError(f'Gene name "{gene_name}" not complete, use one of: {suffixes}')
+        print('Available gene names:', chains.keys())
+        raise ValueError(f'Gene name "{gene_name}" not found')
+
+    return chains[gene_name]
+
+
+def get_imgt_v_chains(chain_type=None):
+    global _HUMAN_IMGT_V_CHAINS
+    if _HUMAN_IMGT_V_CHAINS is None or chain_type not in _HUMAN_IMGT_V_CHAINS:
+        _HUMAN_IMGT_V_CHAINS = {}
+        for t, germlines in HUMAN_IMGT_IG_V.items():
+            positions = germlines['positions']
+            seqs = germlines['aligned_sequences']
+            _HUMAN_IMGT_V_CHAINS[t] = {name: germline_to_chain(positions, seq, name=name, chain_type=t) for name, seq in seqs.items()}
+    return _HUMAN_IMGT_V_CHAINS[chain_type]
+
+
+def get_imgt_j_chains(chain_type=None):
+    global _HUMAN_IMGT_J_CHAINS
+    if _HUMAN_IMGT_J_CHAINS is None or chain_type not in _HUMAN_IMGT_J_CHAINS:
+        _HUMAN_IMGT_J_CHAINS = {}
+        for t, germlines in HUMAN_IMGT_IG_J.items():
+            positions = germlines['positions']
+            seqs = germlines['aligned_sequences']
+            _HUMAN_IMGT_J_CHAINS[t] = {name: germline_to_chain(positions, seq, name=name, chain_type=t) for name, seq in seqs.items()}
+    return _HUMAN_IMGT_J_CHAINS[chain_type]
+
+
+def germline_to_chain(positions, seq, chain_type, **kwargs):
+    from abnumber.chain import Chain, Position
+    return Chain(sequence=None, scheme='imgt', chain_type=chain_type, tail='', aa_dict={
+        Position.from_string(pos, chain_type=chain_type, scheme='imgt'): aa for pos, aa in zip(positions, seq)
+    }, **kwargs)
+
+
+def get_germline_v_families(chain_type):
+    names = HUMAN_IMGT_IG_V[chain_type]['aligned_sequences'].keys()
+    return sorted(set([name.split('-')[0].split('/')[0] for name in names]))
+
+
+def get_germline_v_genes(chain_type):
+    names = HUMAN_IMGT_IG_V[chain_type]['aligned_sequences'].keys()
+    return sorted(set([name.split('*')[0] for name in names]))
+
+
+HUMAN_IMGT_IG_V = {
+    'H': {
+        "positions": [
+            "H1", "H2", "H3", "H4", "H5", "H6", "H7", "H8", "H9", "H11", "H12", "H13", "H14", "H15", "H16", "H17", "H18", "H19", "H20", "H21", "H22", "H23", "H24", "H25", "H26", "H27", "H28", "H29", "H30", "H31", "H34", "H35", "H36", "H37", "H38", "H39", "H40", "H41", "H42", "H43", "H44", "H45", "H46", "H47", "H48", "H49", "H50", "H51", "H52", "H53", "H54", "H55", "H56", "H57", "H58", "H59", "H60", "H61", "H62", "H63", "H64", "H65", "H66", "H67", "H68", "H69", "H70", "H71", "H72", "H74", "H75", "H76", "H77", "H78", "H79", "H80", "H81", "H82", "H83", "H84", "H85", "H86", "H87", "H88", "H89", "H90", "H91", "H92", "H93", "H94", "H95", "H96", "H97", "H98", "H99", "H100", "H101", "H102", "H103", "H104", "H105", "H106", "H107"
+        ],
+        "aligned_sequences": {
+            "IGHV1-18*01": "QVQLVQSGAEVKKPGASVKVSCKASGYTF--TSYGISWVRQAPGQGLEWMGWISAY--NGNTNYAQKLQGRVTMTTDTSTSTAYMELRSLRSDDTAVYYCAR-",
+            "IGHV1-18*03": "QVQLVQSGAEVKKPGASVKVSCKASGYTF--TSYGISWVRQAPGQGLEWMGWISAY--NGNTNYAQKLQGRVTMTTDTSTSTAYMELRSLRSDDMAVYYCAR-",
+            "IGHV1-18*04": "QVQLVQSGAEVKKPGASVKVSCKASGYTF--TSYGISWVRQAPGQGLEWMGWISAY--NGNTNYAQKLQGRVTMTTDTSTSTAYMELRSLRSDDTAVYYCAR-",
+            "IGHV1-2*01": "QVQLVQSGAEVKKPGASVKVSCKASGYTF--TGYYMHWVRQAPGQGLEWMGRINPN--SGGTNYAQKFQGRVTSTRDTSISTAYMELSRLRSDDTVVYYCAR-",
+            "IGHV1-2*02": "QVQLVQSGAEVKKPGASVKVSCKASGYTF--TGYYMHWVRQAPGQGLEWMGWINPN--SGGTNYAQKFQGRVTMTRDTSISTAYMELSRLRSDDTAVYYCAR-",
+            "IGHV1-2*03": "QVQLVQSGAEVKKLGASVKVSCKASGYTF--TGYYMHWVXQAPGQGLEWMGWINPN--SGGTNYAQKFQGRVTMTRDTSISTAYMELSRLRSDDTAVYYCAR-",
+            "IGHV1-2*04": "QVQLVQSGAEVKKPGASVKVSCKASGYTF--TGYYMHWVRQAPGQGLEWMGWINPN--SGGTNYAQKFQGWVTMTRDTSISTAYMELSRLRSDDTAVYYCAR-",
+            "IGHV1-2*05": "QVQLVQSGAEVKKPGASVKVSCKASGYTF--TGYYMHWVRQAPGQGLEWMGRINPN--SGGTNYAQKFQGRVTMTRDTSISTAYMELSRLRSDDTVVYYCAR-",
+            "IGHV1-2*06": "QVQLVQSGAEVKKPGASVKVSCKASGYTF--TGYYMHWVRQAPGQGLEWMGRINPN--SGGTNYAQKFQGRVTMTRDTSISTAYMELSRLRSDDTAVYYCAR-",
+            "IGHV1-2*07": "QVQLVQSGAEVKKPGASVKVSCKASGYTF--TGYYMHWVRQAPGQGLEWMGWINPN--SGGTNYAHKFQGRVTMTRDTSISTAYMELSRLRSDDTAVYYCAR-",
+            "IGHV1-24*01": "QVQLVQSGAEVKKPGASVKVSCKVSGYTL--TELSMHWVRQAPGKGLEWMGGFDPE--DGETIYAQKFQGRVTMTEDTSTDTAYMELSSLRSEDTAVYYCAT-",
+            "IGHV1-3*01": "QVQLVQSGAEVKKPGASVKVSCKASGYTF--TSYAMHWVRQAPGQRLEWMGWINAG--NGNTKYSQKFQGRVTITRDTSASTAYMELSSLRSEDTAVYYCAR-",
+            "IGHV1-3*02": "QVQLVQSGAEVKKPGASVKVSCKASGYTF--TSYAMHWVRQAPGQRLEWMGWSNAG--NGNTKYSQEFQGRVTITRDTSASTAYMELSSLRSEDMAVYYCAR-",
+            "IGHV1-3*03": "QVQLVQSGAEVKKPGASVKVSCKASGYTF--TSYAMHWVRQAPGQRLEWMGWINAG--NGNTKYSQEFQGRVTITRDTSASTAYMELSSLRSEDMAVYYCAR-",
+            "IGHV1-3*05": "QVQLVQSGAEEKKPGASVKVSCKASGYTF--TSYAMHWVRQAPGQRLEWMGWINAG--NGNTKYSQKFQGRVTITRDTSASTAYMELSSLRSEDTAVYYCAR-",
+            "IGHV1-38-4*01": "QVQLVQSWAEVRKSGASVKVSCSFSGFTI--TSYGIHWVQQSPGQGLEWMGWINPG--NGSPSYAKKFQGRFTMTRDMSTTTAYTDLSSLTSEDMAVYYYAR-",
+            "IGHV1-45*01": "QMQLVQSGAEVKKTGSSVKVSCKASGYTF--TYRYLHWVRQAPGQALEWMGWITPF--NGNTNYAQKFQDRVTITRDRSMSTAYMELSSLRSEDTAMYYCAR-",
+            "IGHV1-45*02": "QMQLVQSGAEVKKTGSSVKVSCKASGYTF--TYRYLHWVRQAPGQALEWMGWITPF--NGNTNYAQKFQDRVTITRDRSMSTAYMELSSLRSEDTAMYYCAR-",
+            "IGHV1-45*03": "QMQLVQSGAEVKKTGSSVKVSCKASGYTF--TYRYLHWVRQAPRQALEWMGWITPF--NGNTNYAQKFQDRVTITRDRSMSTAYMELSSLRSEDTAMYYCAR-",
+            "IGHV1-46*01": "QVQLVQSGAEVKKPGASVKVSCKASGYTF--TSYYMHWVRQAPGQGLEWMGIINPS--GGSTSYAQKFQGRVTMTRDTSTSTVYMELSSLRSEDTAVYYCAR-",
+            "IGHV1-46*02": "QVQLVQSGAEVKKPGASVKVSCKASGYTF--NSYYMHWVRQAPGQGLEWMGIINPS--GGSTSYAQKFQGRVTMTRDTSTSTVYMELSSLRSEDTAVYYCAR-",
+            "IGHV1-46*03": "QVQLVQSGAEVKKPGASVKVSCKASGYTF--TSYYMHWVRQAPGQGLEWMGIINPS--GGSTSYAQKFQGRVTMTRDTSTSTVYMELSSLRSEDTAVYYCAR-",
+            "IGHV1-46*04": "QVQLVQSGAEVKKPGASVKVSCKASGYTF--TSYYMHWVRQAPGQGLEWMGIINPS--GGSTSYAQKLQGRVTMTRDTSTSTVYMELSSLRSEDTAVYYCAR-",
+            "IGHV1-58*01": "QMQLVQSGPEVKKPGTSVKVSCKASGFTF--TSSAVQWVRQARGQRLEWIGWIVVG--SGNTNYAQKFQERVTITRDMSTSTAYMELSSLRSEDTAVYYCAA-",
+            "IGHV1-58*02": "QMQLVQSGPEVKKPGTSVKVSCKASGFTF--TSSAMQWVRQARGQRLEWIGWIVVG--SGNTNYAQKFQERVTITRDMSTSTAYMELSSLRSEDTAVYYCAA-",
+            "IGHV1-68*01": "QVQLGQSEAEVKKPGASVKVSCKASGYTF--TCCSLHWLQQAPGQGLERMRWITLY--NGNTNYAKKFQGRVTITRDMSLRTAYIELSSLRSEDSAVYYWAR-",
+            "IGHV1-68*02": "QVQLGQSEAEVKKPGASVKVSCKASGYTF--TYCSLHWLQQAPGQGLERMRWITLY--NGNINYAKKFQSRVTITRDMSLRTAYIELSSLRSEDSAVYYWAR-",
+            "IGHV1-69*01": "QVQLVQSGAEVKKPGSSVKVSCKASGGTF--SSYAISWVRQAPGQGLEWMGGIIPI--FGTANYAQKFQGRVTITADESTSTAYMELSSLRSEDTAVYYCAR-",
+            "IGHV1-69*02": "QVQLVQSGAEVKKPGSSVKVSCKASGGTF--SSYTISWVRQAPGQGLEWMGRIIPI--LGIANYAQKFQGRVTITADKSTSTAYMELSSLRSEDTAVYYCAR-",
+            "IGHV1-69*04": "QVQLVQSGAEVKKPGSSVKVSCKASGGTF--SSYAISWVRQAPGQGLEWMGRIIPI--LGIANYAQKFQGRVTITADKSTSTAYMELSSLRSEDTAVYYCAR-",
+            "IGHV1-69*05": "QVQLVQSGAEVKKPGSSVKVSCKASGGTF--SSYAISWVRQAPGQGLEWMGGIIPI--FGTANYAQKFQGRVTITTDESTSTAYMELSSLRSEDTAVYYCAR-",
+            "IGHV1-69*06": "QVQLVQSGAEVKKPGSSVKVSCKASGGTF--SSYAISWVRQAPGQGLEWMGGIIPI--FGTANYAQKFQGRVTITADKSTSTAYMELSSLRSEDTAVYYCAR-",
+            "IGHV1-69*08": "QVQLVQSGAEVKKPGSSVKVSCKASGGTF--SSYTISWVRQAPGQGLEWMGRIIPI--LGTANYAQKFQGRVTITADKSTSTAYMELSSLRSEDTAVYYCAR-",
+            "IGHV1-69*09": "QVQLVQSGAEVKKPGSSVKVSCKASGGTF--SSYAISWVRQAPGQGLEWMGRIIPI--LGIANYAQKFQGRVTITADKSTSTAYMELSSLRSEDTAVYYCAR-",
+            "IGHV1-69*10": "QVQLVQSGAEVKKPGSSVKVSCKASGGTF--SSYAISWVRQAPGQGLEWMGGIIPI--LGIANYAQKFQGRVTITADKSTSTAYMELSSLRSEDTAVYYCAR-",
+            "IGHV1-69*11": "QVQLVQSGAEVKKPGSSVKVSCKASGGTF--SSYAISWVRQAPGQGLEWMGRIIPI--LGTANYAQKFQGRVTITADESTSTAYMELSSLRSEDTAVYYCAR-",
+            "IGHV1-69*12": "QVQLVQSGAEVKKPGSSVKVSCKASGGTF--SSYAISWVRQAPGQGLEWMGGIIPI--FGTANYAQKFQGRVTITADESTSTAYMELSSLRSEDTAVYYCAR-",
+            "IGHV1-69*13": "QVQLVQSGAEVKKPGSSVKVSCKASGGTF--SSYAISWVRQAPGQGLEWMGGIIPI--FGTANYAQKFQGRVTITADESTSTAYMELSSLRSEDTAVYYCAR-",
+            "IGHV1-69*14": "QVQLVQSGAEVKKPGSSVKVSCKASGGTF--SSYAISWVRQAPGQGLEWMGGIIPI--FGTANYAQKFQGRVTITADKSTSTAYMELSSLRSEDTAVYYCAR-",
+            "IGHV1-69*15": "QVQLVQSGAEVKKPGSSVKVSCKASGGTF--SSYAISWVRQAPGQGLEWMGRIIPI--FGTANYAQKFQGRVTITADESTSTAYMELSSLRSEDTAVYYCAR-",
+            "IGHV1-69*16": "QVQLVQSGAEVKKPGSSVKVSCKASGGTF--SSYTISWVRQAPGQGLEWMGGIIPI--LGTANYAQKFQGRVTITTDESTSTAYMELSSLRSEDTAVYYCAR-",
+            "IGHV1-69*17": "QVQLVQSGAEVKKPGSSVKVSCKASGGTF--SSYAISWVRQAPGQGLEWMGGIIPI--FGIANYAQKFQGRVTITADKSTSTAYMELSSLRSEDTAVYYCAR-",
+            "IGHV1-69*19": "QVQLVQSGAEVKKPGSSVKVSCKASGGTF--SSYAISWVRQAPGQGLEWMGGIIPI--FGTANYAQKFQGRVTITADESTSTAYMELSSLRSEDTAVYYCAR-",
+            "IGHV1-69-2*01": "EVQLVQSGAEVKKPGATVKISCKVSGYTF--TDYYMHWVQQAPGKGLEWMGLVDPE--DGETIYAEKFQGRVTITADTSTDTAYMELSSLRSEDTAVYYCAT-",
+            "IGHV1-69D*01": "QVQLVQSGAEVKKPGSSVKVSCKASGGTF--SSYAISWVRQAPGQGLEWMGGIIPI--FGTANYAQKFQGRVTITADESTSTAYMELSSLRSEDTAVYYCAR-",
+            "IGHV1-8*01": "QVQLVQSGAEVKKPGASVKVSCKASGYTF--TSYDINWVRQATGQGLEWMGWMNPN--SGNTGYAQKFQGRVTMTRNTSISTAYMELSSLRSEDTAVYYCAR-",
+            "IGHV1-8*02": "QVQLVQSGAEVKKPGASVKVSCKASGYTF--TSYDINWVRQATGQGLEWMGWMNPN--SGNTGYAQKFQGRVTMTRNTSISTAYMELSSLRSEDTAVYYCAR-",
+            "IGHV1-8*03": "QVQLVQSGAEVKKPGASVKVSCKASGYTF--TSYDINWVRQATGQGLEWMGWMNPN--SGNTGYAQKFQGRVTITRNTSISTAYMELSSLRSEDTAVYYCAR-",
+            "IGHV1-NL1*01": "QVQLLQPGVQVKKPGSSVKVSC-ASRYTF--TKYFTRWV-QSPGQGHXWMG-INPY--NDNTHYAQTFWGRVTITSDRSMSTAYMELSXLRSEDMVVYYCVR-",
+            "IGHV1/OR15-1*01": "QVQLVQSGAEVKKPGASVKVSCKASGYIF--TDYYMHWVRQAPGQELGWMGRINPN--SGGTNYAQKFQGRVTMTRDTSISTAYTELSSLRSEDTATYYCAR-",
+            "IGHV1/OR15-1*02": "QVQLVQSGAEVKKPGASVKVSCKASGYIF--TDYYMHWVRQAPGQELGWMGRINPN--SGGTNYAQKFQGRVTMTRDTSISTACTELSSLRSEDTATYYCAR-",
+            "IGHV1/OR15-1*03": "QVQLVQSGAEVKKPGASVKVSCKASGYIF--TDYYMHWVRQAPGQELGWMGRINPN--SGGTNYAQKFQGRVTMTRDTSISTAYTELSSLRSEDTATYYCAR-",
+            "IGHV1/OR15-1*04": "QVQLVQSGAEVKKPGASVKVSCKASGYIF--TDYYMHWVRQAPGQELGWMGRINPN--SGGTNYAQKFQGRVTMTRDTSISTAYMELSSLRSEDTATYYCAR-",
+            "IGHV1/OR15-2*01": "QVQLVQSGAEVKKPRASVKVSCKASGYTF--TSYYMHWV-QAPEQGLEWMGWINTY--NGNTNYPQKLQGRVTMTRDTSTSTAYMELSRLRSDDMAVYYCAR-",
+            "IGHV1/OR15-2*02": "QVQLVQSGAEVKKPGASVKVSCKASGYTF--TSYYMHWV-QAPEQGLEWMGWINTY--NGNTNYPQKLQGRVTMTRDTSTSTAYMELSSLRSDDMAVYYCAR-",
+            "IGHV1/OR15-2*03": "QVQLVQSGAEVKKPRASVKVSCKASGYTF--TSYYMHWV-QAPEQGLEWMGWINTY--NGNTNYPQKLQGRVTMTRDTSTSTAYMELSSLRSDDMAVYYCAR-",
+            "IGHV1/OR15-3*01": "QVQLV-SGAEVKKPGASVKVSCKASGYTF--TDYFMNWMRQAPGQRLEWMGWINAG--NGNTKYSQKLQGRVTITRDTSSSTAYMQLSSLRSEDTAVYYCAR-",
+            "IGHV1/OR15-3*02": "QVQLV-SGAEVKKPGASVKVSCKASGYTF--TDYFMNWMRQAPGQRLEWMGWINAG--NGNTKYSQKLQGRVTITRDTSASTAYMQLSSLRSEDTAVYYCAR-",
+            "IGHV1/OR15-3*03": "QVQLV-SGAEVKKPGASVKVSCKASGYTF--TSYYMNWMRQAPGQGFEWMGWINAG--NGNTKYSQKLQGRVTITRDTSASTAYMQLSSLRSEDTAVYYCAR-",
+            "IGHV1/OR15-4*01": "QDQLVQSGAEVKKPLSSVKVSFKASGYTF--TNNFMHWV-QAPGQGLEWMGWINAG--NGNTTYAQKFQGRVTITRDTSMSTAYTELSSLRSEDTAVYYCAR-",
+            "IGHV1/OR15-5*02": "QVQLVQSGAEVKKPGASVKVSCKASGYTF--TNYCMHWVRQVHAQGLEWMGLVCPS--DGSTSYAQKFQARVTITRDTSMSTAYMELSSLRSEDTAMYYCVR-",
+            "IGHV1/OR15-9*01": "QVQLMQSGAEVKKPGASVRISCKASGYTF--TSYCMHWVCQAHAQGLEWMGLVCPS--DGSTSYAQKFQGRVTITRDTSMGTAYMELSSLRSEDTAMYYCVR-",
+            "IGHV1/OR21-1*01": "QVQLVQSGAEVKKPGASVKVSCKASGYTI--TSYCMHWVHQVHAQGLEWMGLVCPS--DGSTSYAQKFQARVTITRDTSMSTAYMELSSLRSEDTAMYYCVR-",
+            "IGHV2-10*01": "QVTLKESGPALVKPTQTLMLTCTFSGFSLSTSGMGVG-ICQPSAKALEWLAHIY-N---DNKYYSPSLKSRLIISKDTSKNEVVLTVINMDIVDTATHYCARR",
+            "IGHV2-26*01": "QVTLKESGPVLVKPTETLTLTCTVSGFSLSNARMGVSWIRQPPGKALEWLAHIFSN---DEKSYSTSLKSRLTISKDTSKSQVVLTMTNMDPVDTATYYCARI",
+            "IGHV2-26*02": "QVTLKESGPVLVKPTETLTLTCTVSGFSLSNARMGVSWIRQPPGKALEWLAHIFSN---DEKSYSTSLKSRLTISKDTSKSQVVLTMTNMDPVDTATYYCARI",
+            "IGHV2-26*03": "QVTLKESGPVLVKPTETLTLTCTISGFSLSNARMGVSWIRQPPGKALEWLAHIFSN---DEKSYSTSLKSRLTISKDTSKSQVVLTMTNMDPVDTATYYCARI",
+            "IGHV2-5*01": "QITLKESGPTLVKPTQTLTLTCTFSGFSLSTSGVGVGWIRQPPGKALEWLALIYWN---DDKRYSPSLKSRLTITKDTSKNQVVLTMTNMDPVDTATYYCAHR",
+            "IGHV2-5*02": "QITLKESGPTLVKPTQTLTLTCTFSGFSLSTSGVGVGWIRQPPGKALEWLALIYWD---DDKRYSPSLKSRLTITKDTSKNQVVLTMTNMDPVDTATYYCAHR",
+            "IGHV2-5*05": "QITLKESGPTLVKPTQTLTLTCTFSGFSLSTSGVGVGWIRQPPGKALEWLALIYWD---DDKRYGPSLKSRLTITKDTSKNQVVLTMTNMDPVDTATYYCAHR",
+            "IGHV2-5*06": "QITLKESGPTLVKPTQTLTLTCTFSGFSLSTSGVGVGWIRQPPGKALEWLALIYWD---DDKRYGPSLKSRLTITKDTSKNQVVLTMTNMDPVDTATYYCAHR",
+            "IGHV2-5*08": "QVTLKESGPALVKPTQTLTLTCTFSGFSLSTSGMRVSWIRQPPGKALEWLALIYWD---DDKRYSPSLKSRLTITKDTSKNQVVLTMTNMDPVDTATYYCAHR",
+            "IGHV2-5*09": "QVTLKESGPTLVKPTQTLTLTCTFSGFSLSTSGVGVGWIRQPPGKALEWLALIYWD---DDKRYGPSLKSRLTITKDTSKNQVVLTMTNMDPVDTATYYCAHR",
+            "IGHV2-70*01": "QVTLRESGPALVKPTQTLTLTCTFSGFSLSTSGMCVSWIRQPPGKALEWLALIDWD---DDKYYSTSLKTRLTISKDTSKNQVVLTMTNMDPVDTATYYCARI",
+            "IGHV2-70*04": "QVTLKESGPALVKPTQTLTLTCTFSGFSLSTSGMRVSWIRQPPGKALEWLARIDWD---DDKFYSTSLKTRLTISKDTSKNQVVLTMTNMDPVDTATYYCARI",
+            "IGHV2-70*10": "QVTLKESGPALVKPTQTLTLTCTFSGFSLSTSGMRVSWIRQPPGKALEWIARIDWD---DDKYYSTSLKTRLTISKDTSKNQVVLTMTNMDPVDTATYYCARI",
+            "IGHV2-70*11": "RVTLRESGPALVKPTQTLTLTCTFSGFSLSTSGMCVSWIRQPPGKALEWLARIDWD---DDKYYSTSLKTRLTISKDTSKNQVVLTMTNMDPVDTATYYCARI",
+            "IGHV2-70*12": "QITLKESGPTLVKPTQTLTLTCTFSGFSLSTSGMCVSWIRQPPGKALEWLALIDWD---DDKYYSTSLKTRLTISKDTSKNQVVLTMTNMDPVDTATYYCAHR",
+            "IGHV2-70*13": "QVTLRESGPALVKPTQTLTLTCTFSGFSLSTSGMCVSWIRQPPGKALEWLALIDWD---DDKYYSTSLKTRLTISKDTSKNQVVLTMTNMDPVDTATYYCARI",
+            "IGHV2-70*15": "QVTLRESGPALVKPTQTLTLTCTFSGFSLSTSGMCVSWIRQPPGKALEWLARIDWD---DDKYYSTSLKTRLTISKDTSKNQVVLTMTNMDPVDTATYYCARI",
+            "IGHV2-70*16": "QVTLKESGPVLVKPTQTLTLTCTFSGFSLSTSGMCVSWIRQPPGKALEWLARIDWD---DDKFYSTSLKTRLTISKDTSKNQVVLTMTNMDPVDTATYYCARI",
+            "IGHV2-70*17": "QVTLRESGPALVKPTQTLTLTCTFSGFSLSTSGMCVSWIRQPPGKALEWLARIDWD---DDKFYSTSLKTRLTISKDTSKNQVVLTMTNMDPVDTATYYCARI",
+            "IGHV2-70*18": "QVTLRESGPALVKPTQTLTLTCTFSGFSLSTSEMCVSWVRQPPGKALEWLALIDWD---DDKYYSTSLKTRLTISKDTSKNQVVLTMTNMDPVDTATYYCARI",
+            "IGHV2-70*19": "QVTLRESGPALVKPTQTLTLTCTFSGFSLSTSGMCVSWVRQPPGKALEWLALIDWD---DDKHYSTSLKTRLTISKDTSKNQVVLTMTNMDPVDTATYYCARI",
+            "IGHV2-70D*04": "QVTLKESGPALVKPTQTLTLTCTFSGFSLSTSGMRVSWIRQPPGKALEWLARIDWD---DDKFYSTSLKTRLTISKDTSKNQVVLTMTNMDPVDTATYYCARI",
+            "IGHV2-70D*14": "QVTLKESGPALVKPTQTLTLTCTFSGFSLSTSGMRVSWIRQPPGKALEWLARIDWD---DDKFYSTSLKTRLTISKDTSKNQVVLTMTNMDPVDTATYYCARI",
+            "IGHV2/OR16-5*01": "QVTLKESGPALVKPTETLTLTCTLSGFSLSTSGMGMSWIRQPPGKALEWLAHIFLN---DKKSYSTSLKNRLIISKDTSKSQVVLTMTNMDPVDTATYYCAWR",
+            "IGHV3-11*01": "QVQLVESGGGLVKPGGSLRLSCAASGFTF--SDYYMSWIRQAPGKGLEWVSYISSS--GSTIYYADSVKGRFTISRDNAKNSLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-11*03": "QVQLLESGGGLVKPGGSLRLSCAASGFTF--SDYYMSWIRQAPGKGLEWVSYISSS--SSYTNYADSVKGRFTISRDNAKNSLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-11*04": "QVQLVESGGGLVKPGGSLRLSCAASGFTF--SDYYMSWIRQAPGKGLEWVSYISSS--GSTIYYADSVKGRFTISRDNAKNSLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-11*05": "QVQLVESGGGLVKPGGSLRLSCAASGFTF--SDYYMSWIRQAPGKGLEWVSYISSS--SSYTNYADSVKGRFTISRDNAKNSLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-11*06": "QVQLVESGGGLVKPGGSLRLSCAASGFTF--SDYYMSWIRQAPGKGLEWVSYISSS--SSYTNYADSVKGRFTISRDNAKNSLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-13*01": "EVQLVESGGGLVQPGGSLRLSCAASGFTF--SSYDMHWVRQATGKGLEWVSAIGTA---GDTYYPGSVKGRFTISRENAKNSLYLQMNSLRAGDTAVYYCAR-",
+            "IGHV3-13*02": "EVHLVESGGGLVQPGGALRLSCAASGFTF--SNYDMHWVRQATGKGLEWVSANGTA---GDTYYPGSVKGRFTISRENAKNSLYLQMNSLRAGDTAVYYCAR-",
+            "IGHV3-13*03": "EVQLVESGGGLVQPGGSLRLSCAACGFTF--SSYDMHWVRQATGKGLEWVSAIGTA---GDTYYPGSVKGQFTISRENAKNSLYLQMNSLRAGDTAVYYCAR-",
+            "IGHV3-13*04": "EVQLVESGGGLVQPGGSLRLSCAASGFTF--SSYDMHWVRQATGKGLEWVSAIGTA---GDTYYPGSVKGRFTISRENAKNSLYLQMNSLRAGDTAVYYCAR-",
+            "IGHV3-13*05": "EVQLVESGGGLVQPGGSLRLSCAASGFTF--SSYDMHWVRQATGKGLEWVSAIGTA---GDPYYPGSVKGRFTISRENAKNSLYLQMNSLRAGDTAVYYCAR-",
+            "IGHV3-15*01": "EVQLVESGGGLVKPGGSLRLSCAASGFTF--SNAWMSWVRQAPGKGLEWVGRIKSKTDGGTTDYAAPVKGRFTISRDDSKNTLYLQMNSLKTEDTAVYYCTT-",
+            "IGHV3-15*02": "EVQLVESGGALVKPGGSLRLSCAASGFTF--SNAWMSWVRQAPGKGLEWVGRIKSKTDGGTTDYAAPVKGRFTISRDDSKNTLYLQMNSLKTEDTAVYYCTT-",
+            "IGHV3-15*03": "EVQLVESAGALVQPGGSLRLSCAASGFTC--SNAWMSWVRQAPGKGLEWVGRIKSKANGGTTDYAAPVKGRFTISRVDSKNTLYLQMNSLKTEDTAVYYCTT-",
+            "IGHV3-15*04": "EVQLVESGGGLVKPGGSLRLSCAASGFTF--SNAWMSWVRQAPGKGLEWVGRIESKTDGGTTDYAAPVKGRFTISRDDSKNTLYLQMNSLKTEDTAVYYCTT-",
+            "IGHV3-15*05": "EVQLVESGGGLVKPGGSLRLSCAASGFTF--SNAWMSWVRQAPGKGLEWVGRIKSKTDGGTTDYAAPVKGRFTISRDDSKNTLYLQMNSLKTEDTAVYYCTT-",
+            "IGHV3-15*06": "EVQLVESGGGLVKPGGSLRLSCAASGFTF--SNAWMSWVRQAPGKGLEWVGRIKSKTDGGTTNYAAPVKGRFTISRDDSKNTLYLQMNSLKTEDTAVYYCTT-",
+            "IGHV3-15*07": "EVQLVESGGGLVKPGGSLRLSCAASGFTF--SNAWMNWVRQAPGKGLEWVGRIKSKTDGGTTDYAAPVKGRFTISRDDSKNTLYLQMNSLKTEDTAVYYCTT-",
+            "IGHV3-15*08": "EVQLVESAGGLVQPGGSLRLSCAASGFTC--SNAWMSWVRQAPGKGLEWVGCIKSKANGGTTDYAAPVKGRFTISRDDSKNTLYLQMISLKTEDTAVYYCTT-",
+            "IGHV3-16*01": "EVQLVESGGGLVQPGGSLRLSCAASGFTF--SNSDMNWARKAPGKGLEWVSGVSWN--GSRTHYVDSVKRRFIISRDNSRNSLYLQKNRRRAEDMAVYYCVR-",
+            "IGHV3-16*02": "EVQLVESGGGLVQPGGSLRLSCAASGFTF--SNSDMNWARKAPGKGLEWVSGVSWN--GSRTHYVDSVKRRFIISRDNSRNSLYLQKNRRRAEDMAVYYCVR-",
+            "IGHV3-19*01": "TVQLVESGGGLVEPGGSLRLSCAASGFTF--SNSDMNWVRQAPGKGLEWVSGVSWN--GSRTHYADSVKGRFIISRDNSRNFLYQQMNSLRPEDMAVYYCVR-",
+            "IGHV3-20*01": "EVQLVESGGGVVRPGGSLRLSCAASGFTF--DDYGMSWVRQAPGKGLEWVSGINWN--GGSTGYADSVKGRFTISRDNAKNSLYLQMNSLRAEDTALYHCAR-",
+            "IGHV3-20*02": "EVQLVESGGGVVRPGGSLRLSFAASGFTF--DDYGMSWVRQAPGKGLEWVSGINWN--GGSTGYADSVKGRFTISRDNAKNSLYLQMNSLRAEDTALYHCAR-",
+            "IGHV3-20*03": "EVQLVESGGGVVRPGGSLRLSFAASGFTF--DDYGMSWVRQAPGKGLEWVSGINWN--GGSTGYADSVKGRFTISRDNAKNSLYLQMNSLRAEDTALYYCAR-",
+            "IGHV3-20*04": "EVQLVESGGGVVRPGGSLRLSCAASGFTF--DDYGMSWVRQAPGKGLEWVSGINWN--GGSTGYADSVKGRFTISRDNAKNSLYLQMNSLRAEDTALYYCAR-",
+            "IGHV3-21*01": "EVQLVESGGGLVKPGGSLRLSCAASGFTF--SSYSMNWVRQAPGKGLEWVSSISSS--SSYIYYADSVKGRFTISRDNAKNSLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-21*02": "EVQLVESGGGLVKPGGSLRLSCAASGFTF--SSYSMNWVRQAPGKGLEWVSSISSS--SSYIYYADSVKGRFTISRDNAKNSLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-21*03": "EVQLVESGGGLVKPGGSLRLSCAASGFTF--SSYSMNWVRQAPGKGLEWVSSISSS--SSYIYYADSVKGRFTISRDNAKNSLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-21*04": "EVQLVESGGGLVKPGGSLRLSCAASGFTF--SSYSMNWVRQAPGKGLEWVSSISSS--SSYIYYADSVKGRFTISRDNAKNSLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-21*05": "EVQLVESGGGLVKPGGSLRLSCAASGFTF--SSYSMNWVRQAPGKGLEWVSYISSS--SSYIYYADSVKGRFTISRDNAKNSLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-21*06": "EVQLVESGGGLVKPGGSLRLSCAASGFTF--SSYSMNWVRQAPGKGLEWVSSISSS--SSYIYYADSVKGRFTISRDNAKNSLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-22*01": "EVHLVESGGALVQPGGSLRLSCAASGFTF--SYYYMSGVRQAPGKGLEWVGFIRNKANGGTTE-TTSVKGRFTISRDDSKSITYLQMKSLKTEDTAVYYCSR-",
+            "IGHV3-22*02": "EVQLVESGGGLVQPGGSLRLSCAASGFTF--SYYYMSGVRQAPGKGLEWVGFIRNKANGGTTE-TTSVKGRFTISRDDSKSITYLQMKSLKTEDTAVYYCSR-",
+            "IGHV3-23*01": "EVQLLESGGGLVQPGGSLRLSCAASGFTF--SSYAMSWVRQAPGKGLEWVSAISGS--GGSTYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAK-",
+            "IGHV3-23*02": "EVQLLESGGGLVQPGGSLRLSCAASGFTF--SSYAMSWVRQAPGKGLEWVSAISGS--GGSTYYGDSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAK-",
+            "IGHV3-23*03": "EVQLLESGGGLVQPGGSLRLSCAASGFTF--SSYAMSWVRQAPGKGLEWVSVIYSG--GSSTYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAK-",
+            "IGHV3-23*04": "EVQLVESGGGLVQPGGSLRLSCAASGFTF--SSYAMSWVRQAPGKGLEWVSAISGS--GGSTYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAK-",
+            "IGHV3-23D*01": "EVQLLESGGGLVQPGGSLRLSCAASGFTF--SSYAMSWVRQAPGKGLEWVSAISGS--GGSTYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAK-",
+            "IGHV3-25*01": "EMQLVESGGGLQKPAWSPRLSCAASQFTF--SSYYMNCVRQAPGNGLELV-QVNPN--GGSTYLIDSGKDRFNTSRDNAKNTLHLQMNSLKTEDTALY-CTR-",
+            "IGHV3-25*02": "EMQLVESGGGLAKPAWSPRLSCAASQFTF--SSYYMNCVRQAPGNGLELV-QVNPN--GGSTYLIDSGKDRFNTSRDNAKNTLHLQMNSLKTEDTALY-CTR-",
+            "IGHV3-25*04": "ETQLVESGGGLAKPGRSPRLSCAASQFTF--SSYYMNCVRQAPGNGLELVGQVNPN--GGSTYLIDSGKDRFNTSRDNAKNTLHLQMNSLKTEDTALYYCTR-",
+            "IGHV3-25*05": "EMQLVESGGGLAKPAWSPRLSCAASQFTF--SSYYMNCVRQAPGNGLELVGQVNPN--GGSTYLIDSGKDRFNTSRDNAKNTLHLQMNSLKTEDTALY-CTR-",
+            "IGHV3-29*01": "EVELIEPTEDLRQPGKFLRLSCVASRFAF--SSF-MSPVHQSAGKGLE-VIDIKDD--GSQIHHADSVKGRFSISKDNAKNSLYLQMNSQRTEDMAVYGCT-G",
+            "IGHV3-30*01": "QVQLVESGGGVVQPGRSLRLSCAASGFTF--SSYAMHWVRQAPGKGLEWVAVISYD--GSNKYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-30*02": "QVQLVESGGGVVQPGGSLRLSCAASGFTF--SSYGMHWVRQAPGKGLEWVAFIRYD--GSNKYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAK-",
+            "IGHV3-30*03": "QVQLVESGGGVVQPGRSLRLSCAASGFTF--SSYGMHWVRQAPGKGLEWVAVISYD--GSNKYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-30*04": "QVQLVESGGGVVQPGRSLRLSCAASGFTF--SSYAMHWVRQAPGKGLEWVAVISYD--GSNKYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-30*05": "QVQLVESGGGVVQPGRSLRLSCAASGFTF--SSYGMHWVRQAPGKGLEWVAVISYD--GSNKYYADSVKGRFTISRDNSKNTLYLQMNSLRAEGTAVYYCAR-",
+            "IGHV3-30*06": "QVQLVESGGGVVQPGRSLRLSCAASGFTF--SSYGMHWVRQAPGKGLEWVAVISYD--GSNKYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-30*07": "QVQLVESGGGVVQPGRSLRLSCAASGFTF--SSYAMHWVRQAPGKGLEWVAVISYD--GSNKYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-30*08": "QVQLVDSGGGVVQPGRSLRLSCAASAFTF--SSYAMHWVRQAPGKGLEWVAVISYD--GSNKYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-30*09": "QVQLVESGGGVVQPGRSLRLSCAASGFTF--SSYAMHWVRQAPGKGLEWVAVISYD--GSNKYYADSVKGRFAISRDNSKNTLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-30*10": "QVQLVESGGGVVQPGRSLRLSCAASGFTF--SSYAMHWVRQAPGKGLEWVAVISYD--GSNKYYTDSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-30*11": "QVQLVESGGGVVQPGRSLRLSCAASGFTF--SSYAMHWVRQAPGKGLEWVAVISYD--GSNKYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-30*12": "QVQLVESGGGVVQPGRSLRLSCAASGFTF--SSYGMHWVRQAPGKGLEWVAVISYD--GSNKYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-30*13": "QVQLVESGGGVVQPGRSLRLSCAASGFTF--SSYGMHWVRQAPGKGLEWVAVISYD--GSNKYYADSVKGRFTISRDNSKNRLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-30*14": "QVQLVESGGGVVQPGRSLRLSCAASGFTF--SSYAMHWVRQAPGKGLEWVAVISYD--GSNKYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-30*15": "QVQLVESGGGVVQPGRSLRLSCAASGFTF--SSYAMHWVRQAPGKGLEWVAVISYD--GSNKYYADSVKGRFTISRDNSKNTLYLQMSSLRAEDTAVYYCAR-",
+            "IGHV3-30*16": "QVQLVESGGGVVQPGRSLRLSCAASGFTF--SSYAMHWVRQAPGKGLEWVAVISYD--GSNKYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-30*17": "QVQLVESGGGVVQPGRSLRLSCAASGFTF--SSYAMHWVRQAPGKGLEWVAVISYD--GSNKYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-30*18": "QVQLVESGGGVVQPGRSLRLSCAASGFTF--SSYGMHWVRQAPGKGLEWVAVISYD--GSNKYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAK-",
+            "IGHV3-30*19": "QVQLVESGGGVVQPGRSLRLSCAASGFTF--SSYGMHWVRQAPGKGLEWVAVISYD--GSNKYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-30-2*01": "EVQLVESGEDPRQPGGSLRLSCADSGLTF--SSY-RNSVSQAPGKGLE-VVDIQCD--GSQICYA-SLKSKFTISKENAKNSLYLLMNSLRAAGTAVCYCM-G",
+            "IGHV3-30-22*01": "EVELIESIEDLRQPGKFLRLSCVASRFAF--SSF-MSRVHQSPGKGLE-VIDIKDD--GSQIHHADSVKGRFSISKDNAKNSLYLQMNSQRAEDMDVYGCT-G",
+            "IGHV3-30-3*01": "QVQLVESGGGVVQPGRSLRLSCAASGFTF--SSYAMHWVRQAPGKGLEWVAVISYD--GSNKYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-30-3*02": "QVQLVESGGGVVQPGRSLRLSCAASGFTF--SSYAMHWVRQAPGKGLEWVAVISYD--GSNKYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAK-",
+            "IGHV3-30-3*03": "QVQLVESGGGVVQPGRSLRLSCAASGFTF--SSYAMHWVRQAPGKGLEWVAVISYD--GSNKYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-30-33*01": "EVQLVESGEDPRQPGGSLRLSCADSGLTF--SSY-RSSVSQAPGKGLE-VVDIQCD--GSQICYA-SLKSKFTISKENAKNSLYLLMNSLRAEGTAVCYCM--",
+            "IGHV3-30-42*01": "EVELIEPTEDLRQPGKFLRLSCVASRFAF--SSF-MSPVHQSAGKGLE-VIDIKDD--GSQIHHADSVKGRFSISKDNAKNSLYLQMNSQRTEDMAVYGCT-G",
+            "IGHV3-30-5*01": "QVQLVESGGGVVQPGRSLRLSCAASGFTF--SSYGMHWVRQAPGKGLEWVAVISYD--GSNKYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAK-",
+            "IGHV3-30-5*02": "QVQLVESGGGVVQPGGSLRLSCAASGFTF--SSYGMHWVRQAPGKGLEWVAFIRYD--GSNKYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAK-",
+            "IGHV3-30-52*01": "EVQLVESGEDPRQPGGSLRLSCADSGLTF--SSY-RNSVSQAPGKGLE-VVDIQCD--GSQICYA-SLKSKFTISKENAKNSLYLLMNSLRAAGTAVCYCM--",
+            "IGHV3-32*01": "EVELIESIEDLRQPGKFLRLSCVASRFAF--SSF-MSRVHQSPGKGLE-VIDIKDD--GSQIHHADSVKGRFSISKDNAKNSLYLQMNTQRAEDVAVYGYT-G",
+            "IGHV3-33*01": "QVQLVESGGGVVQPGRSLRLSCAASGFTF--SSYGMHWVRQAPGKGLEWVAVIWYD--GSNKYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-33*02": "QVQLVESGGGVVQPGRSLRLSCAASGFTF--SSYGMHWVRQAPGKGLEWVAVIWYD--GSNKYYADSAKGRFTISRDNSTNTLFLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-33*03": "QVQLVESGGGVVQPGRSLRLSCAASGFTF--SSYGMHWVRQAPGKGLEWVAVIWYD--GSNKYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAK-",
+            "IGHV3-33*04": "QVQLVESGGGVVQPGRSLRLSCAASGFTF--SSYGMHWVRQAPGKGLEWVAVIWYD--GSNKYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-33*05": "QVQLVESGGGVVQPGRSLRLSCAASGFTF--SSYGMHWVRQAPGKGLEWVAVISYD--GSNKYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-33*06": "QVQLVESGGGVVQPGRSLRLSCAASGFTF--SSYGMHWVRQAPGKGLEWVAVIWYD--GSNKYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAK-",
+            "IGHV3-33*07": "QVQLVESGGRVVQPGRSLRLSCAASGFTF--SRYGMYWVRQAPGKGLEWVAVIWYD--GSNKYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-33-2*01": "EVQLVESGEDPRQPGGSLRLSCADSGLTF--SSY-MSSVSQAPGKGLE-VVDIQCD--GSQICYAQSVKSKFTISKENAKNSLYLQMNSLRAEGTAVCYCM-G",
+            "IGHV3-35*01": "EVQLVESGGGLVQPGGSLRLSCAASGFTF--SNSDMNWVHQAPGKGLEWVSGVSWN--GSRTHYADSVKGRFIISRDNSRNTLYLQTNSLRAEDTAVYYCVR-",
+            "IGHV3-38*01": "EVQLVESGGGLVQPRGSLRLSCAASGFTV--SSNEMSWIRQAPGKGLEWVSSISG----GSTYYADSRKGRFTISRDNSKNTLYLQMNNLRAEGTAAYYCARY",
+            "IGHV3-38*02": "EVQLVESGGGLVQPRGSLRLSCAASGFTV--SSNEMSWIRQAPGKGLEWVSSISG----GSTYYADSRKGRFTISRDNSKNTLYLQMNNLRAEGTAVYYCARY",
+            "IGHV3-38*03": "EVQLVESGGGLVQPRGSLRLSCAASGFTV--SSNEMSWIRQAPGKGLEWVSSISG----GSTYYADSRKGRFTISRDNSKNTLYLQMNNLRAEGTAVYYCARY",
+            "IGHV3-38-3*01": "EVQLVESRGVLVQPGGSLRLSCAASGFTV--SSNEMSWVRQAPGKGLEWVSSISG----GSTYYADSRKGRFTISRDNSKNTLHLQMNSLRAEDTAVYYCKK-",
+            "IGHV3-41*02": "EVQLVESGGGLVQPGGSLRLSCAASGFSF--SSYGMSWVRQAPGKGLD-VAHIWND--GSQKYYADSVKGRFTISRDNSKSMLYLQMDSLKAKDTAMYYCTR-",
+            "IGHV3-43*01": "EVQLVESGGVVVQPGGSLRLSCAASGFTF--DDYTMHWVRQAPGKGLEWVSLISWD--GGSTYYADSVKGRFTISRDNSKNSLYLQMNSLRTEDTALYYCAKD",
+            "IGHV3-43*02": "EVQLVESGGGVVQPGGSLRLSCAASGFTF--DDYAMHWVRQAPGKGLEWVSLISGD--GGSTYYADSVKGRFTISRDNSKNSLYLQMNSLRTEDTALYYCAKD",
+            "IGHV3-43D*03": "EVQLVESGGVVVQPGGSLRLSCAASGFTF--DDYAMHWVRQAPGKGLEWVSLISWD--GGSTYYADSVKGRFTISRDNSKNSLYLQMNSLRAEDTALYYCAKD",
+            "IGHV3-43D*04": "EVQLVESGGVVVQPGGSLRLSCAASGFTF--DDYAMHWVRQAPGKGLEWVSLISWD--GGSTYYADSVKGRFTISRDNSKNSLYLQMNSLRAEDTALYYCAKD",
+            "IGHV3-47*01": "EDQLVESGGGLVQPGGSLRPSCAASGFAF--SSYALHWVRRAPGKGLEWVSAIGTG---GDTYYADSVMGRFTISRDNAKKSLYLHMNSLIAEDMAVYYCAR-",
+            "IGHV3-47*02": "EDQLVESGGGLVQPGGSLRPSCAASGFAF--SSYVLHWVRRAPGKGPEWVSAIGTG---GDTYYADSVMGRFTISRDNAKKSLYLQMNSLIAEDMAVYYCAR-",
+            "IGHV3-48*01": "EVQLVESGGGLVQPGGSLRLSCAASGFTF--SSYSMNWVRQAPGKGLEWVSYISSS--SSTIYYADSVKGRFTISRDNAKNSLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-48*02": "EVQLVESGGGLVQPGGSLRLSCAASGFTF--SSYSMNWVRQAPGKGLEWVSYISSS--SSTIYYADSVKGRFTISRDNAKNSLYLQMNSLRDEDTAVYYCAR-",
+            "IGHV3-48*03": "EVQLVESGGGLVQPGGSLRLSCAASGFTF--SSYEMNWVRQAPGKGLEWVSYISSS--GSTIYYADSVKGRFTISRDNAKNSLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-48*04": "EVQLVESGGGLVQPGGSLRLSCAASGFTF--SSYSMNWVRQAPGKGLEWVSYISSS--SSTIYYADSVKGRFTISRDNAKNSLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-49*01": "EVQLVESGGGLVQPGRSLRLSCTASGFTF--GDYAMSWFRQAPGKGLEWVGFIRSKAYGGTTEYTASVKGRFTISRDGSKSIAYLQMNSLKTEDTAVYYCTR-",
+            "IGHV3-49*02": "EVQLVESGGGLVQPGPSLRLSCTASGFTF--GYYPMSWVRQAPGKGLEWVGFIRSKAYGGTTEYAASVKGRFTISRDDSKSIAYLQMNSLKTEDTAVYYCTR-",
+            "IGHV3-49*03": "EVQLVESGGGLVQPGRSLRLSCTASGFTF--GDYAMSWFRQAPGKGLEWVGFIRSKAYGGTTEYAASVKGRFTISRDDSKSIAYLQMNSLKTEDTAVYYCTR-",
+            "IGHV3-49*04": "EVQLVESGGGLVQPGRSLRLSCTASGFTF--GDYAMSWVRQAPGKGLEWVGFIRSKAYGGTTEYAASVKGRFTISRDDSKSIAYLQMNSLKTEDTAVYYCTR-",
+            "IGHV3-49*05": "EVQLVESGGGLVKPGRSLRLSCTASGFTF--GDYAMSWFRQAPGKGLEWVGFIRSKAYGGTTEYAASVKGRFTISRDDSKSIAYLQMNSLKTEDTAVYYCTR-",
+            "IGHV3-52*01": "EVQLVESG-GLVQPGGSLRLSCAASGFTF--SSSWMHWVCQAPEKGLEWVADIKCD--GSEKYYVDSVKGRLTISRDNAKNSLYLQVNSLRAEDMTVYYCVR-",
+            "IGHV3-52*03": "EVQLVESG-GLVQPGGSLRLSCAASGFTF--SSSWMHWVCQAPEKGLEWVADIKCD--GSEKYYVDSVKGRLTISRDNAKNSLYLQVNSLRAEDMTVYYCVR-",
+            "IGHV3-53*01": "EVQLVESGGGLIQPGGSLRLSCAASGFTV--SSNYMSWVRQAPGKGLEWVSVIYSG---GSTYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-53*02": "EVQLVETGGGLIQPGGSLRLSCAASGFTV--SSNYMSWVRQAPGKGLEWVSVIYSG---GSTYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-53*03": "EVQLVESGGGLIQPGGSLRLSCAASGFTV--SSNYMSWVRQPPGKGLEWVSVIYSG---GSTYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-53*04": "EVQLVESGGGLVQPGGSLRLSCAASGFTV--SSNYMSWVRQAPGKGLEWVSVIYSG---GSTYYADSVKGRFTISRHNSKNTLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-53*05": "EVQLVETGGGLIQPGGSLRLSCAASGFTV--SSNYMSWVRQAPGKGLEWVSVIYSG---GSTYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-54*01": "EVQLVESEENQRQLGGSLRLSCADSGLTF--SSY-MSSDSQAPGKGLE-VVDI--D--RSQLCYAQSVKSRFTISKENAKNSLCLQMNSLRAEGTAVYYCM--",
+            "IGHV3-54*02": "EVQLVESEENQRQLGGSLRLSCADSGLTF--SSY-MSSDSQAPGKGLE-VVDI-YD--RSQICYAQSVKSRFTISKENAKNSLRLQMNSLRAEGTAVYYCM--",
+            "IGHV3-54*04": "EVQLVESEENQRQLGGSLRLSCADSGLTF--SSY-MSSDSQAPGKGLE-VVDI--D--RSQLCYAQSVKSRFTISKENAKNSLCLQMNSLRAEGTAVYYCM--",
+            "IGHV3-62*01": "EVQLVESGEGLVQPGGSLRLSCAASGFTF--SSSAMHWVRQAPRKGL-WVSVISTS--GDTVLYTDSVKGRFTISRDNAQNSLSLQMNSLRAEGTVVYYCVK-",
+            "IGHV3-62*03": "EVQLVESGEGLVQPGGSLRLSCAASGFTF--SSSAMHWVRQAPRKGL-WVSVISTS--GDTVLYTDSVKGRFTISRDNAQNSLYLQMNSLRADDMAVYYCVK-",
+            "IGHV3-62*04": "EVQLVKSGGGLVQPGGSLRLSCAASGFTF--SSSAMHWVRQAPRKGLEWVSVISTS--GDTVLYTDSVKGRFTISRDNAQNSLSLQMNSLRAEDMAVYYCVK-",
+            "IGHV3-63*01": "EVELIESIEGLRQLGKFLRLSCVASGFTF--SSY-MSWVNETLGKGLEGVIDVKYD--GSQIYHADSVKGRFTISKDNAKNSPYLQTNSLRAEDMTMHGCT-G",
+            "IGHV3-64*01": "EVQLVESGGGLVQPGGSLRLSCAASGFTF--SSYAMHWVRQAPGKGLEYVSAISSN--GGSTYYANSVKGRFTISRDNSKNTLYLQMGSLRAEDMAVYYCAR-",
+            "IGHV3-64*02": "EVQLVESGEGLVQPGGSLRLSCAASGFTF--SSYAMHWVRQAPGKGLEYVSAISSN--GGSTYYADSVKGRFTISRDNSKNTLYLQMGSLRAEDMAVYYCAR-",
+            "IGHV3-64*03": "EVQLVESGGGLVQPGGSLRLSCSASGFTF--SSYAMHWVRQAPGKGLEYVSAISSN--GGSTYYADSVKGRFTISRDNSKNTLYVQMSSLRAEDTAVYYCVK-",
+            "IGHV3-64*04": "QVQLVESGGGLVQPGGSLRLSCSASGFTF--SSYAMHWVRQAPGKGLEYVSAISSN--GGSTYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-64*05": "EVQLVESGGGLVQPGGSLRLSCSASGFTF--SSYAMHWVRQAPGKGLEYVSAISSN--GGSTYYADSVKGRFTISRDNSKNTLYVQMSSLRAEDTAVYYCVK-",
+            "IGHV3-64*07": "EVQLVESGGGLVQPGGSLRLSCAASGFTF--SSYAMHWVRQAPGKGLEYVSAISSN--GGSTYYADSVKGRFTISRDNSKNTLYLQMGSLRAEDMAVYYCAR-",
+            "IGHV3-64D*06": "EVQLVESGGGLVQPGGSLRLSCSASGFTF--SSYAMHWVRQAPGKGLEYVSAISSN--GGSTYYADSVKGRFTISRDNSKNTLYLQMSSLRAEDTAVYYCVK-",
+            "IGHV3-64D*08": "EVQLVESGGGLVQPGGSLRLSCSASGFTF--SSYAMHWVRQAPGKGLEYVSAISSN--GGSTYYADSVKGRFTISRDNSKNTLYLQMSSLRAEDTAVYYCVK-",
+            "IGHV3-64D*09": "EVQLVESGGGLVQPGGSLRLSCSASGFTF--SSYAMHWVRQAPGKGLEYVSAISSN--GGSTYYADSVKGRFTISRDNSKNTLYLQMSSLRAEDTAVYYCVK-",
+            "IGHV3-66*01": "EVQLVESGGGLVQPGGSLRLSCAASGFTV--SSNYMSWVRQAPGKGLEWVSVIYSG---GSTYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-66*02": "EVQLVESGGGLVQPGGSLRLSCAASGFTV--SSNYMSWVRQAPGKGLEWVSVIYSG---GSTYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-66*03": "EVQLVESGGGLIQPGGSLRLSCAASGFTV--SSNYMSWVRQAPGKGLEWVSVIYSC---GSTYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-66*04": "EVQLVESGGGLVQPGGSLRLSCAASGFTV--SSNYMSWVRQAPGKGLEWVSVIYSG---GSTYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-69-1*01": "EVQLVESGGGLVKPGGSLRLSCAASGFTF--SDYYMNWVRQAPGKGLEWVSSISSS---STIYYADSVKGRFTISRDNAKNSLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-69-1*02": "EVQLVESGGGLVKPGGSLRLSCAASGFTF--SDYYMNWVRQAPGKGLEWVSSISSS---STIYYADSVKGRFTISRDNAKNSLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-7*01": "EVQLVESGGGLVQPGGSLRLSCAASGFTF--SSYWMSWVRQAPGKGLEWVANIKQD--GSEKYYVDSVKGRFTISRDNAKNSLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-7*02": "EVQLVESGGGLVQPGGSLRLSCAASGFTF--SSYWMSWVRQAPGKGLEWVANIKQD--GSEKYYVDSVKGRFTISRDNAKNSLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-7*03": "EVQLVESGGGLVQPGGSLRLSCAASGFTF--SSYWMSWVRQAPGKGLEWVANIKQD--GSEKYYVDSVKGRFTISRDNAKNSLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-7*04": "EVQLVESGGGLVQPGGSLRLSCAASGFTF--SSYWMSWVRQAPGKGLEWVANIKQD--GSEKYYVDSVKGRFTISRDNAKNSLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-7*05": "EVQLVESGGGLVQPGGSLRLSCAASGFTF--SSYWMSWVRQAPGKGLEWVANIKQD--GSEKYYVDSVKGRFTISRDNAKNSLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-71*01": "EVQLVESGGGLVQPGGSLRLSCAASGFTF--SDYYMSWVRQAPGKGLEWVGFIRNKANGGTTE-TTSVKGRFTISRDDSKSITYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-71*02": "EVQLVESGGGLVQPGGSLRLSCAASGFTF--SDYYMSWVRQAPGKGLEWVGFIRNKANGGTTE-TTSVKGRFTISRDDSKSITYLQMNSLRAEDMAVYYCAR-",
+            "IGHV3-71*03": "EVQLVESGGGLVQPGGSLRLSCAASGFTF--SDYYMSWVRQAPGKGLEWVGFIRNKANGGTTE-TTSVKGRFTISRDDSKSITYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-71*04": "EVQLVESGGGLVQPGGSLRLSCAASGFTF--SDYYMSWVRQAPGKGLEWVGFIRNKANGGTTE-TTSVKGRFTISRDDSKSITYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-72*01": "EVQLVESGGGLVQPGGSLRLSCAASGFTF--SDHYMDWVRQAPGKGLEWVGRTRNKANSYTTEYAASVKGRFTISRDDSKNSLYLQMNSLKTEDTAVYYCAR-",
+            "IGHV3-73*01": "EVQLVESGGGLVQPGGSLKLSCAASGFTF--SGSAMHWVRQASGKGLEWVGRIRSKANSYATAYAASVKGRFTISRDDSKNTAYLQMNSLKTEDTAVYYCTR-",
+            "IGHV3-73*02": "EVQLVESGGGLVQPGGSLKLSCAASGFTF--SGSAMHWVRQASGKGLEWVGRIRSKANSYATAYAASVKGRFTISRDDSKNTAYLQMNSLKTEDTAVYYCTR-",
+            "IGHV3-74*01": "EVQLVESGGGLVQPGGSLRLSCAASGFTF--SSYWMHWVRQAPGKGLVWVSRINSD--GSSTSYADSVKGRFTISRDNAKNTLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-74*02": "EVQLVESGGGLVQPGGSLRLSCAASGFTF--SSYWMHWVRQAPGKGLVWVSRINSD--GSSTSYADSVKGRFTISRDNAKNTLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-74*03": "EVQLVESGGGLVQPGGSLRLSCAASGFTF--SSYWMHWVRQAPGKGLVWVSRINSD--GSSTTYADSVKGRFTISRDNAKNTLYLQMNSLRAEDTAVYYCAR-",
+            "IGHV3-9*01": "EVQLVESGGGLVQPGRSLRLSCAASGFTF--DDYAMHWVRQAPGKGLEWVSGISWN--SGSIGYADSVKGRFTISRDNAKNSLYLQMNSLRAEDTALYYCAKD",
+            "IGHV3-9*02": "EVQLVESGGGLVQPGRSLRLSCAASGFTS--DDYAMHWVRQAPGKGLEWVSGISWN--SGSIGYADSVKGRFTISRDNAKNSLYLQMNSLRAEDTALYYCAKD",
+            "IGHV3-9*03": "EVQLVESGGGLVQPGRSLRLSCAASGFTF--DDYAMHWVRQAPGKGLEWVSGISWN--SGSIGYADSVKGRFTISRDNAKNSLYLQMNSLRAEDMALYYCAKD",
+            "IGHV3-NL1*01": "QVQLVESGGGVVQPGGSLRLSCAASGFTF--SSYGMHWVRQAPGKGLEWVSVIYSG--GSSTYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAK-",
+            "IGHV3/OR15-7*01": "EVQLVESGGGLVQPGGSLRLSCAASGFTF--SDHYMSWVRQAQGKGLELVGLIRNKANSYTTEYAASVKGRLTISREDSKNTMYLQMSNLKTEDLAVYYCAR-",
+            "IGHV3/OR15-7*02": "EVQLLESGGGLVQPGGSLRLSCAASGFTF--SDHYMSWVRQAQGKGLELVGLIRNKANSYTTEYAASVKGRLTISREDSKNTLYLQMSSLKTEDLAVYYCAR-",
+            "IGHV3/OR15-7*03": "EVQLVESGGGLVQPGGSLRLSCAASGFTF--SDHYMSWVRQAQGKGLELVGLIRNKANSYTTEYAASVKGRLTISREDSKNTLYLQMSSLKTEDLAVYYCAR-",
+            "IGHV3/OR15-7*05": "EVQLVESGGGLVQPGGSLRLSCAASGFTF--SDHYMSWVRQAQGKGLELVGLIRNKANSYTTEYAASVKGRLTISREDSKNTLYLQMSNLKTEDLAVYYCAR-",
+            "IGHV3/OR16-10*01": "EVQLVQSGGGLVHPGGSLRLSCAGSGFTF--SSYAMHWVRQAPGKGLEWVSAIGTG---GGTYYADSVKGRFTISRDNAKNSLYLQMNSLRAEDMAVYYCAR-",
+            "IGHV3/OR16-10*02": "EVQLVQSGGGLVQPGGSLRLSCAGSGFTF--SSYAMHWVRQAPGKGLEWVSAIGTG---GGTYYADSVKGRFTISRDNAKNSLYLQMNSLRAEDMAVYYCAR-",
+            "IGHV3/OR16-10*03": "EVQLVESGGGLVQPGGSLRLSCAGSGFTF--SSYAMHWVRQAPGKGLEWVSAIGTG---GGTYYADSVKGRFTISRDNAKNSLYLQMNSLRAEDMAVYYCAR-",
+            "IGHV3/OR16-12*01": "EVQLVESGRGLAQPGGYLKLSGAASGFTV--GSWYMSWIHQAPGKGLEWVSYISSS--GCSTNYADSVKGRFTISTDNSKNTLYLQMNSLRVEDTAVYYCAR-",
+            "IGHV3/OR16-13*01": "EVQLVESGGGLVQPGGSLRLSCAASGFTF--SSYWMHWVRQAPGKGLVWVSRINSD--GSSTSYADSMKGQFTISRDNAKNTLYLQMNSLRAEDMAVYYCTR-",
+            "IGHV3/OR16-14*01": "EVQLEESGGGLVQPGGSLRLSCAASGFTF--SSYWMHWVRQSPGKGLV-VSRINSD--GSSTSYADSLKGQFTISRDNAKNTLYLQMNSLRAEDMAVYYCTR-",
+            "IGHV3/OR16-15*01": "EVQLVESGGGLVQPGGSLRLSCAASVFTF--SNSDINWVL-APGKGLEWVSGISWN--GGKTHYVDSVKGQFSISRDNSSKSLYLQKNRQRAKDMAVYYCVR-",
+            "IGHV3/OR16-15*02": "EVQLVESGGGLVQPGGSLRHSCAASGFTF--SNSDMNWVL-APGKGLEWVSGISWN--GGKTHYVDSVKGQFTISRDNSSKSLYLQKNRQRAKDMAVYYCVR-",
+            "IGHV3/OR16-16*01": "EVQLVESGGGLVQPGGSLRHSCAASGFTF--SNSDMNWVL-APGKGLEWVSDISWN--GGKTHYVDSVKGQFTISRDNSSKSLYLQKNRQRAKDMAVYYCVR-",
+            "IGHV3/OR16-17*01": "EVQLVESGGGLVQPGGSLRLSCPDSGFTF--SNHYMSWVRQAPGKGLEWISYISGD--SGYTNYADSVKGRFTISRDNANNSPYLQMNSLRAEDTAVYYCVK-",
+            "IGHV3/OR16-18*01": "EVQLVESGGGLVQPGGSLRLSCAASGFTF--SNSDMNWVL-APGKGLEWVSGISWN--GGKTHYVDSVKGQFTISRDNSSKSLYLQKNRQRAKDMAVYYCVR-",
+            "IGHV3/OR16-20*01": "EVQLVQSGGGLVQPGGSLRLSCAGSGFTF--SSYAMHWVRQAPGKGLEWVSAIGTG---GGTYYADSVKGRFTISRDNAKNSLYLQMNSLRAEDMAVYYCAR-",
+            "IGHV3/OR16-6*02": "EVQLVESAGGLGTAWGSLRLSCAASGFTC--SNAWMSWVRQAPGKGLEWVGCIKSKANGGTTDYAAPVKGRFTISRDDSKNTLYLQMISLKTEDTAVYYCTT-",
+            "IGHV3/OR16-8*01": "EVQLVESGGGLVQPGGSLRLSCPASGFTF--SNHYMSWVRQAPGKGLEWVSYISGD--SGYTNYADSVKGRFTISRDNANNSPYLQMNSLRAEDTAVYYCVK-",
+            "IGHV3/OR16-8*02": "EVQLVESGGGLVQPGGSLRLSCPDSGFTF--SNHYMSWVRQAPGKGLEWISYISGD--SGYTNYADSVKGRFTISRDNANNSPYLQMNSLRAEDTAVYYCVK-",
+            "IGHV3/OR16-9*01": "EVQLVESGGGLVQPGGSLRLSCAASGFTF--SNHYTSWVRQAPGKGLEWVSYSSGN--SGYTNYADSVKGRFTISRDNAKNSLYLQMNSLRAEDTAVYYCVK-",
+            "IGHV4-28*01": "QVQLQESGPGLVKPSDTLSLTCAVSGYSIS-SSNWWGWIRQPPGKGLEWIGYIYYS---GSTYYNPSLKSRVTMSVDTSKNQFSLKLSSVTAVDTAVYYCAR-",
+            "IGHV4-28*02": "QVQLQESGPGLVKPSQTLSLTCAVSGYSIS-SSNWWGWIRQPPGKGLEWIGYIYYS---GSIYYNPSLKSRVTMSVDTSKNQFSLKLSSVTAVDTAVYYCAR-",
+            "IGHV4-28*03": "QVQLQESGPGLVKPSDTLSLTCAVSGYSIS-SSNWWGWIRQPPGKGLEWIGYIYYS---GSTYYNPSLKSRVTMSVDTSKNQFSLKLSSVTAVDTAVYYCAR-",
+            "IGHV4-28*04": "QVQLQESGPGLVKPSDTLSLTCAVSGYSIS-SSNWWGWIRQPPGKGLEWIGYIYYS---GSTYYNPSLKSRVTMSVDTSKNQFSLKLSSVTAVDTGVYYCAR-",
+            "IGHV4-28*05": "QVQLQESGPGLVKPSDTLSLTCAVSGYSIS-SSNWWGWIRQPPGKGLEWIGYIYYS---GSIYYNPSLKSRVTMSVDTSKNQFSLKLSSVTAVDTAVYYCAR-",
+            "IGHV4-28*06": "QVQLQESGPGLVKPSDTLSLTCAVSGYSIS-SSNWWGWIRQPPGKGLEWIGYIYYS---GSTNYNPSLKSRVTMSVDTSKNQFSLKLSSVTALDTAVYYCAR-",
+            "IGHV4-28*07": "QVQLQESGPGLVKPSDTLSLTCAVSGYSIS-SSNWWGWIRQPPGKGLEWIGYIYYS---GSTYYNPSLKSRVTMSVDTSKNQFSLKLSSVTAVDTAVYYCAR-",
+            "IGHV4-30-2*01": "QLQLQESGSGLVKPSQTLSLTCAVSGGSISSGGYSWSWIRQPPGKGLEWIGYIYHS---GSTYYNPSLKSRVTISVDRSKNQFSLKLSSVTAADTAVYYCAR-",
+            "IGHV4-30-2*03": "QLQLQESGSGLVKPSQTLSLTCAVSGGSISSGGYSWSWIRQPPGKGLEWIGSIYYS---GSTYYNPSLKSRVTISVDTSKNQFSLKLSSVTAADTAVYYCAR-",
+            "IGHV4-30-2*05": "QLQLQESGSGLVKPSQTLSLTCAVSGGSISSGGYSWSWIRQPPGKGLEWIGYIYHS---GSTYYNPSLKSRVTISVDTSKNQFSLKLSSVTAADTAVYYCAR-",
+            "IGHV4-30-2*06": "QLQLQESGSGLVKPSQTLSLTCAVSGGSISSGGYSWSWIRQSPGKGLEWIGYIYHS---GSTYYNPSLKSRVTISVDRSKNQFSLKLSSVTAADTAVYYCAR-",
+            "IGHV4-30-4*01": "QVQLQESGPGLVKPSQTLSLTCTVSGGSISSGDYYWSWIRQPPGKGLEWIGYIYYS---GSTYYNPSLKSRVTISVDTSKNQFSLKLSSVTAADTAVYYCAR-",
+            "IGHV4-30-4*02": "QVQLQESGPGLVKPSDTLSLTCTVSGGSISSGDYYWSWIRQPPGKGLEWIGYIYYS---GSTYYNPSLKSRVTISVDTSKNQFSLKLSSVTAADTAVYYCAR-",
+            "IGHV4-30-4*07": "QVQLQESGPGLVKPSQTLSLTCAVSGGSISSGGYSWSWIRQPPGKGLEWIGYIYYS---GSTYYNPSLKSRVTISVDTSKNQFSLKLSSVTAADTAVYYCAR-",
+            "IGHV4-31*01": "QVQLQESGPGLVKPSQTLSLTCTVSGGSISSGGYYWSWIRQHPGKGLEWIGYIYYS---GSTYYNPSLKSLVTISVDTSKNQFSLKLSSVTAADTAVYYCAR-",
+            "IGHV4-31*02": "QVQLQESGPGLVKPSQTLSLTCTVSGGSISSGGYYWSWIRQHPGKGLEWIGYIYYS---GSTYYNPSLKSRVTISVDTSKNQFSLKLSSVTAADTAVYYCAR-",
+            "IGHV4-31*03": "QVQLQESGPGLVKPSQTLSLTCTVSGGSISSGGYYWSWIRQHPGKGLEWIGYIYYS---GSTYYNPSLKSRVTISVDTSKNQFSLKLSSVTAADTAVYYCAR-",
+            "IGHV4-31*10": "QVQLQESGPGLLKPSQTLSLTCTVSGGSISSGGYYWSWIRQHPGKGLEWIGCIYYS---GSTYYNPSLKSRVTISVDPSKNQFSLKPSSVTAADTAVDYCAR-",
+            "IGHV4-34*01": "QVQLQQWGAGLLKPSETLSLTCAVYGGSF--SGYYWSWIRQPPGKGLEWIGEINHS---GSTNYNPSLKSRVTISVDTSKNQFSLKLSSVTAADTAVYYCAR-",
+            "IGHV4-34*02": "QVQLQQWGAGLLKPSETLSLTCAVYGGSF--SGYYWSWIRQPPGKGLEWIGEINHS---GSTNYNPSLKSRVTISVDTSKNQFSLKLSSVTAADTAVYYCAR-",
+            "IGHV4-34*04": "QVQLQQWGAGLLKPSETLSLTCAVYGGSF--SGYYWSWIRQPPGKGLEWIGEINHS---GSTNNNPSLKSRATISVDTSKNQFSLKLSSVTAADTAVYYCAR-",
+            "IGHV4-34*05": "QVQLQQWGAGLLKPSETLSLTCAVYGGSF--SGYYWCWIRQPLGKGLEWIGEINHS---GSTNNNPSLKSRATISVDTSKNQFSLKLSSVTAADTAVYYCAR-",
+            "IGHV4-34*09": "QVQLQESGPGLVKPSQTLSLTCAVYGGSF--SGYYWSWIRQPPGKGLEWIGEINHS---GSTNYNPSLKSRVTISVDTSKNQFSLKLSSVTAADTAVYYCAR-",
+            "IGHV4-34*10": "QVQLQESGPGLVKPSETLSLTCAVYGGSF--SGYYWSWIRQPPGKGLEWIGEINHS---GSTNYNPSLKSRITMSVDTSKNQFYLKLSSVTAADTAVYYCAR-",
+            "IGHV4-34*11": "QVQLQQWGAGLLKPSETLSLTCAVYGGSV--SGYYWSWIRQPPGKGLEWIGYIYYS---GSTNNNPSLKSRATISVDTSKNQFSLNLSSVTAADTAVYCCAR-",
+            "IGHV4-34*12": "QVQLQQWGAGLLKPSETLSLTCAVYGGSF--SGYYWSWIRQPPGKGLEWIGEIIHS---GSTNYNPSLKSRVTISVDTSKNQFSLKLSSVTAADTAVYYCAR-",
+            "IGHV4-38-2*01": "QVQLQESGPGLVKPSETLSLTCAVSGYSIS-SGYYWGWIRQPPGKGLEWIGSIYHS---GSTYYNPSLKSRVTISVDTSKNQFSLKLSSVTAADTAVYYCAR-",
+            "IGHV4-38-2*02": "QVQLQESGPGLVKPSETLSLTCTVSGYSIS-SGYYWGWIRQPPGKGLEWIGSIYHS---GSTYYNPSLKSRVTISVDTSKNQFSLKLSSVTAADTAVYYCAR-",
+            "IGHV4-39*01": "QLQLQESGPGLVKPSETLSLTCTVSGGSISSSSYYWGWIRQPPGKGLEWIGSIYYS---GSTYYNPSLKSRVTISVDTSKNQFSLKLSSVTAADTAVYYCAR-",
+            "IGHV4-39*02": "QLQLQESGPGLVKPSETLSLTCTVSGGSISSSSYYWGWIRQPPGKGLEWIGSIYYS---GSTYYNPSLKSRVTISVDTSKNHFSLKLSSVTAADTAVYYCAR-",
+            "IGHV4-39*06": "RLQLQESGPGLVKPSETLSLTCTVSGGSISSSSYYWGWIRQPPGKGLEWIGSIYYS---GSTYYNPSLKSRVTISVDTSKNQFPLKLSSVTAADTAVYYCAR-",
+            "IGHV4-39*07": "QLQLQESGPGLVKPSETLSLTCTVSGGSISSSSYYWGWIRQPPGKGLEWIGSIYYS---GSTYYNPSLKSRVTISVDTSKNQFSLKLSSVTAADTAVYYCAR-",
+            "IGHV4-4*01": "QVQLQESGPGLVKPPGTLSLTCAVSGGSIS-SSNWWSWVRQPPGKGLEWIGEIYHS---GSTNYNPSLKSRVTISVDKSKNQFSLKLSSVTAADTAVYCCAR-",
+            "IGHV4-4*02": "QVQLQESGPGLVKPSGTLSLTCAVSGGSIS-SSNWWSWVRQPPGKGLEWIGEIYHS---GSTNYNPSLKSRVTISVDKSKNQFSLKLSSVTAADTAVYYCAR-",
+            "IGHV4-4*07": "QVQLQESGPGLVKPSETLSLTCTVSGGSI--SSYYWSWIRQPAGKGLEWIGRIYTS---GSTNYNPSLKSRVTMSVDTSKNQFSLKLSSVTAADTAVYYCAR-",
+            "IGHV4-4*08": "QVQLQESGPGLVKPSETLSLTCTVSGGSI--SSYYWSWIRQPPGKGLEWIGYIYTS---GSTNYNPSLKSRVTISVDTSKNQFSLKLSSVTAADTAVYYCAR-",
+            "IGHV4-55*01": "QVQLQESGPGLVKPSETLSLICAVSGDSIS-SGNW-IWVRQPPGKGLEWIGEIHHS---GSTYYNPSLKSRITMSVDTSKNQFYLKLSSVTAADTAVYYCAR-",
+            "IGHV4-55*02": "QVQLQESGPGLVKPSETLSLICAVSGDSIS-SGNW-IWVRQPPGKGLEWIGEIHHS---GSTYYNPSLKSRITMSVDTSKNQFYLKLSSVTAADTAVYYCAR-",
+            "IGHV4-55*08": "QVQLQESGPGLVKPSETLSLICAVSGDSIS-SGNW-IWVRQPPGKGLEWIGEIHHS---GSTYYNPSLKSRITMSVDTSKNQFYLKLSSVTAADTAVYYCAR-",
+            "IGHV4-55*09": "QVQLQESGPGLVKPSETLSLICAVSGDSIS-SGNW-IWVRQPPGKGLEWIGEIHHS---GSTYYNPSLKSRITMSVDTSKNQFSLKLSSVTAVDTAVYYCAR-",
+            "IGHV4-59*01": "QVQLQESGPGLVKPSETLSLTCTVSGGSI--SSYYWSWIRQPPGKGLEWIGYIYYS---GSTNYNPSLKSRVTISVDTSKNQFSLKLSSVTAADTAVYYCAR-",
+            "IGHV4-59*02": "QVQLQESGPGLVKPSETLSLTCTVSGGSV--SSYYWSWIRQPPGKGLEWIGYIYYS---GSTNYNPSLKSRVTISVDTSKNQFSLKLSSVTAADTAVYYCAR-",
+            "IGHV4-59*07": "QVQLQESGPGLVKPSDTLSLTCTVSGGSI--SSYYWSWIRQPPGKGLEWIGYIYYS---GSTNYNPSLKSRVTISVDTSKNQFSLKLSSVTAADTAVYYCAR-",
+            "IGHV4-59*08": "QVQLQESGPGLVKPSETLSLTCTVSGGSI--SSYYWSWIRQPPGKGLEWIGYIYYS---GSTNYNPSLKSRVTISVDTSKNQFSLKLSSVTAADTAVYYCAR-",
+            "IGHV4-59*10": "QVQLQQWGAGLLKPSETLSLTCAVYGGSI--SSYYWSWIRQPAGKGLEWIGRIYTS---GSTNYNPSLKSRVTMSVDTSKNQFSLKLSSVTAADTAVYYCAR-",
+            "IGHV4-59*11": "QVQLQESGPGLVKPSETLSLTCTVSGGSI--SSHYWSWIRQPPGKGLEWIGYIYYS---GSTNYNPSLKSRVTISVDTSKNQFSLKLSSVTAADTAVYYCAR-",
+            "IGHV4-59*13": "QVQLQESGPGLVKPSETLSLTCTVSGGSI--SSYYWSWIRQPPGKGLEWIGYIYYS---GSTNYNPSLKSRVTISVDTSKNQFSLKLSSVTAADTAVYYCAR-",
+            "IGHV4-61*01": "QVQLQESGPGLVKPSETLSLTCTVSGGSVSSGSYYWSWIRQPPGKGLEWIGYIYYS---GSTNYNPSLKSRVTISVDTSKNQFSLKLSSVTAADTAVYYCAR-",
+            "IGHV4-61*02": "QVQLQESGPGLVKPSQTLSLTCTVSGGSISSGSYYWSWIRQPAGKGLEWIGRIYTS---GSTNYNPSLKSRVTISVDTSKNQFSLKLSSVTAADTAVYYCAR-",
+            "IGHV4-61*03": "QVQLQESGPGLVKPSETLSLTCTVSGGSVSSGSYYWSWIRQPPGKGLEWIGYIYYS---GSTNYNPSLKSRVTISVDTSKNHFSLKLSSVTAADTAVYYCAR-",
+            "IGHV4-61*05": "QLQLQESGPGLVKPSETLSLTCTVSGGSISSSSYYWGWIRQPPGKGLEWIGYIYYS---GSTNYNPSLKSRVTISVDKSKNQFSLKLSSVTAADTAVYYCAR-",
+            "IGHV4-61*08": "QVQLQESGPGLVKPSETLSLTCTVSGGSVSSGGYYWSWIRQPPGKGLEWIGYIYYS---GSTNYNPSLKSRVTISVDTSKNQFSLKLSSVTAADTAVYYCAR-",
+            "IGHV4-61*09": "QVQLQESGPGLVKPSQTLSLTCTVSGGSISSGSYYWSWIRQPAGKGLEWIGHIYTS---GSTNYNPSLKSRVTISVDTSKNQFSLKLSSVTAADTAVYYCAR-",
+            "IGHV4/OR15-8*01": "QVQLQESGPGLVKPSETLSLTCVVSGGSIS-SSNWWSWVRQPPGKGLEWIGEIYHS---GSPNYNPSLKSRVTISVDKSKNQFSLKLSSVTAADTAVYYCAR-",
+            "IGHV4/OR15-8*02": "QVQLQESGPGLVKPSETLSLTCVVSGGSIS-SSNWWSWVRQPPGKGLEWIGEIYHS---GNPNYNPSLKSRVTISIDKSKNQFSLKLSSVTAADTAVYYCAR-",
+            "IGHV4/OR15-8*03": "QVQLQESGPGLVKPSETLSLTCVVSGGSIS-SSNWWSWVRQPPGKGLEWIGEIYHS---GSPNYNPSLKSRVTISVDKSKNQFSLKLSSVTAADTAVYYCAR-",
+            "IGHV5-10-1*01": "EVQLVQSGAEVKKPGESLRISCKGSGYSF--TSYWISWVRQMPGKGLEWMGRIDPS--DSYTNYSPSFQGHVTISADKSISTAYLQWSSLKASDTAMYYCAR-",
+            "IGHV5-10-1*02": "EVQLVQSGAEVKKPGESLRISCKGSGYSF--TSYWISWVRQMPGKGLEWMGRIDPS--DSYTNYSPSFQGHVTISADKSISTAYLQWSSLKASDTAMYYCAR-",
+            "IGHV5-10-1*03": "EVQLVQSGAEVKKPGESLRISCKGSGYSF--TSYWISWVRQMPGKGLEWMGRIDPS--DSYTNYSPSFQGHVTISADKSISTAYLQWSSLKASDTAMYYCAR-",
+            "IGHV5-10-1*04": "EVQLVQSGAEVKKPGESLRISCKGSGYSF--TSYWISWVRQMPGKGLEWMGRIDPS--DSYTNYSPSFQGQVTISADKSISTAYLQWSSLKASDTAMYYCAR-",
+            "IGHV5-51*01": "EVQLVQSGAEVKKPGESLKISCKGSGYSF--TSYWIGWVRQMPGKGLEWMGIIYPG--DSDTRYSPSFQGQVTISADKSISTAYLQWSSLKASDTAMYYCAR-",
+            "IGHV5-51*02": "EVQLVQSGAEVKKPGESLKISCKGSGYSF--TSYWTGWVRQMPGKGLEWMGIIYPG--DSDTRYSPSFQGQVTISADKSISTAYLQWSSLKASDTAMYYCAR-",
+            "IGHV5-51*03": "EVQLVQSGAEVKKPGESLKISCKGSGYSF--TSYWIGWVRQMPGKGLEWMGIIYPG--DSDTRYSPSFQGQVTISADKSISTAYLQWSSLKASDTAMYYCAR-",
+            "IGHV5-51*04": "EVQLVQSGAEVKKPGESLKISCKGSGYSF--TSYWIGWVRQMPGKGLEWMGIIYPG--DSDTRYSPSFQGQVTISADKPISTAYLQWSSLKASDTAMYYCAR-",
+            "IGHV5-51*07": "EVQLVQSGAEVKKPGESLKISCKGSGYSF--TSYWIGWVHQMPGKGLEWMGIIYPG--DSDTRYSPSFQGQVTISADKSISTAYLQWSSLKASDTAMYYCAR-",
+            "IGHV5-78*01": "EVQLLQSAAEVKRPGESLRISCKTSGYSF--TSYWIHWVRQMPGKELEWMGSIYPG--NSDTRYSPSFQGHVTISADSSSSTAYLQWSSLKASDAAMYYCVR-",
+            "IGHV6-1*01": "QVQLQQSGPGLVKPSQTLSLTCAISGDSVSSNSAAWNWIRQSPSRGLEWLGRTYYRS-KWYNDYAVSVKSRITINPDTSKNQFSLQLNSVTPEDTAVYYCAR-",
+            "IGHV6-1*02": "QVQLQQSGPGLVKPSQTLSLTCAISGDSVSSNSAAWNWIRQSPSRGLEWLGRTYYRS-KWYNDYAVSVKSRITINPDTSKNQFSLQLNSVTPEDTAVYYCAR-",
+            "IGHV6-1*03": "QVQLQQSGPGLVKPSQTLSLTCAISGDSVSSNSAAWNWIRQSPSRGLEWLGRTYYRS-KWYNDYAVSVKS-ITINPDTSKNQFSLQLNSVTPEDTAVYYCAR-",
+            "IGHV7-34-1*01": "-LQLVQSGPEVKKPGASVKVSYKSSGYTF--TIYGMNWV--TPGQGFEWM-WIITY--TGNPTYTHGFTGWFVFSMDTSVSTACLQISSLKAEDTAEYYCAK-",
+            "IGHV7-34-1*02": "-LQLVQSGPEVKKPGASVKVSYKSSGYTF--TIYGMNWV--TPGQGFEWM-WIITY--NGNPTYTHGFTGWFVFSMDTSVSTACLQISSLKAEDTAEYYCAK-",
+            "IGHV7-34-1*03": "-LQLVQSGPEVKKRGASVKVSYKSSGYTF--TIYGMNWV--TPGQGFEWM-WIITY--TGNPTYTHGFTGWFVFSMDTSVSTACLQISSLKAEDTAEYYCAK-",
+            "IGHV7-4-1*01": "QVQLVQSGSELKKPGASVKVSCKASGYTF--TSYAMNWVRQAPGQGLEWMGWINTN--TGNPTYAQGFTGRFVFSLDTSVSTAYLQICSLKAEDTAVYYCAR-",
+            "IGHV7-4-1*02": "QVQLVQSGSELKKPGASVKVSCKASGYTF--TSYAMNWVRQAPGQGLEWMGWINTN--TGNPTYAQGFTGRFVFSLDTSVSTAYLQISSLKAEDTAVYYCAR-",
+            "IGHV7-4-1*04": "QVQLVQSGSELKKPGASVKVSCKASGYTF--TSYAMNWVRQAPGQGLEWMGWINTN--TGNPTYAQGFTGRFVFSLDTSVSMAYLQISSLKAEDTAVYYCAR-",
+            "IGHV7-4-1*05": "QVQLVQSGSELKKPGASVKVSCKASGYTF--TSYAMNWVRQAPGQGLEWMGWINTN--TGNPTYAQGFTGRFVFSLDTSVSMAYLQISSLKAEDTAVCYCAR-",
+            "IGHV7-40*03": "FSIEKSNNLSVNQWMIR-NMIYVNHGILC--SQYGMNSV-PAPGQGLEWMGWIITY--TGNPTYTNGFTGRFLFSMDTSVSMAYLQISSLKAEDTAVYDCMR-",
+            "IGHV7-81*01": "QVQLVQSGHEVKQPGASVKVSCKASGYSF--TTYGMNWVPQAPGQGLEWMGWFNTY--TGNPTYAQGFTGRFVFSMDTSASTAYLQISSLKAEDMAMYYCAR-",
+            "IGHV8-51-1*01": "EAQLTESGGDLVH-EGPLRLSCAASWFTF--SIYEIHWVCQASGKGLEWVAVIWRS--ESHQYNADYVRGRLTTSRDNTKYMLYMQMNSLRTQNMAAFNCAG-",
+            "IGHV8-51-1*02": "EAQLTESGGDLVHLEGPLRLSCAASWFTF--SIYEIHWVCQASGKGLEWVAVIWRG--ESHQYNADYVRGRLTTSRDNTKYMLYMQMISLRTQNMAAFNCAG-",
+            "IGHV8-51-1*03": "EAQLTESGGDLVH-EGPLRLSCAASWFTF--SIYEIHWVCQASGKGLEWVAVIWRG--ESHQYNADYVRGRLTTSRDNTKYMLYMQMNSLRTQNMAAFNCAG-"
+        }
+    },
+    'L': {
+        "positions": [
+            "L1", "L2", "L3", "L4", "L5", "L6", "L7", "L8", "L9", "L10", "L11", "L12", "L13", "L14", "L15", "L16", "L17", "L18", "L19", "L20", "L21", "L22", "L23", "L24", "L25", "L26", "L27", "L28", "L29", "L30", "L31", "L32", "L33", "L34", "L35", "L36", "L37", "L38", "L39", "L40", "L41", "L42", "L43", "L44", "L45", "L46", "L47", "L48", "L49", "L50", "L51", "L52", "L53", "L54", "L55", "L56", "L57", "L58", "L59", "L62", "L63", "L64", "L65", "L66", "L67", "L68", "L69", "L70", "L71", "L72", "L74", "L75", "L76", "L77", "L78", "L79", "L80", "L81", "L82", "L83", "L84", "L85", "L86", "L87", "L88", "L89", "L90", "L91", "L92", "L93", "L94", "L95", "L96", "L97", "L98", "L99", "L100", "L101", "L102", "L103", "L104", "L105", "L106", "L107", "L108", "L109", "L110", "L111", "L111A", "L111B", "L111C", "L111D"
+        ],
+        "aligned_sequences": {
+            "IGLV1-36*01": "QSVLTQPPS-VSEAPRQRVTISCSGSSSNI----GNNAVNWYQQLPGKAPKLLIYYD-----DLLPSGVSDRFSGSK--SGTSASLAISGLQSEDEADYYCAAWDDSLNG--",
+            "IGLV1-40*01": "QSVLTQPPS-VSGAPGQRVTISCTGSSSNIG---AGYDVHWYQQLPGTAPKLLIYGN-----SNRPSGVPDRFSGSK--SGTSASLAITGLQAEDEADYYCQSYDSSLSG--",
+            "IGLV1-40*02": "QSVVTQPPS-VSGAPGQRVTISCTGSSSNIG---AGYDVHWYQQLPGTAPKLLIYGN-----SNRPSGVPDRFSGSK--SGTSASLAITGLQAEDEADYYCQSYDSSLSG--",
+            "IGLV1-40*03": "QSVVTQPPS-VSGAPGQRVTISCTGSSSNIG---AGYDVHWYQQLPGTAPKLLIYGN-----SNRPSGVPDRFSGSK--SGASASLAITGLQAEDEADYYCQSYDSSLSG--",
+            "IGLV1-41*01": "QSVLTQPPS-VSAAPGQKVTISCSGSSSDM----GNYAVSWYQQLPGTAPKLLIYEN-----NKRPSGIPDRFSGSK--SGTSATLGITGLWPEDEADYYCLAWDTSPRA--",
+            "IGLV1-41*02": "QSVLTQPPS-VSAAPGQKVTISCSGSSSDM----GNYAVSWYQQLPGTAPKLLIYEN-----NKRPSGIPDRFSGSK--SGTSATLGITGLWPED-ADYYCLAWDTSLRA--",
+            "IGLV1-44*01": "QSVLTQPPS-ASGTPGQRVTISCSGSSSNI----GSNTVNWYQQLPGTAPKLLIYSN-----NQRPSGVPDRFSGSK--SGTSASLAISGLQSEDEADYYCAAWDDSLNG--",
+            "IGLV1-47*01": "QSVLTQPPS-ASGTPGQRVTISCSGSSSNI----GSNYVYWYQQLPGTAPKLLIYRN-----NQRPSGVPDRFSGSK--SGTSASLAISGLRSEDEADYYCAAWDDSLSG--",
+            "IGLV1-47*02": "QSVLTQPPS-ASGTPGQRVTISCSGSSSNI----GSNYVYWYQQLPGTAPKLLIYSN-----NQRPSGVPDRFSGSK--SGTSASLAISGLRSEDEADYYCAAWDDSLSG--",
+            "IGLV1-47*03": "QSVLTQPPS-ASGTPGQRVTISCSGSSSNI----GSNYVYWYQQLPGTAPKLLIYRN-----NQRPSGVPDRFSGSK--SGTSASLAISGLWSEDEADYYCAAWDDSLSG--",
+            "IGLV1-50*01": "QSVLTQPPS-VSGAPGQRVTISCTGSSSNIG---AGYVVHWYQQLPGTAPKLLIYGN-----SNRPSGVPDQFSGSK--SGTSASLAITGLQSEDEADYYCKAWDNSLNA--",
+            "IGLV1-51*01": "QSVLTQPPS-VSAAPGQKVTISCSGSSSNI----GNNYVSWYQQLPGTAPKLLIYDN-----NKRPSGIPDRFSGSK--SGTSATLGITGLQTGDEADYYCGTWDSSLSA--",
+            "IGLV1-51*02": "QSVLTQPPS-VSAAPGQKVTISCSGSSSNI----GNNYVSWYQQLPGTAPKLLIYEN-----NKRPSGIPDRFSGSK--SGTSATLGITGLQTGDEADYYCGTWDSSLSA--",
+            "IGLV1-62*01": "QSVLTQPPS-VSWATRQRLTVSCTGSSSNTG---TGYNVNCWQ-LPRTDPKLLRHGD-----KNWASWVSDQFSGSK--SGSLASLGTTGLWAEDKTDYHCQSRDIC-VL--",
+            "IGLV10-54*01": "QAGLTQPPS-VSKGLRQTATLTCTGNSNNV----GNQGAAWLQQHQGHPPKLLSYRN-----NNRPSGISERLSASR--SGNTASLTITGLQPEDEADYYCSAWDSSLSA--",
+            "IGLV10-54*02": "QAGLTQPPS-VSKGLRQTATLTCTGNSNIV----GNQGAAWLQQHQGHPPKLLSYRN-----NNRPSGISERFSASR--SGNTASLTITGLQPEDEADYYCSALDSSLSA--",
+            "IGLV10-54*03": "QAGLTQPPS-VSKGLRQTATLTCTGNSNNV----GNQGAAWPEQHQGHPPKLLSYRN-----NNRPSGISERLSASR--SGNTASLTITGLQPEDEADYYCSAWDSSLSA--",
+            "IGLV11-55*01": "RPVLTQPPS-LSASPGATARLPCTLSSDLSV---GGKNMFWYQQKPGSSPRLFLYHYSD-SDKQLGPGVPSRVSGSKETSSNTAFLLISGLQPEDEADYYCQVYESSAN---",
+            "IGLV11-55*02": "RPVLTQPPS-LSASPGATARLPCTLSSDLSV---GGKNMFWYQQKLGSSPRLFLYHYSD-SDKQLGPGVPSRVSGSKETSSNTAFLLISGLQPEDEADYYCQVYESSAN---",
+            "IGLV2-11*01": "QSALTQPRS-VSGSPGQSVTISCTGTSSDVG---GYNYVSWYQQHPGKAPKLMIYDV-----SKRPSGVPDRFSGSK--SGNTASLTISGLQAEDEADYYCCSYAGSYTF--",
+            "IGLV2-11*02": "QSALTQPRS-VSGSPGQSVTISCTGTSSDVG---GYNYVSWYQQHPGKAPKLMIYDV-----SKRPSGVPDRFSGSK--SGNTASLTISGLQAEDEADYYCCSYAGSYTF--",
+            "IGLV2-14*01": "QSALTQPAS-VSGSPGQSITISCTGTSSDVG---GYNYVSWYQQHPGKAPKLMIYEV-----SNRPSGVSNRFSGSK--SGNTASLTISGLQAEDEADYYCSSYTSSSTL--",
+            "IGLV2-14*02": "QSALTQPAS-VSGSPGQSITISCTGTSSDVG---SYNLVSWYQQHPGKAPKLMIYEG-----SKRPSGVSNRFSGSK--SGNTASLTISGLQAEDEADYYCSSYTSSSTL--",
+            "IGLV2-14*03": "QSALTQPAS-VSGSPGQSITISCTGTSSDVG---GYNYVSWYQQHPGKAPKLMIYDV-----SNRPSGVSNRFSGSK--SGNTASLTISGLQAEDEADYYCSSYTSSSTL--",
+            "IGLV2-18*01": "QSALTQPPS-VSGSPGQSVTISCTGTSSDVG---SYNRVSWYQQPPGTAPKLMIYEV-----SNRPSGVPDRFSGSK--SGNTASLTISGLQAEDEADYYCSLYTSSSTF--",
+            "IGLV2-18*02": "QSALTQPPS-VSGSPGQSVTISCTGTSSDVG---SYNRVSWYQQPPGTAPKLMIYEV-----SNRPSGVPDRFSGSK--SGNTASLTISGLQAEDEADYYCSSYTSSSTF--",
+            "IGLV2-18*03": "QSALTQPPS-VSGSPGQSVTISCTGTSSDVG---SYNRVSWYQQPPGTAPKLMIYEV-----SNRPSGVPDRFSGSK--SGNTASLTTSGLQAEDEADYYCSSYTSSSTF--",
+            "IGLV2-18*04": "QSALTQPPS-VSGSPGQSVTISCTGTSSDVG---SYNRVSWYQQPPGTAPKLMIYEV-----SNRPSGVPDRSSGSK--SGNTASLTISGLQAEDEADYYCSSYTSSSTF--",
+            "IGLV2-23*01": "QSALTQPAS-VSGSPGQSITISCTGTSSDVG---SYNLVSWYQQHPGKAPKLMIYEG-----SKRPSGVSNRFSGSK--SGNTASLTISGLQAEDEADYYCCSYAGSSTL--",
+            "IGLV2-23*02": "QSALTQPAS-VSGSPGQSITISCTGTSSDVG---SYNLVSWYQQHPGKAPKLMIYEV-----SKRPSGVSNRFSGSK--SGNTASLTISGLQAEDEADYYCCSYAGSSTF--",
+            "IGLV2-23*03": "QSALTQPAS-VSGSPGQSITISCTGTSSDVG---SYNLVSWYQQHPGKAPKLMIYEG-----SKRPSGVSNRFSGSK--SGNTASLTISGLQAEDEADYYCCSYAGSSTF--",
+            "IGLV2-33*01": "QSALTQPPF-VSGAPGQSVTISCTGTSSDVG---DYDHVFWYQKRLSTTSRLLIYNV-----NTRPSGISDLFSGSK--SGNMASLTISGLKSEVEANYHCSLYSSSYTF--",
+            "IGLV2-33*02": "QSALTQPPF-VSGAPGQSVTISCTGTSSDVG---DYDHVFWYQKRLSTTSRLLIYNV-----NTRPSGISDLFSGSK--SGNMASLTISGLKSEVEANYHCSLYSSSYTF--",
+            "IGLV2-33*03": "QSALTQPPF-VSGAPGQSVTISCTGTSSDVG---DYDHVFWYQKRLSTTSRLLIYNV-----NTRPSGISDLFSGSK--SGNVASLTISGLKSEVEANYHCSLYSSSYTF--",
+            "IGLV2-34*01": "QSVLTQPRS-VSRSPGQ-VTIFCTGTSSDIG---GYDLVSWCQ-HPGKAPKLMIYDV-----ANWPSGAPGCFSGSK--SGNTASLTISGLQAEDEADYYCSSYAGSYNF--",
+            "IGLV2-34*02": "QSVLTQPRS-VSRSPGQ-VTIFCTGTSSDIG---GYDLVSWCQ-HPGKAPKLMIYDV-----GNWPSGAPGCFSGSK--SGNTASLTISGLQAEDEADYYCSSYAGSYNF--",
+            "IGLV2-5*01": "QSALIQPPS-VSGSPGQSVTISCTGTSSDVG---SYDYVSWYQQHPGTVPKPMIYNV-----NTQPSGVPDRFSGSK--SGNTASMTISGLQAEDEADY-CCSYTSSAT---",
+            "IGLV2-5*02": "QSALIQPPS-VSGSPGQSVTISCTGTSSDVG---SYDYVSWYQQHPGTVPKPMIYNV-----NTRPSGVPDRFSGSK--SGNTASMTISGLQAEDEADY-CCSYTSSAT---",
+            "IGLV2-8*01": "QSALTQPPS-ASGSPGQSVTISCTGTSSDVG---GYNYVSWYQQHPGKAPKLMIYEV-----SKRPSGVPDRFSGSK--SGNTASLTVSGLQAEDEADYYCSSYAGSNNF--",
+            "IGLV2-8*02": "QSALTQPPS-ASRSPGQSVTISCTGTSSDVG---GYNYVSWYQQHPGKAPKLMIYEV-----SKRPSGVPDRFSGSK--SGNTASLTVSGLQAEDEADYYCSSYAGSNNF--",
+            "IGLV3-1*01": "SYELTQPPS-VSVSPGQTASITCSGDKLG------DKYACWYQQKPGQSPVLVIYQD-----SKRPSGIPERFSGSN--SGNTATLTISGTQAMDEADYYCQAWDSSTA---",
+            "IGLV3-10*01": "SYELTQPPS-VSVSPGQTARITCSGDALP------KKYAYWYQQKSGQAPVLVIYED-----SKRPSGIPERFSGSS--SGTMATLTISGAQVEDEADYYCYSTDSSGNH--",
+            "IGLV3-10*03": "SYELTQPPS-VSVSPGQTARITCSGDALP------KKYAYWYQQKSGQAPVLVIYED-----SKRPSGIPERFSGSS--SGTMATLTISGAQVEDEDDYYCYSTDSSGNH--",
+            "IGLV3-12*01": "SYELTQPHS-VSVATAQMARITCGGNNIG------SKAVHWYQQKPGQDPVLVIYSD-----SNRPSGIPERFSGSN--PGNTTTLTISRIEAGDEADYYCQVWDSSSDH--",
+            "IGLV3-12*02": "SYELTQPHS-VSVATAQMARITCGGNNIG------SKAVHWYQQKPGQDPVLVIYSD-----SNRPSGIPERFSGSN--PGNTATLTISRIEAGDEADYYCQVWDSSSDH--",
+            "IGLV3-13*01": "SYELTQPPA-VSVSPGQTARISCSGDVLR------DNYADWYPQKPGQAPVLVIYKD-----GERPSGIPERFSGST--SGNTTALTISRVLTKGGADYYCFSGD-NN----",
+            "IGLV3-13*02": "SYELTQPPA-VSVSPGQTARISCSGDVLR------DNYADWYPQKPGQTPVLVIYKD-----GERPSGIPERFSGST--SGNTTALTISRVLTKGGADYYCFSGD-NN----",
+            "IGLV3-16*01": "SYELTQPPS-VSVSLGQMARITCSGEALP------KKYAYWYQQKPGQFPVLVIYKD-----SERPSGIPERFSGSS--SGTIVTLTISGVQAEDEADYYCLSADSSGTY--",
+            "IGLV3-19*01": "SSELTQDPA-VSVALGQTVRITCQGDSLR------SYYASWYQQKPGQAPVLVIYGK-----NNRPSGIPDRFSGSS--SGNTASLTITGAQAEDEADYYCNSRDSSGNH--",
+            "IGLV3-19*02": "SSELTQDPA-VSVALGQTVRITCQGDSLR------SYYASWYQQKPGQAPVRVIYGK-----NNRPSGIPDRFSGSS--SGNTASLTITGAQAEDEADYYCNSWDSSGNH--",
+            "IGLV3-21*01": "SYVLTQPPS-VSVAPGKTARITCGGNNIG------SKSVHWYQQKPGQAPVLVIYYD-----SDRPSGIPERFSGSN--SGNTATLTISRVEAGDEADYYCQVWDSSSDH--",
+            "IGLV3-21*02": "SYVLTQPPS-VSVAPGQTARITCGGNNIG------SKSVHWYQQKPGQAPVLVVYDD-----SDRPSGIPERFSGSN--SGNTATLTISRVEAGDEADYYCQVWDSSSDH--",
+            "IGLV3-21*03": "SYVLTQPPS-VSVAPGKTARITCGGNNIG------SKSVHWYQQKPGQAPVLVVYDD-----SDRPSGIPERFSGSN--SGNTATLTISRVEAGDEADYYCQVWDSSSDH--",
+            "IGLV3-21*04": "SYVLTQPPS-VSVAPGKTARITCGGNNIG------SKSVHWYQQKPGQAPVLVIYYD-----SDRPSGIPERFSGSN--SGNTATLTISRVEAGDEADYYCQVWDSSSDH--",
+            "IGLV3-22*01": "SYELTQLPS-VSVSPGQTARITCSGDVLG------ENYADWYQQKPGQAPELVIYED-----SERYPGIPERFSGST--SGNTTTLTISRVLTEDEADYYCLSGDEDN----",
+            "IGLV3-22*03": "SYELTQLPS-VSLSPGQKARITCSGDVLG------KNYADWYQQKPGQAPELVIYED-----SERYPGIPERFSGST--SGNTTTLTISRVLTEDEADYYCLSGNEDN----",
+            "IGLV3-25*01": "SYELMQPPS-VSVSPGQTARITCSGDALP------KQYAYWYQQKPGQAPVLVIYKD-----SERPSGIPERFSGSS--SGTTVTLTISGVQAEDEADYYCQSADSSGTY--",
+            "IGLV3-25*02": "SYELTQPPS-VSVSPGQTARITCSGDALP------KQYAYWYQQKPGQAPVLVIYKD-----SERPSGIPERFSGSS--SGTTVTLTISGVQAEDEADYYCQSADSSGTY--",
+            "IGLV3-25*03": "SYELTQPPS-VSVSPGQTARITCSGDALP------KQYAYWYQQKPGQAPVLVIYKD-----SERPSGIPERFSGSS--SGTTVTLTISGVQAEDEADYYCQSADSSGTY--",
+            "IGLV3-27*01": "SYELTQPSS-VSVSPGQTARITCSGDVLA------KKYARWFQQKPGQAPVLVIYKD-----SERPSGIPERFSGSS--SGTTVTLTISGAQVEDEADYYCYSAADNN----",
+            "IGLV3-31*01": "SSELSQEPA-VSVALG-TARITCQGDSIE------DSVVNWYKQKPSQAPGLVI-LN-----SVQSSGIPKKFSGSS--SGNMATLTITGIQVEDKADYYCQSWDSSRTH--",
+            "IGLV3-31*02": "SSELSQEPA-VSVSLG-TARITCQGDSIE------DSVVNWYKQKPSQAPGLVI-LN-----SVQSSGIPKKFSGSS--SGNMATLTITGIQVEDKADYYCQSWDSSRTH--",
+            "IGLV3-32*01": "SSGPTQVPA-VSVALGQMARITCQGDSME------GSYEHWYQQKPGQAPVLVIYDS-----SDRPSRIPERFSGSK--SGNTTTLTITGAQAEDEADYYYQLIDNHATQ--",
+            "IGLV3-9*01": "SYELTQPLS-VSVALGQTARITCGGNNIG------SKNVHWYQQKPGQAPVLVIYRD-----SNRPSGIPERFSGSN--SGNTATLTISRAQAGDEADYYCQVWDSSTA---",
+            "IGLV3-9*02": "SYELTQPLS-VSVALGQAARITCGGNNLG------YKSVHWYQQKPGQAPVLVIYRD-----NNRPSGIPERFSGSN--SGNTATLTISRAQAGDEADYYCQVWDSSTAH--",
+            "IGLV4-3*01": "LPVLTQPPS-ASALLGASIKLTCTLSSEHS-----TYTIEWYQQRPGRSPQYIMKVKSD-GSHSKGDGIPDRFMGSS--SGADRYLTFSNLQSDDEAEYHCGESHTIDGQVG",
+            "IGLV4-60*01": "QPVLTQSSS-ASASLGSSVKLTCTLSSGHS-----SYIIAWHQQQPGKAPRYLMKLEGS-GSYNKGSGVPDRFSGSS--SGADRYLTISNLQLEDEADYYCETWDSNT----",
+            "IGLV4-60*02": "QPVLTQSSS-ASASLGSSVKLTCTLSSGHS-----SYIIAWHQQQPGKAPRYLMKLEGS-GSYNKGSGVPDRFSGSS--SGADRYLTISNLQFEDEADYYCETWDSNT----",
+            "IGLV4-60*03": "QPVLTQSSS-ASASLGSSVKLTCTLSSGHS-----SYIIAWHQQQPGKAPRYLMKLEGS-GSYNKGSGVPDRFSGSS--SGADRYLTISNLQSEDEADYYCETWDSNT----",
+            "IGLV4-69*01": "QLVLTQSPS-ASASLGASVKLTCTLSSGHS-----SYAIAWHQQQPEKGPRYLMKLNSD-GSHSKGDGIPDRFSGSS--SGAERYLTISSLQSEDEADYYCQTWGTGI----",
+            "IGLV4-69*02": "QLVLTQSPS-ASASLGASVKLTCTLSSGHS-----SYAIAWHQQQPEKGPRYLMKLNSD-GSHSKGDGIPDRFSGSS--SGAERYLTISSLQSEDEADYYCQTWGTGI----",
+            "IGLV5-37*01": "QPVLTQPPS-SSASPGESARLTCTLPSDINV---GSYNIYWYQQKPGSPPRYLLYYYSD-SDKGQGSGVPSRFSGSKDASANTGILLISGLQSEDEADYYCMIWPSNAS---",
+            "IGLV5-39*01": "QPVLTQPTS-LSASPGASARFTCTLRSGINV---GTYRIYWYQQKPGSLPRYLLRYKSD-SDKQQGSGVPSRFSGSKDASTNAGLLLISGLQSEDEADYYCAIWYSSTS---",
+            "IGLV5-39*02": "QPVLTQPTS-LSASPGASARFTCTLRSGINV---GTYRIYWYQQNPGSLPRYLLRYKSD-SDKQQGSGVPSRFSGSKDASTNAGLLLISGLQSEDEADYYCAIWYSSTS---",
+            "IGLV5-45*01": "QAVLTQPAS-LSASPGASASLTCTLRSGINV---GTYRIYWYQQKPGSPPQYLLRYKSD-SDKQQGSGVPSRFSGSKDASANAGILLISGLQSEDEADYYCMIWHSSAS---",
+            "IGLV5-45*02": "QAVLTQPSS-LSASPGASASLTCTLRSGINV---GTYRIYWYQQKPGSPPQYLLRYKSD-SDKQQGSGVPSRFSGSKDASANAGILLISGLQSEDEADYYCMIWHSSAS---",
+            "IGLV5-45*03": "QAVLTQPSS-LSASPGASASLTCTLRSGINV---GTYRIYWYQQKPGSPPQYLLRYKSD-SDKQQGSGVPSRFSGSKDASANAGILLISGLQSEDEADYYCMIWHSSAS---",
+            "IGLV5-45*04": "QAVLTQPSS-LSASPGASASLTCTLCSGINV---GTYRIYWYQQKPGSPPQYLLRYKSD-SDKQQGSGVPSRFSGSKDASANAGILLISGLQSEDEADYYCMIWHSSAS---",
+            "IGLV5-48*01": "QPVLTQPTS-LSASPGASARLTCTLRSGINL---GSYRIFWYQQKPESPPRYLLSYYSD-SSKHQGSGVPSRFSGSKDASSNAGILVISGLQSEDEADYYCMIWHSSAS---",
+            "IGLV5-48*02": "QAVLTQPTS-LSASPGASARLTCTLRSGISV---GSYRIYWYQQKPGSPPRYLLNYYSD-SDKHQGSGVPSRFSGSKDASTNAGILFISGL-SEDEADYYCMIWHSSAS---",
+            "IGLV5-52*01": "QPVLTQPSS-HSASSGASVRLTCMLSSGFSV---GDFWIRWYQQKPGNPPRYLLYYHSD-SNKGQGSGVPSRFSGSNDASANAGILRISGLQPEDEADYYCGTWHSNSKT--",
+            "IGLV6-57*01": "NFMLTQPHS-VSESPGKTVTISCTRSSGSI----ASNYVQWYQQRPGSSPTTVIYED-----NQRPSGVPDRFSGSIDSSSNSASLTISGLKTEDEADYYCQSYDSSN----",
+            "IGLV6-57*02": "NFMLTQPHS-VSESPGKTVTISCTGSSGSI----ASNYVQWYQQRPGSAPTTVIYED-----NQRPSGVPDRFSGSIDSSSNSASLTISGLKTEDEADYYCQSYDSSN----",
+            "IGLV6-57*03": "NFMLTQPHS-VSESPGKTVTISCTRSSGSI----ASNYVQWYQQRPGSAPTTVIYED-----NQRPSGVPDRFSGSIDSSSNSASLTISGLKTEDEADYYCQSYDSSN----",
+            "IGLV7-43*01": "QTVVTQEPS-LTVSPGGTVTLTCASSTGAVT---SGYYPNWFQQKPGQAPRALIYST-----SNKHSWTPARFSGSL--LGGKAALTLSGVQPEDEAEYYCLLYYGGAQ---",
+            "IGLV7-46*01": "QAVVTQEPS-LTVSPGGTVTLTCGSSTGAVT---SGHYPYWFQQKPGQAPRTLIYDT-----SNKHSWTPARFSGSL--LGGKAALTLSGAQPEDEAEYYCLLSYSGAR---",
+            "IGLV7-46*02": "QAVVTQEPS-LTVSPGGTVTLTCGSSTGAVT---SGHYPYWFQQKPGQAPRTLIYDT-----SNKHSWTPARFSGSL--LGGKAALTLLGAQPEDEAEYYCLLSYSGAR---",
+            "IGLV8-61*01": "QTVVTQEPS-FSVSPGGTVTLTCGLSSGSVS---TSYYPSWYQQTPGQAPRTLIYST-----NTRSSGVPDRFSGSI--LGNKAALTITGAQADDESDYYCVLYMGSGI---",
+            "IGLV8-61*02": "QTVVTQEPS-FSVSPGGTVTLTCGLSSGSVS---TSYYPSWYQQTPGQAPRTLIYST-----NTRSSGVPDCFSGSI--LGNKAALTITGAQADDESDYYCVLYMGSGI---",
+            "IGLV8/OR8-1*02": "QSVVTQEPS-LSGSPGGTVTLTCALSSGSVS---TSHYPRWYQQTPGQAPHMLICSP-----NTCPSGVPGRFSGSI--LGNKAALTITGTQVDDDSDHYCVLYMGSGN---",
+            "IGLV9-49*01": "QPVLTQPPS-ASASLGASVTLTCTLSSGYS-----NYKVDWYQQRPGKGPRFVMRVGTGGIVGSKGDGIPDRFSVLG--SGLNRYLTIKNIQEEDESDYHCGADHGSGSNFV",
+            "IGLV9-49*02": "QPVLTQPPS-ASASLGASVTLTCTLSSGYS-----NYKVDWYQQRPGKGPRFVMRVGTGGIVGSKGDGIPDRFSVLG--SGLNRYLTIKNIQEEDESDYHCGADHGSGSNFV",
+            "IGLV9-49*03": "QPVLTQPPS-ASASLGASVTLTCTLSSGYS-----NYKVDWYQQRPGKGPRFVMRVGTGGIVGSKGDGIPDRFSVLG--SGLNRYLTIKNIQEEDESDYHCGADHGSGSNFV"
+        }
+    },
+    'K': {
+        "positions": [
+            "L1", "L2", "L3", "L4", "L5", "L6", "L7", "L8", "L9", "L10", "L11", "L12", "L13", "L14", "L15", "L16", "L17", "L18", "L19", "L20", "L21", "L22", "L23", "L24", "L25", "L26", "L27", "L28", "L29", "L30", "L31", "L32", "L33", "L34", "L35", "L36", "L37", "L38", "L39", "L40", "L41", "L42", "L43", "L44", "L45", "L46", "L47", "L48", "L49", "L50", "L51", "L52", "L53", "L54", "L55", "L56", "L57", "L58", "L59", "L62", "L63", "L64", "L65", "L66", "L67", "L68", "L69", "L70", "L71", "L72", "L74", "L75", "L76", "L77", "L78", "L79", "L80", "L81", "L82", "L83", "L84", "L85", "L86", "L87", "L88", "L89", "L90", "L91", "L92", "L93", "L94", "L95", "L96", "L97", "L98", "L99", "L100", "L101", "L102", "L103", "L104", "L105", "L106", "L107", "L108", "L109", "L110", "L111", "L111A", "L111B", "L111C", "L111D"
+        ],
+        "aligned_sequences": {
+          "IGKV1-12*01": "DIQMTQSPSSVSASVGDRVTITCRASQGI------SSWLAWYQQKPGKAPKLLIYAA-----SSLQSGVPSRFSGSG--SGTDFTLTISSLQPEDFATYYCQQANSFP----",
+          "IGKV1-12*02": "DIQMTQSPSSVSASVGDRVTITCRASQGI------SSWLAWYQQKPGKAPKLLIYAA-----SSLQSGVPSRFSGSG--SGTDFTLTISSLQPEDFATYYCQQANSFP----",
+          "IGKV1-13*01": "AIQLTQSPSSLSASVGDRVTITCRASQGI------SSALA-YQQKPGKAPKLLIYDA-----SSLESGVPSRFSGSG--SGTDFTLTISSLQPEDFATYYCQQFNNYP----",
+          "IGKV1-13*02": "AIQLTQSPSSLSASVGDRVTITCRASQGI------SSALAWYQQKPGKAPKLLIYDA-----SSLESGVPSRFSGSG--SGTDFTLTISSLQPEDFATYYCQQFNSYP----",
+          "IGKV1-16*01": "DIQMTQSPSSLSASVGDRVTITCRASQGI------SNYLAWFQQKPGKAPKSLIYAA-----SSLQSGVPSRFSGSG--SGTDFTLTISSLQPEDFATYYCQQYNSYP----",
+          "IGKV1-16*02": "DIQMTQSPSSLSASVGDRVTITCRASQGI------SNYLAWFQQKPGKAPKSLIYAA-----SSLQSGVPSKFSGSG--SGTDFTLTISSLQPEDFATYYCQQYNSYP----",
+          "IGKV1-17*01": "DIQMTQSPSSLSASVGDRVTITCRASQGI------RNDLGWYQQKPGKAPKRLIYAA-----SSLQSGVPSRFSGSG--SGTEFTLTISSLQPEDFATYYCLQHNSYP----",
+          "IGKV1-17*02": "DIQMTQSPSSLSASVGDRVTITCRASQGI------RNDLGWYQQKPGKAPKRLIYAA-----SSLQSGVPSRFSGSG--SGTEFTLTISNLQPEDFATYYCLQHNSYP----",
+          "IGKV1-17*03": "DIQMTQSPSAMSASVGDRVTITCRASQGI------SNYLAWFQQKPGKVPKRLIYAA-----SSLQSGVPSRFSGSG--SGTEFTLTISSLQPEDFATYYCLQHNSYP----",
+          "IGKV1-27*01": "DIQMTQSPSSLSASVGDRVTITCRASQGI------SNYLAWYQQKPGKVPKLLIYAA-----STLQSGVPSRFSGSG--SGTDFTLTISSLQPEDVATYYCQKYNSAP----",
+          "IGKV1-33*01": "DIQMTQSPSSLSASVGDRVTITCQASQDI------SNYLNWYQQKPGKAPKLLIYDA-----SNLETGVPSRFSGSG--SGTDFTFTISSLQPEDIATYYCQQYDNLP----",
+          "IGKV1-37*01": "DIQLTQSPSSLSASVGDRVTITCRVSQGI------SSYLNWYRQKPGKVPKLLIYSA-----SNLQSGVPSRFSGSG--SGTDFTLTISSLQPEDVATYYGQRTYNAP----",
+          "IGKV1-39*01": "DIQMTQSPSSLSASVGDRVTITCRASQSI------SSYLNWYQQKPGKAPKLLIYAA-----SSLQSGVPSRFSGSG--SGTDFTLTISSLQPEDFATYYCQQSYSTP----",
+          "IGKV1-39*02": "DIQMTQSPSFLSASVGDRVTITCRASQSI------SSYLNWYQQKPGKAPKLLIYAA-----SSLQSGVPSRFSGSG--SGTDFTLTISSLQPEDFATYYCQCGYSTP----",
+          "IGKV1-5*01": "DIQMTQSPSTLSASVGDRVTITCRASQSI------SSWLAWYQQKPGKAPKLLIYDA-----SSLESGVPSRFSGSG--SGTEFTLTISSLQPDDFATYYCQQYNSYS----",
+          "IGKV1-5*02": "DIQMTQSPSTLSASVGDRVTIICRASQSI------SSWLAWYQQKPGKAPKLLIYDA-----SSLESGVPSRFSGSG--SGTEFTLTISSLQPDDFATYYCQQYNSYS----",
+          "IGKV1-5*03": "DIQMTQSPSTLSASVGDRVTITCRASQSI------SSWLAWYQQKPGKAPKLLIYKA-----SSLESGVPSRFSGSG--SGTEFTLTISSLQPDDFATYYCQQYNSYS----",
+          "IGKV1-6*01": "AIQMTQSPSSLSASVGDRVTITCRASQGI------RNDLGWYQQKPGKAPKLLIYAA-----SSLQSGVPSRFSGSG--SGTDFTLTISSLQPEDFATYYCLQDYNYP----",
+          "IGKV1-6*02": "AIQMTQSPSSLSASVGDRVTITCRASQGI------RNDLGWYQQKPGKAPKLLIYAA-----SSLQSGVPSRFSGSG--SGTDFTLTISSLQPEDFATYYCLQDYNYP----",
+          "IGKV1-8*01": "AIRMTQSPSSFSASTGDRVTITCRASQGI------SSYLAWYQQKPGKAPKLLIYAA-----STLQSGVPSRFSGSG--SGTDFTLTISCLQSEDFATYYCQQYYSYP----",
+          "IGKV1-9*01": "DIQLTQSPSFLSASVGDRVTITCRASQGI------SSYLAWYQQKPGKAPKLLIYAA-----STLQSGVPSRFSGSG--SGTEFTLTISSLQPEDFATYYCQQLNSYP----",
+          "IGKV1-NL1*01": "DIQMTQSPSSLSASVGDRVTITCRASQGI------SNSLAWYQQKPGKAPKLLLYAA-----SRLESGVPSRFSGSG--SGTDYTLTISSLQPEDFATYYCQQYYSTP----",
+          "IGKV1/OR-2*01": "DIQMTQSPSSLSASVGGRVTITCRASQGI------SNNLNWYQQKPRKTPKLLIYAA-----SSLQSGIPSRFSDSG--SGTDYTLTISSLQPEDFATYYCQQSDSNP----",
+          "IGKV1/OR-3*01": "DIQMTQSPSSLSASVGGRVTITCRASQGI------SNNLNWYQQKPGKTPKLLIYAA-----SSLQSGIPSRFSDSG--SGTDYTLTISSLQPEDFAAYYCQQSDSTP----",
+          "IGKV1/OR-4*01": "DIQMTQSPSSLSASVGDRVTITCRASQGI------SNNLNWYQQKPGKTPKFLIYAA-----SSLQSGIPSRFSDSG--SGTDYTLTISSLQPEDFATYYCQQSDSTP----",
+          "IGKV1/OR1-1*01": "DIQMTQSPSSLSASVGDRVTITCRASQGI------SNNLNWYQQKPGKTPKLLIYAA-----SSLQSGIPSRFSDSG--SGADYTLTIRSLQPEDFATYYCQQSDSTP----",
+          "IGKV1/OR10-1*01": "DIQMTQSPSSLSASVGDRVTITCRASQGI------SNNLNWYQQKPGKTPKLLIYAA-----SSLQSGIPSRFSDSG--SGTDYTLTISSLQPEDFATYYCQQSDSTS----",
+          "IGKV1/OR15-118*01": "DIQMTQSPSSLSASVGDRVTITCRASQGI------SNNLNWYQQKPGKTPKLLIYAA-----PSLQSGIPSRFSDSG--SGADYTLTIRSLQPEDFATY-CQQSDSTP----",
+          "IGKV1/OR2-0*01": "DIQMTQSPSSLSASVGDRVTITCRASQGI------SNNLNWYQQKPGKTPKLLIYAA-----PSLQSGIPSRFSDSG--SGADYTLTIRSLQPEDFATYYCQQSDSTP----",
+          "IGKV1/OR2-1*01": "DIQMTQSPSSLSASVGGRVTITCRASQGI------SNNLNWYQQKPGKTPKLLIYAA-----SSLQSGIPSRFSDSG--SGADYTLTISSLQPEDFAAYYCQQSDSTP----",
+          "IGKV1/OR2-108*01": "DIQVTQSPSSLSASVGDRVTITCRASQGI------SNGLSWYQQKPGQAPTLLIYAA-----SSLQSGVPSRFSGSG--SGTDFTLTISSLQPEDVATYYCLQDYTTP----",
+          "IGKV1/OR2-11*01": "DIQMTQPPSSLSASVGDRATVSCQASQSI------YNYLNWYQQKPGKAPKFLTYRA-----SSLQRAMPSQFSGSG--YGRDFTLTVSSLQPEDFATY-CQQESIFP----",
+          "IGKV1/OR2-118*01": "DIQMTQSPSSLSASVGDRVTITCRASQGI------SNNLNWYQQKPGKTPKLLIYAA-----SSLQSGIPSRFSDSG--SGADYTLTIRSLQPEDFANYYCQQSDSTP----",
+          "IGKV1/OR2-2*01": "DIQMTQSPSSLSASVGGRVTITCRASQGI------SNNLNWYQQKPGKTPKLLIYAA-----SSLQSGIPSRFSDSG--SGADYTLTISSLQPEDFAAYYCQQSDSTP----",
+          "IGKV1/OR2-3*01": "DIQMTQPPSSLSASVGDRVTVSCQASQSI------YNYLNWYQQKPGKAPKFLTYRA-----SSLQRGMPSQFSGSG--YGRDFTLTVSSLQPEDFATY-CQQESIFP----",
+          "IGKV1/OR2-9*01": "DIQMTQPPSSLSASVGDRATVSCQASQSI------YNYLNWYQQKPGKAPKFLTYRA-----SSLQRAMPSQFSGSG--YGRDFTLTVSSLQPEDFATY-CQQESIFP----",
+          "IGKV1/OR22-5*01": "DIQMTQSPSSLSASVGGRVTITCRASQGI------SNNLNWYQQKPGKTPKPLIYAA-----SSLQSGIPSQFSDSG--SGTD-TLTISSLQPEDFATYYCQQSYSTP----",
+          "IGKV1/OR22-5*02": "DIQMTQSPSSLSASVGDRVTITCRASQGI------SNNLNWYQQKPGKTPKLLIYAA-----SSLQSGIPSQFSDSG--SGTD-TLTISSLQPEDFTTYYCQQSYSTP----",
+          "IGKV1/OR9-1*01": "DIQMTQSPSSLSASVGGRVTITCRVSQGI------SNNLNWYQQKPRKTPKLLIYAA-----SSLQSGIPSRFSDSG--SGTDYTLTISSLQPEDFATYYCQQSDSNP----",
+          "IGKV1/OR9-2*01": "DIQMTQSPSSLSASVGGRVTITCRASQGI------SNNLNWYQQKPRKTPKLLIYAA-----SSLQSGIPSRFSDSG--SGTDYTLTISSLQPEDFATYYCQQSDSNP----",
+          "IGKV1/ORY-1*01": "DIQMTQSPSSLSASVGDRVTITCRASQGI------INNLNWYQKKPGKTPKLLIYAA-----SSLQSGIPTRFSDSG--SGTDYTPTISSLQPEDFATYYCQQSDSTP----",
+          "IGKV1D-12*01": "DIQMTQSPSSVSASVGDRVTITCRASQGI------SSWLAWYQQKPGKAPKLLIYAA-----SSLQSGVPSRFSGSG--SGTDFTLTISSLQPEDFATYYCQQANSFP----",
+          "IGKV1D-12*02": "DIQMTQSPSSVSASVGDRVTITCRASQGI------SSWLAWYQQKPGKAPKLLIYAA-----SSLQSGVPSRFSGSG--SGTDFTLTISSLQPEDFATYYCQQANSFP----",
+          "IGKV1D-13*01": "AIQLTQSPSSLSASVGDRVTITCRASQGI------SSALAWYQQKPGKAPKLLIYDA-----SSLESGVPSRFSGSG--SGTDFTLTISSLQPEDFATYYCQQFNNYP----",
+          "IGKV1D-13*02": "AIQLTQSPSSLSASVGDRVTITCRASQGI------SSALAWYQQKPGKAPKLLIYDA-----SSLESGVPSRFSGSG--SGTDFTLTISSLQPEDFATYYCQQFNSYP----",
+          "IGKV1D-16*01": "DIQMTQSPSSLSASVGDRVTITCRASQGI------SSWLAWYQQKPEKAPKSLIYAA-----SSLQSGVPSRFSGSG--SGTDFTLTISSLQPEDFATYYCQQYNSYP----",
+          "IGKV1D-16*02": "DIQMTQSPSSLSASVGDRVTITCRARQGI------SSWLAWYQQKPEKAPKSLIYAA-----SSLQSGVPSRFSGSG--SGTDFTLTISSLQPEDFATYYCQQYNSYP----",
+          "IGKV1D-17*01": "NIQMTQSPSAMSASVGDRVTITCRARQGI------SNYLAWFQQKPGKVPKHLIYAA-----SSLQSGVPSRFSGSG--SGTEFTLTISSLQPEDFATYYCLQHNSYP----",
+          "IGKV1D-33*01": "DIQMTQSPSSLSASVGDRVTITCQASQDI------SNYLNWYQQKPGKAPKLLIYDA-----SNLETGVPSRFSGSG--SGTDFTFTISSLQPEDIATYYCQQYDNLP----",
+          "IGKV1D-37*01": "DIQLTQSPSSLSASVGDRVTITCRVSQGI------SSYLNWYRQKPGKVPKLLIYSA-----SNLQSGVPSRFSGSG--SGTDFTLTISSLQPEDVATYYGQRTYNAP----",
+          "IGKV1D-39*01": "DIQMTQSPSSLSASVGDRVTITCRASQSI------SSYLNWYQQKPGKAPKLLIYAA-----SSLQSGVPSRFSGSG--SGTDFTLTISSLQPEDFATYYCQQSYSTP----",
+          "IGKV1D-42*01": "DIQMIQSPSFLSASVGDRVSIICWASEGI------SSNLAWYLQKPGKSPKLFLYDA-----KDLHPGVSSRFSGRG--SGTDFTLTIISLKPEDFAAYYCKQDFSYP----",
+          "IGKV1D-42*02": "DIQMTQSPSFLSASVGDRVSIICWASEGI------SSNLAWYLQKPGKSPKLFLYDA-----KDLHPGVSSRFSGRG--SGTDFTLTIISLKPEDFAAYYCKQDFSYP----",
+          "IGKV1D-43*01": "AIRMTQSPFSLSASVGDRVTITCWASQGI------SSYLAWYQQKPAKAPKLFIYYA-----SSLQSGVPSRFSGSG--SGTDYTLTISSLQPEDFATYYCQQYYSTP----",
+          "IGKV1D-8*01": "VIWMTQSPSLLSASTGDRVTISCRMSQGI------SSYLAWYQQKPGKAPELLIYAA-----STLQSGVPSRFSGSG--SGTDFTLTISCLQSEDFATYYCQQYYSFP----",
+          "IGKV1D-8*02": "AIWMTQSPSLLSASTGDRVTISCRMSQGI------SSYLAWYQQKPGKAPELLIYAA-----STLQSGVPSRFSGSG--SGTDFTLTISCLQSEDFATYYCQQYYSFP----",
+          "IGKV1D-8*03": "VIWMTQSPSLLSASTGDRVTISCRMSQGI------SSYLAWYQQKPGKAPELLIYAA-----STLQSGVPSRFSGSG--SGTDFTLTISCLQSEDFATYYCQQYYSFP----",
+          "IGKV2-18*01": "DIVMTQTPPSLPVNPGEPASISCRSSQSLLHS-NGYTYLHWYLQKPGQSPQLLIYRV-----SNHLSGVPDRFSGSG--SGSDFTLKISWVEAEDVGVYYCMQATQFP----",
+          "IGKV2-24*01": "DIVMTQTPLSSPVTLGQPASISCRSSQSLVHS-DGNTYLSWLQQRPGQPPRLLIYKI-----SNRFSGVPDRFSGSG--AGTDFTLKISRVEAEDVGVYYCMQATQFP----",
+          "IGKV2-28*01": "DIVMTQSPLSLPVTPGEPASISCRSSQSLLHS-NGYNYLDWYLQKPGQSPQLLIYLG-----SNRASGVPDRFSGSG--SGTDFTLKISRVEAEDVGVYYCMQALQTP----",
+          "IGKV2-29*01": "DIVMTQTPLSLSVTPGQPASISCKSSQSLLHS-DGKTYLYWYLQKPGQSPQLLIYEV-----SSRFSGVPDRFSGSG--SGTDFTLKISRVEAEDVGVYY-MQGIHLP----",
+          "IGKV2-29*02": "DIVMTQTPLSLSVTPGQPASISCKSSQSLLHS-DGKTYLYWYLQKPGQSPQLLIYEV-----SSRFSGVPDRFSGSG--SGTDFTLKISRVEAEDVGVYYCMQGIHLP----",
+          "IGKV2-29*03": "DIVMTQTPLSLSVTPGQPASISCKSSQSLLHS-DGKTYLYWYLQKPGQSPQLLIYEV-----SSRFSGVPDRFSGSG--SGTDFTLKISRVEAEDVGVYYCMQGIHLP----",
+          "IGKV2-30*01": "DVVMTQSPLSLPVTLGQPASISCRSSQSLVYS-DGNTYLNWFQQRPGQSPRRLIYKV-----SNRDSGVPDRFSGSG--SGTDFTLKISRVEAEDVGVYYCMQGTHWP----",
+          "IGKV2-30*02": "DVVMTQSPLSLPVTLGQPASISCRSSQSLVHS-DGNTYLNWFQQRPGQSPRRLIYKV-----SNRDSGVPDRFSGSG--SGTDFTLKISRVEAEDVGVYYCMQGTHWP----",
+          "IGKV2-4*01": "DIVMTQHLLSLPIPLGEPASISCRSSQSLLHS-DGNTYLDWYLQKPGQSPQLLIYTI-----SNKFYGVPNKFSGSR--SGTGFTLKFSKVEAEDVGVYCCEQGLQGP----",
+          "IGKV2-40*01": "DIVMTQTPLSLPVTPGEPASISCRSSQSLLDSDDGNTYLDWYLQKPGQSPQLLIYTL-----SYRASGVPDRFSGSG--SGTDFTLKISRVEAEDVGVYYCMQRIEFP----",
+          "IGKV2/OR2-7D*01": "DILLTQTPLSLSITPGEPASISCRSSRSLLHS-NGNTYLHW-LQKPGQPPQCLICKV-----SNRFSGVPDRFSGSG--SGIDFTLKISPVEAADVGVYITACKLHTGP---",
+          "IGKV2/OR22-4*01": "DIVMTQTPLSLPVTPGEPASISCRSSESLLDTDDEYTYLNWYLQKPGQSPQLLIYEV-----SNRASGVPDRFSGSG--SGTDFTLKISRVEA-DVGVYYCMQALQTP----",
+          "IGKV2D-18*01": "DIVMTQTPPSLPVNPGEPASISCRSSQSLLHS-NGYTYLHWYPQKPGQSPQLLIYRV-----SSRFSGVPDRFSGSG--SGSDFTLKISWVEAEDVGVYYCMQATQFP----",
+          "IGKV2D-24*01": "DIVMTQTPLSSPVTLGQPASISFRSSQSLVHS-DGNTYLSWLQQRPGQPPRLLIYKV-----SNRFSGVPDRFSGSG--AGTDFTLKISRVEAEDVGVYYCTQATQFP----",
+          "IGKV2D-26*01": "EIVMTQTPLSLSITPGEQASISCRSSQSLLHS-DGYTYLYWFLQKARPVSTLLIYEV-----SNRFSGVPDRFSGSG--SGTDFTLKISRVEAEDFGVYYCMQDAQDP----",
+          "IGKV2D-26*02": "EIVMTQTPLSLSITPGEQASMSCRSSQSLLHS-DGYTYLYWFLQKARPVSTLLICEV-----SNRFSGVPDRFSGSG--SGTDFTLKISRVEAEDFGVYYCMQDAQDP----",
+          "IGKV2D-26*03": "EIVMTQTPLSLSITPGEQASMSCRSSQSLLHS-DGYTYLYWFLQKARPVSTLLIYEV-----SNRFSGVPDRFSGSG--SGTDFTLKISRVEAEDFGVYYCMQDAQDP----",
+          "IGKV2D-28*01": "DIVMTQSPLSLPVTPGEPASISCRSSQSLLHS-NGYNYLDWYLQKPGQSPQLLIYLG-----SNRASGVPDRFSGSG--SGTDFTLKISRVEAEDVGVYYCMQALQTP----",
+          "IGKV2D-29*01": "DIVMTQTPLSLSVTPGQPASISCKSSQSLLHS-DGKTYLYWYLQKPGQPPQLLIYEV-----SNRFSGVPDRFSGSG--SGTDFTLKISRVEAEDVGVYYCMQSIQLP----",
+          "IGKV2D-29*02": "DIVMTQTPLSLSVTPGQPASISCKSSQSLLHS-DGKTYLYWYLQKPGQSPQLLIYEV-----SNRFSGVPDRFSGSG--SGTDFTLKISRVEAEDVGVYYCMQSIQLP----",
+          "IGKV2D-30*01": "DVVMTQSPLSLPVTLGQPASISCRSSQSLVYS-DGNTYLNWFQQRPGQSPRRLIYKV-----SNWDSGVPDRFSGSG--SGTDFTLKISRVEAEDVGVYYCMQGTHWP----",
+          "IGKV2D-40*01": "DIVMTQTPLSLPVTPGEPASISCRSSQSLLDSDDGNTYLDWYLQKPGQSPQLLIYTL-----SYRASGVPDRFSGSG--SGTDFTLKISRVEAEDVGVYYCMQRIEFP----",
+          "IGKV3-11*01": "EIVLTQSPATLSLSPGERATLSCRASQSV------SSYLAWYQQKPGQAPRLLIYDA-----SNRATGIPARFSGSG--SGTDFTLTISSLEPEDFAVYYCQQRSNWP----",
+          "IGKV3-11*02": "EIVLTQSPATLSLSPGERATLSCRASQSV------SSYLAWYQQKPGQAPRLLIYDA-----SNRATGIPARFSGSG--SGRDFTLTISSLEPEDFAVYYCQQRSNWP----",
+          "IGKV3-15*01": "EIVMTQSPATLSVSPGERATLSCRASQSV------SSNLAWYQQKPGQAPRLLIYGA-----STRATGIPARFSGSG--SGTEFTLTISSLQSEDFAVYYCQQYNNWP----",
+          "IGKV3-20*01": "EIVLTQSPGTLSLSPGERATLSCRASQSVS-----SSYLAWYQQKPGQAPRLLIYGA-----SSRATGIPDRFSGSG--SGTDFTLTISRLEPEDFAVYYCQQYGSSP----",
+          "IGKV3-7*01": "EIVMTQSPPTLSLSPGERVTLSCRASQSVS-----SSYLTWYQQKPGQAPRLLIYGA-----STRATSIPARFSGSG--SGTDFTLTISSLQPEDFAVYYCQQDHNLP----",
+          "IGKV3-7*02": "EIVMTQSPPTLSLSPGERVTLSCRASQSVS-----SSYLSWYQQKPGQAPRLLIYGA-----STRATGIPARFSGSG--SGTDFTLTISSLQPEDFAVYYCQQDYNLP----",
+          "IGKV3-7*03": "EIVMTQSPPTLSLSPGERVTLSCRASQSVS-----SSYLTWYQQKPGQAPRLLIYGA-----STRATSIPARFSGSG--SGRDFTLTISSLQPEDFAVYYCQQDHNLP----",
+          "IGKV3-7*04": "EIVMTQSPPTLSLSPGERVTLSCRASQSVS-----SSYLTWYQQKPGQAPRLLIYGA-----STRATSIPARFSGSG--SGTDFTLTISSLQPEDFAVYYCQQDYNLP----",
+          "IGKV3/OR2-268*01": "EIVMTQSPATLSLSPGERATLSCRASQSVS-----SSYLSWYQQKPGQAPRLLIYGA-----STRATGIPARFSGSG--SGTDFTLTISSLQPEDFAVYYCQQDYNLP----",
+          "IGKV3/OR2-268*02": "EIVMTQSPATLSLSPGERATLSCRASQSVS-----SSYLSWYQQKPGQAPRLLIYGA-----STRATGIPARFSGSG--SGTDFTLTISSLQPEDFAVYYCQQDYNLP----",
+          "IGKV3D-11*01": "EIVLTQSPATLSLSPGERATLSCRASQGV------SSYLAWYQQKPGQAPRLLIYDA-----SNRATGIPARFSGSG--PGTDFTLTISSLEPEDFAVYYCQQRSNWH----",
+          "IGKV3D-11*02": "EIVLTQSPATLSLSPGERATLSCRASQSV------SSYLAWYQQKPGQAPRLLIYDA-----SNRATGIPARFSGSG--PGTDFTLTISSLEPEDFAVYYCQQRSNWH----",
+          "IGKV3D-11*03": "EIVLTQSPATLSLSPGERATLSCRASQGV------SSNLAWYQQKPGQAPRLLIYDA-----SNRATGIPARFSGSG--PGTDFTLTISSLEPEDFAVYYCQQRSNWH----",
+          "IGKV3D-15*01": "EIVMTQSPATLSVSPGERATLSCRASQSV------SSNLAWYQQKPGQAPRLLIYGA-----STRATGIPARFSGSG--SGTEFTLTISSLQSEDFAVYYCQQYNNWP----",
+          "IGKV3D-15*02": "EIVMMQSPATLSVSPGERATLSCRASQSV------SSNLAWYQQKPGQAPRLLIYGA-----STRATGIPARFSGSG--SGTEFTLTISSLQSEDFAVYYCQQYNN-P----",
+          "IGKV3D-15*03": "EIVMTQSPATLSVSPGERATLSCRASQSV------SSNLAWYQQKPGQAPRLLIYGA-----SIRATGIPARFSGSG--SGTEFTLTISILQSEDFAVYYCQQYNNWP----",
+          "IGKV3D-20*01": "EIVLTQSPATLSLSPGERATLSCGASQSVS-----SSYLAWYQQKPGLAPRLLIYDA-----SSRATGIPDRFSGSG--SGTDFTLTISRLEPEDFAVYYCQQYGSSP----",
+          "IGKV3D-20*02": "EIVLTQSPATLSLSPGERATLSCRASQSVS-----SSYLAWYQQKPGQAPRLLIYDA-----SSRATGIPDRFSGSG--SGTDFTLTISRLEPEDFAVYYCQQRSNWH----",
+          "IGKV3D-7*01": "EIVMTQSPATLSLSPGERATLSCRASQSVS-----SSYLSWYQQKPGQAPRLLIYGA-----STRATGIPARFSGSG--SGTDFTLTISSLQPEDFAVYYCQQDYNLP----",
+          "IGKV4-1*01": "DIVMTQSPDSLAVSLGERATINCKSSQSVLYSSNNKNYLAWYQQKPGQPPKLLIYWA-----STRESGVPDRFSGSG--SGTDFTLTISSLQAEDVAVYYCQQYYSTP----",
+          "IGKV5-2*01": "ETTLTQSPAFMSATPGDKVNISCKASQDI------DDDMNWYQQKPGEAAIFIIQEA-----TTLVPGIPPRFSGSG--YGTDFTLTINNIESEDAAYYFCLQHDNFP----",
+          "IGKV6-21*01": "EIVLTQSPDFQSVTPKEKVTITCRASQSI------GSSLHWYQQKPDQSPKLLIKYA-----SQSFSGVPSRFSGSG--SGTDFTLTINSLEAEDAATYYCHQSSSLP----",
+          "IGKV6-21*02": "EIVLTQSPDFQSVTPKEKVTITCRASQSI------GSSLHWYQQKPDQSPKLLIKYA-----SQSISGVPSRFSGSG--SGTDFTLTINSLEAEDAATYYCHQSSSLP----",
+          "IGKV6D-21*01": "EIVLTQSPDFQSVTPKEKVTITCRASQSI------GSSLHWYQQKPDQSPKLLIKYA-----SQSFSGVPSRFSGSG--SGTDFTLTINSLEAEDAATYYCHQSSSLP----",
+          "IGKV6D-21*02": "EIVLTQSPDFQSVTPKEKVTITCRASQSI------GSSLHWYQQKPDQSPKLLIKYA-----SQSISGVPSRFSGSG--SGTDFTLTINSLEAEDAAAYYCHQSSSLP----",
+          "IGKV6D-41*01": "DVVMTQSPAFLSVTPGEKVTITCQASEGI------GNYLYWYQQKPDQAPKLLIKYA-----SQSISGVPSRFSGSG--SGTDFTFTISSLEAEDAATYYCQQGNKHP----",
+          "IGKV7-3*01": "DIVLTQSPASLAVSPGQRATITCRASESVSF--LGINLIHWYQQKPGQPPKLLIYQA-----SNKDTGVPARFSGSG--SGTDFTLTINPVEANDTANYYCLQSKNFP----"
+        }
+    }
+}
+
+HUMAN_IMGT_IG_J = {
+    'H': {
+        "positions": [
+            "H112C", "H112B", "H112A", "H112", "H113", "H114", "H115", "H116", "H117", "H118", "H119", "H120", "H121", "H122", "H123", "H124", "H125", "H126", "H127", "H128"
+        ],
+        "aligned_sequences": {
+            "IGHJ1*01": "---AEYFQHWGQGTLVTVSS",
+            "IGHJ2*01": "---YWYFDLWGRGTLVTVSS",
+            "IGHJ3*01": "----DAFDVWGQGTMVTVSS",
+            "IGHJ3*02": "----DAFDIWGQGTMVTVSS",
+            "IGHJ4*01": "-----YFDYWGQGTLVTVSS",
+            "IGHJ4*02": "-----YFDYWGQGTLVTVSS",
+            "IGHJ4*03": "-----YFDYWGQGTLVTVSS",
+            "IGHJ5*01": "----NWFDSWGQGTLVTVSS",
+            "IGHJ5*02": "----NWFDPWGQGTLVTVSS",
+            "IGHJ6*01": "YYYYYGMDVWGQGTTVTVSS",
+            "IGHJ6*04": "YYYYYGMDVWGKGTTVTVSS"
+        }
+    },
+    'L': {
+        "positions": [
+            "L116", "L117", "L118", "L119", "L120", "L121", "L122", "L123", "L124", "L125", "L126", "L127"
+        ],
+        "aligned_sequences": {
+            "IGLJ1*01": "YVFGTGTKVTVL",
+            "IGLJ2*01": "VVFGGGTKLTVL",
+            "IGLJ3*01": "VVFGGGTKLTVL",
+            "IGLJ3*02": "WVFGGGTKLTVL",
+            "IGLJ4*01": "FVFGGGTQLIIL",
+            "IGLJ5*01": "WVFGEGTELTVL",
+            "IGLJ5*02": "WVFGEGTELTVL",
+            "IGLJ6*01": "NVFGSGTKVTVL",
+            "IGLJ7*01": "AVFGGGTQLTVL",
+            "IGLJ7*02": "AVFGGGTQLTAL"
+        }
+    },
+    'K': {
+        "positions": [
+            "L116", "L117", "L118", "L119", "L120", "L121", "L122", "L123", "L124", "L125", "L126", "L127"
+        ],
+        "aligned_sequences": {
+            "IGKJ1*01": "WTFGQGTKVEIK",
+            "IGKJ2*01": "YTFGQGTKLEIK",
+            "IGKJ2*02": "CTFGQGTKLEIK",
+            "IGKJ2*03": "YSFGQGTKLEIK",
+            "IGKJ2*04": "CSFGQGTKLEIK",
+            "IGKJ3*01": "FTFGPGTKVDIK",
+            "IGKJ4*01": "LTFGGGTKVEIK",
+            "IGKJ4*02": "LTFGGGTKVEIK",
+            "IGKJ5*01": "ITFGQGTRLEIK"
+        }
+    }
+}

abnumber/position.py

@@ -0,0 +1,158 @@
+import copy
+from typing import List, Union
+
+from abnumber.common import _validate_chain_type, SCHEME_POSITION_TO_REGION, SCHEME_VERNIER, POS_REGEX
+
+
+class Position:
+    """Numbered position using a given numbering scheme
+
+    Used as a key to store Position -> Amino acid information.
+
+    Position objects are sortable according to the schema simply using ``sorted()``.
+    """
+    def __init__(self, chain_type: str, number: int, letter: str, scheme: str):
+        _validate_chain_type(chain_type)
+        self.chain_type: str = chain_type
+        self.number: int = int(number)
+        self.letter: str = letter.strip()
+        self.scheme: str = scheme
+        self.cdr_definition: str = self.scheme
+        self.cdr_definition_position: int = self.number
+
+    def copy(self):
+        return copy.copy(self)
+
+    def _key(self):
+        # Note: We are not including chain_type, but just Heavy/Light flag, to keep Kappa and Lambda chain positions equal
+        return self.chain_type_prefix(), self.number, self.letter, self.scheme
+
+    def __repr__(self):
+        return f'{self.chain_type_prefix()}{self.number}{self.letter} ({self.scheme})'
+
+    def __str__(self):
+        return self.format()
+
+    def set_cdr_definition(self, cdr_definition: str, cdr_definition_position: int):
+        assert cdr_definition is not None, 'cdr_definition is required'
+        assert cdr_definition_position is not None, 'cdr_definition_position is required'
+        self.cdr_definition = cdr_definition
+        self.cdr_definition_position = cdr_definition_position
+
+    def format(self, chain_type=True, region=False, rjust=False, ljust=False, fillchar=' '):
+        """Format Position to string
+
+        :param chain_type: Add chain type prefix (H/L)
+        :param region: Add region prefix (FR1, CDR1, ...)
+        :param rjust: Align text to the right
+        :param ljust: Align text to the left
+        :param fillchar: Characer to use for alignment padding
+        :return: formatted string
+        """
+        formatted = f'{self.number}{self.letter}'
+        if chain_type:
+            formatted = f'{self.chain_type_prefix()}{formatted}'
+        if region:
+            formatted = f'{self.get_region()} {formatted}'
+        just = 4 + 1* int(chain_type) + 5 * int(region)
+        if rjust:
+            formatted = formatted.rjust(just, fillchar)
+        if ljust:
+            formatted = formatted.ljust(just, fillchar)
+        return formatted
+
+    def __hash__(self):
+        return self._key().__hash__()
+
+    def __eq__(self, other):
+        return isinstance(other, Position) and self._key() == other._key()
+
+    def __ge__(self, other):
+        return self == other or self > other
+
+    def __le__(self, other):
+        return self == other or self < other
+
+    def __lt__(self, other):
+        if not isinstance(other, Position):
+            raise TypeError(f'Cannot compare Position object with {type(other)}: {other}')
+        assert self.is_heavy_chain() == other.is_heavy_chain(), f'Positions do not come from the same chain: {self}, {other}'
+        assert self.scheme == other.scheme, 'Comparing positions in different schemes is not implemented'
+        return self._sort_key() < other._sort_key()
+
+    def chain_type_prefix(self):
+        if self.chain_type == 'H':
+            return 'H'
+        if self.chain_type in ['K', 'L']:
+            return 'L'
+        raise NotImplementedError(f'Unknown chain type "{self.chain_type}"')
+
+    def _sort_key(self):
+        letter_ord = ord(self.letter) if self.letter else 0
+        if self.scheme == 'imgt':
+            if self.number in [33, 61, 112]:
+                # position 112 is sorted in reverse
+                letter_ord = -letter_ord
+        elif self.scheme in ['chothia', 'kabat', 'aho']:
+            # all letters are sorted alphabetically for these schemes
+            pass
+        else:
+            raise NotImplementedError(f'Cannot compare positions of scheme: {self.scheme}')
+        return self.is_heavy_chain(), self.number, letter_ord
+
+    def get_region(self):
+        """Get string name of this position's region
+
+        :return: uppercase string, one of: ``"FR1", "CDR1", "FR2", "CDR2", "FR3", "CDR3", "FR4"``
+        """
+        if self.cdr_definition in SCHEME_POSITION_TO_REGION:
+            regions = SCHEME_POSITION_TO_REGION[self.cdr_definition]
+        else:
+            regions = SCHEME_POSITION_TO_REGION[f'{self.cdr_definition}_{self.chain_type}']
+        return regions[self.cdr_definition_position]
+
+    def is_in_cdr(self):
+        """Check if given position is found in the CDR regions"""
+        return self.get_region().lower().startswith('cdr')
+
+    def is_in_vernier(self):
+        if self.cdr_definition != 'kabat':
+            raise NotImplementedError('Vernier zone identification is currently supported '
+                                      f'only with Kabat CDR definitions, got: {self.cdr_definition}')
+        return self.cdr_definition_position in SCHEME_VERNIER.get(f'{self.cdr_definition}_{self.chain_type}', [])
+
+    @classmethod
+    def from_string(cls, position, chain_type, scheme):
+        """Create Position object from string, e.g. "H5"
+
+        Note that Positions parsed from string do not support separate CDR definitions.
+        """
+        match = POS_REGEX.match(position.upper())
+        _validate_chain_type(chain_type)
+        expected_chain_prefix = 'H' if chain_type == 'H' else 'L'
+        if match is None:
+            raise IndexError(f'Expected position format chainNumberLetter '
+                             f'(e.g. "{expected_chain_prefix}112A" or "112A"), got: "{position}"')
+        chain_prefix, number, letter = match.groups()
+        number = int(number)
+        if chain_prefix and expected_chain_prefix != chain_prefix:
+            raise IndexError(f'Use no prefix or "{expected_chain_prefix}" prefix for "{chain_type}" chain. '
+                             f'Got: "{chain_prefix}".')
+        return cls(chain_type=chain_type, number=number, letter=letter, scheme=scheme)
+
+    def is_heavy_chain(self):
+        return self.chain_type == 'H'
+
+    def is_light_chain(self):
+        return self.chain_type in 'KL'
+
+
+def sort_positions(positions: List[str], chain_type: str, scheme: str) -> List:
+    """Sort position strings to correct order based on given scheme"""
+    has_prefix = [p.startswith('H') or p.startswith('L') for p in positions]
+    assert all(has_prefix) or not any(has_prefix), 'Inconsistent position prefix'
+    has_prefix = all(has_prefix)
+
+    position_objects = [Position.from_string(p, chain_type=chain_type, scheme=scheme) for p in positions]
+
+    return [p.format(chain_type=has_prefix) for p in sorted(position_objects)]

anarci/__init__.py

@@ -0,0 +1,3 @@
+__version__ = "1.b"
+__all__ = ["anarci", "schemes"]
+from .anarci import *

anarci/anarci.py

@@ -0,0 +1,1013 @@
+#    ANARCI - Antibody Numbering and Antigen Receptor ClassIfication
+#    Copyright (C) 2016 Oxford Protein Informatics Group (OPIG)
+#
+#    This program is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.#
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+'''
+ANARCI - Antigen Receptor Numbering And ClassIfication
+
+Oxford Protein Informatics Group (OPIG). 2015-17
+
+ANARCI performs alignments of sequences to databases of Hidden Markov Models (HMMs).
+Those that align with a significant score are classified by species and chain type.
+They are then numbered with a scheme of the user's choosing. 
+
+Currently implemented schemes: 
+    IMGT
+    Chothia (IGs only)
+    Kabat (IGs only)
+    Martin / Enhanced Chothia (IGs only)
+    AHo 
+    Wolfguy (IGs only)
+
+Currently recognisable species (chains):
+    Human (heavy, kappa, lambda, alpha, beta)
+    Mouse (heavy, kappa, lambda, alpha, beta)
+    Rat (heavy, kappa, lambda)
+    Rabbit (heavy, kappa, lambda)
+    Pig (heavy, kappa, lambda)
+    Rhesus Monkey (heavy, kappa)
+    
+Notes:
+ o Use assign_germline to get a better species assignment
+ o Each scheme has been implemented to follow the published specification as closely as possible. However, in places some schemes
+   do not specifiy where insertions should be placed (e.g. imgt FW3). In these cases the HMM alignment is used. This can give rise
+   to inserted positions that were not described by the respective paper. 
+ o AHo is implemented heuristically based on chain type. If one grafted a foreign CDR1 loop onto, say, a VH domain, it will be 
+   numbered as if it is a CDRH1 loop. 
+    
+
+'''
+
+import os
+import sys
+import tempfile
+import gzip
+import math
+from functools import partial
+from textwrap import wrap
+from subprocess import Popen, PIPE
+from itertools import groupby, islice
+from multiprocessing import Pool
+
+from Bio.SearchIO.HmmerIO import Hmmer3TextParser as HMMERParser
+
+# Import from the schemes submodule
+from .schemes import *
+from .germlines import all_germlines
+    
+all_species = list(all_germlines['V']['H'].keys())
+
+amino_acids = sorted(list("QWERTYIPASDFGHKLCVNM"))
+set_amino_acids = set(amino_acids)
+anarci_path  = os.path.split(__file__)[0]
+
+scheme_short_to_long = { "m":"martin", "c":"chothia", "k":"kabat","imgt":"imgt", "kabat":"kabat", "chothia":"chothia", "martin":"martin", "i":"imgt", "a":"aho","aho":"aho","wolfguy":"wolfguy", "w":"wolfguy"}
+
+scheme_names = list(scheme_short_to_long.keys()) 
+chain_type_to_class = {"H":"H", "K":"L", "L":"L", "A":"A", "B":"B", "G":"G", "D":"D"}
+
+HMM_path =  os.path.join( anarci_path, "dat", "HMMs" )
+
+all_reference_states = list(range( 1, 129)) # These are the IMGT reference states (matches)
+
+class HMMscanError(Exception):
+    def __init__(self, message):
+        # Call the base class constructor with the parameters it needs
+        super(HMMscanError, self).__init__(message)
+
+## Utility functions ##
+def read_fasta(filename):
+    """
+    Read a sequence file and parse as description, string 
+    """
+    return [ r for r in fasta_iter(filename) ]
+
+def fasta_iter(fasta_name):
+    """
+    Given a fasta file. yield tuples of header, sequence
+    https://www.biostars.org/p/710/
+    """
+    if fasta_name.endswith( '.gz' ): # IOError raised upon iteration if not a real gzip file.
+        fh = gzip.open(fasta_name)
+    else:
+        fh = open(fasta_name)
+    faiter = (x[1] for x in groupby(fh, lambda line: line[0] == ">"))
+    for header in faiter:
+        header = next(header)[1:].strip()
+        #header = header.next()[1:].strip()
+        seq = "".join(s.strip() for s in next(faiter))
+        yield header, seq
+
+
+def write_fasta(sequences, f):
+    """
+    Write a list of sequences to file. 
+    
+    should be a list of name, sequence tuples
+    
+    f should be an open file
+    """
+    for name, sequence in sequences:
+        print(">%s"%name, file=f)
+        print('\n'.join(['\n'.join(wrap(block, width=80)) for block in sequence.splitlines()]), file=f)
+    
+    
+def validate_sequence(sequence):
+    """
+    Check whether a sequence is a protein sequence or if someone has submitted something nasty.
+    """
+    assert len(sequence) < 10000, "Sequence too long."
+    assert not (set( sequence.upper() ) - set_amino_acids ), "Unknown amino acid letter found in sequence: %s"% ", ".join(list((set( sequence.upper() ) - set_amino_acids )))    
+    return True
+
+def validate_numbering(xxx_todo_changeme, name_seq=[]):
+    """
+    Wrapper to do some basic validation of the numbering.
+    
+    Further validation could be done but at the moment we just check that the numbering indices are incremental (they should be)
+    """
+    (numbering, start, end) = xxx_todo_changeme
+    name, seq = name_seq
+    last = -1
+    nseq=""
+
+    for (index, _), a in numbering:
+        assert index >= last, "Numbering was found to decrease along the sequence %s. Please report."%name
+        last = index
+        nseq += a.replace("-","")
+
+    assert nseq in seq.replace("-",""), "The algorithm did not number a contiguous segment for sequence %s. Please report"%name
+
+    return numbering, start, end
+
+def grouper(n, iterable):
+    '''
+    Group entries of an iterable by n
+    '''
+    it = iter(iterable)
+    def take():
+        while 1:
+            yield list( islice(it,n) )
+    return iter(take().__next__, [] )
+
+def anarci_output(numbered, sequences, alignment_details, outfile, sequence_id=None, domain_id=None):
+    """
+    Outputs to open file
+
+    If sequence_id is specified as an integer then only this sequence will be printed. 
+    Otherwise all sequences will be printed.
+
+    If domain_id is specified as an integer then only this domain will be printed. 
+    Otherwise all domains will be printed.
+
+    If domain_id is specified then sequence_id must also be specified. 
+    """       
+    assert (sequence_id is not None) or (sequence_id is None and domain_id is None), "If domain_id is specified, sequence_id must also be specified."
+    for i in range(len(numbered)):
+        if sequence_id is None:
+            print("# %s"%sequences[i][0], file=outfile) # print the name
+        if numbered[i] is not None:
+            if sequence_id is not None:
+                if i != sequence_id: continue
+            print("# ANARCI numbered", file=outfile)
+            for j in range( len(numbered[i])): # Iterate over domains
+                if domain_id is not None:
+                    if j != domain_id: continue
+                print("# Domain %d of %d"%(j+1, len(numbered[i]) ), file=outfile)
+                print("# Most significant HMM hit", file=outfile)
+                print("#|species|chain_type|e-value|score|seqstart_index|seqend_index|", file=outfile)
+                alignment_details[i][j]["evalue"] = str( alignment_details[i][j]["evalue"] )
+                print("#|%s|%s|%s|%.1f|%d|%d|"%tuple( [alignment_details[i][j][field] for field in 
+                                                                     ["species","chain_type","evalue","bitscore"]] 
+                                                                   +[ numbered[i][j][1], numbered[i][j][2]] ), file=outfile)
+                
+                if 'germlines' in alignment_details[i][j]:
+                    print('# Most sequence-identical germlines', file=outfile)
+                    print('#|species|v_gene|v_identity|j_gene|j_identity|', file=outfile)
+                    (species, vgene), vid =alignment_details[i][j]['germlines'].get('v_gene', [['','unknown'],0])
+                    if vgene is None:
+                        vgene, vid = 'unknown', 0
+                    (_,jgene), jid =alignment_details[i][j]['germlines'].get('j_gene', [['','unknown'],0])
+                    if jgene is None:
+                        jgene, jid = 'unknown', 0
+                    print('#|%s|%s|%.2f|%s|%.2f|'%(species, vgene, vid, jgene, jid ), file=outfile)	
+                chain_type = chain_type_to_class[  alignment_details[i][j]["chain_type"] ]
+                print("# Scheme = %s"%alignment_details[i][j]["scheme"], file=outfile)
+                if len( numbered[i][j][0] ) == 0:
+                    print("# Warning: %s scheme could not be applied to this sequence."%alignment_details[i][j]["scheme"], file=outfile)            
+                for (index, insertion), aa in numbered[i][j][0]:
+                    print(chain_type, ("%d"%index).ljust(5), insertion, aa, file=outfile)
+        print("//", file=outfile)
+
+def csv_output(sequences, numbered, details, outfileroot):
+    '''
+    Write numbered sequences to csv files. A csv file is written for each chain type.
+
+    Kappa and Lambda chains are written to the same file
+
+    The sequences will written aligned to the numbering scheme. Gaps in the sequences with respect to the alignment are written
+    as a '-'
+
+    @param sequences: List of name, sequence tuples    
+    @param numbered: Numbered sequences in the same order as the sequences list. 
+    @param details: List of alignment details in the same order as the sequences list.
+    @param outfileroot: The file path for csv files to write. _<chain_type>.csv will be appended to this.
+    '''
+    
+    chain_types = {}        
+    pos_ranks = {}
+    all_pos = {}
+    _lc = {'K':'KL','L':'KL'}
+
+
+    # Divide the set into chain types and find how to order the numbering for each type.
+    for i in range( len(sequences) ): # Iterate over entries
+        if numbered[i] is None: continue
+
+        for j in range(len(numbered[i])): # Iterate over domains.
+            # Record the chain type index
+            c = details[i][j]['chain_type']
+            c = _lc.get(c, c) # Consider lambda and kappa together.
+            chain_types.setdefault( c, [] ).append( (i,j) ) 
+            if c not in pos_ranks:
+                pos_ranks[c] = {}
+                all_pos[c] = set()
+
+            # Update the insertion order for the scheme. i.e. is it A B C or C B A (e.g. imgt 111 and 112 repectively)
+            l = -1 
+            r = 0 
+            for p, _ in numbered[i][j][0]:
+                if p[0] != l:
+                    l = p[0]
+                    r = 0
+                else:
+                    r +=1
+                pos_ranks[c][p] = max( r, pos_ranks[c].get( p, r ) )
+                all_pos[c].add( p )
+
+    # Write a new file for each chain type. Kappa and lambda are written together as light chains. 
+    for cts in ['H','KL','A','B','G','D']:
+        if cts in chain_types:
+            with open( outfileroot + '_%s.csv'%cts, 'w' ) as out:
+
+                # Sort the positions by index and insertion order
+                positions = sorted( all_pos[cts], key = lambda p: (p[0], pos_ranks[cts][p]) )
+
+                # Header line
+                fields = ['Id','domain_no','hmm_species','chain_type','e-value','score','seqstart_index','seqend_index',
+                          'identity_species','v_gene','v_identity','j_gene','j_identity']
+                fields += [ ('%d%s'%(p)).strip() for p in positions ]
+                print(','.join( fields ), file=out)
+
+                # Iterate over the domains identified
+                for i,j in chain_types[cts]:
+                    line = [ sequences[i][0].replace(',',' '),      
+                             str(j),
+                             details[i][j].get('species',''),
+                             details[i][j].get('chain_type',''),
+                             str(details[i][j].get('evalue','')),
+                             str(details[i][j].get('bitscore','')),
+                             str(numbered[i][j][1]),
+                             str(numbered[i][j][2]),
+                             details[i][j].get('germlines',{}).get( 'v_gene',[['',''],0] )[0][0],
+                             details[i][j].get('germlines',{}).get( 'v_gene',[['',''],0] )[0][1],
+                             '%.2f'%details[i][j].get('germlines',{}).get( 'v_gene',[['',''],0] )[1],
+                             details[i][j].get('germlines',{}).get( 'j_gene',[['',''],0] )[0][1],
+                             '%.2f'%details[i][j].get('germlines',{}).get( 'j_gene',[['',''],0] )[1] ]
+
+                    # Hash the numbering. Insertion order has been preserved in the positions sort.
+                    d = dict( numbered[i][j][0] )
+                    line += [ d.get(p,'-') for p in positions ]
+
+                    assert len( line ) == len( fields )
+                    print(','.join( line ), file=out)
+
+
+
+## Parsing and recognising domain hits from hmmscan ##
+def _domains_are_same(dom1, dom2):
+    """
+    Check to see if the domains are overlapping.
+    @param dom1: 
+    @param dom2: 
+
+    @return: True or False  
+    """
+    dom1, dom2 = sorted( [dom1, dom2], key=lambda x: x.query_start  )
+    if dom2.query_start >= dom1.query_end:
+        return False
+    return True
+
+
+def _parse_hmmer_query(query, bit_score_threshold=80, hmmer_species=None):
+    """
+    
+    @param query: hmmer query object from Biopython
+    @param bit_score_threshold: the threshold for which to consider a hit a hit. 
+    
+    The function will identify multiple domains if they have been found and provide the details for the best alignment for each domain.
+    This allows the ability to identify single chain fvs and engineered antibody sequences as well as the capability in the future for identifying constant domains. 
+
+    """
+    hit_table = [ ['id', 'description', 'evalue', 'bitscore', 'bias', 
+                    'query_start', 'query_end' ] ]
+
+    # Find the best hit for each domain in the sequence.
+
+    top_descriptions, domains,state_vectors = [], [], []
+    
+    if query.hsps: # We have some hits
+        # If we have specified a species, check to see we have hits for that species
+        # Otherwise revert back to using any species
+        if hmmer_species:
+            #hit_correct_species = [hsp for hsp in query.hsps if hsp.hit_id.startswith(hmmer_species) and hsp.bitscore >= bit_score_threshold]
+            hit_correct_species = []
+            for hsp in query.hsps:
+                if hsp.bitscore >= bit_score_threshold:
+                    for species in hmmer_species:
+                        if hsp.hit_id.startswith(species):
+                            hit_correct_species.append(hsp)
+
+            if hit_correct_species:
+                hsp_list = hit_correct_species
+            else:
+                print("Limiting hmmer search to species %s was requested but hits did not achieve a high enough bitscore. Reverting to using any species" %(hmmer_species))
+                hsp_list = query.hsps
+        else:
+            hsp_list = query.hsps
+
+        for hsp in sorted(hsp_list, key=lambda x: x.evalue): # Iterate over the matches of the domains in order of their e-value (most significant first)
+            new=True
+            if hsp.bitscore >= bit_score_threshold: # Only look at those with hits that are over the threshold bit-score.
+                for i in range( len(domains) ): # Check to see if we already have seen the domain
+                    if _domains_are_same( domains[i], hsp ):
+                        new = False
+                        break      
+                hit_table.append( [ hsp.hit_id, hsp.hit_description, hsp.evalue, hsp.bitscore, hsp.bias, hsp.query_start, hsp.query_end] )
+                if new: # It is a new domain and this is the best hit. Add it for further processing.
+                    domains.append( hsp )
+                    top_descriptions.append(  dict( list(zip(hit_table[0], hit_table[-1])) ) ) # Add the last added to the descriptions list. 
+
+        # Reorder the domains according to the order they appear in the sequence.         
+        ordering = sorted( list(range(len(domains))), key=lambda x: domains[x].query_start)
+        domains = [ domains[_] for _ in ordering ]
+        top_descriptions = [ top_descriptions[_] for _ in ordering ]         
+   
+    ndomains = len( domains )
+    for i in range(ndomains): # If any significant hits were identified parse and align them to the reference state.
+        domains[i].order = i
+        species, chain = top_descriptions[i]["id"].split("_")
+        state_vectors.append( _hmm_alignment_to_states(domains[i], ndomains, query.seq_len) ) # Alignment to the reference states.
+        top_descriptions[i][ "species"] = species # Reparse
+        top_descriptions[i][ "chain_type"] = chain
+        top_descriptions[i][ "query_start"] = state_vectors[-1][0][-1] # Make sure the query_start agree if it was changed
+
+    return hit_table, state_vectors, top_descriptions
+
+
+def _hmm_alignment_to_states(hsp, n, seq_length):
+    """
+    Take a hit hsp and turn the alignment into a state vector with sequence indices
+    """
+
+    # Extract the strings for the reference states and the posterior probability strings     
+    reference_string = hsp.aln_annotation["RF"]
+    state_string = hsp.aln_annotation["PP"]
+
+    assert len(reference_string) == len(state_string), "Aligned reference and state strings had different lengths. Don't know how to handle"
+
+    # Extract the start an end points of the hmm states and the sequence
+    # These are python indices i.e list[ start:end ] and therefore start will be one less than in the text file
+    _hmm_start = hsp.hit_start
+    _hmm_end = hsp.hit_end
+     
+    _seq_start = hsp.query_start
+    _seq_end = hsp.query_end
+
+    # Extact the full length of the HMM hit
+    species, ctype = hsp.hit_id.split('_')
+    _hmm_length = get_hmm_length( species, ctype )
+
+    # Handle cases where there are n terminal modifications.
+    # In most cases the user is going to want these included in the numbered domain even though they are not 'antibody like' and 
+    # not matched to the germline. Only allow up to a maximum of 5 unmatched states at the start of the domain
+    # Adds a bug here if there is a very short linker between a scfv domains with a modified n-term second domain
+    # Thus this is only done for the first identified domain ( hence order attribute on hsp )
+    if hsp.order == 0 and _hmm_start and _hmm_start < 5: 
+        n_extend = _hmm_start 
+        if _hmm_start > _seq_start:
+            n_extend = min( _seq_start , _hmm_start - _seq_start )
+        state_string = '8'*n_extend + state_string  
+        reference_string = 'x'*n_extend + reference_string
+        _seq_start = _seq_start - n_extend
+        _hmm_start = _hmm_start - n_extend
+
+    # Handle cases where the alignment should be extended to the end of the j-element
+    # This occurs when there a c-terminal modifications of the variable domain that are significantly different to germline
+    # Extension is only made when half of framework 4 has been recognised and there is only one domain recognised.
+    if n==1 and _seq_end < seq_length and (123 < _hmm_end < _hmm_length): # Extend forwards
+        n_extend = min( _hmm_length - _hmm_end, seq_length - _seq_end )
+        state_string = state_string + '8'*n_extend
+        reference_string = reference_string + 'x'*n_extend
+        _seq_end = _seq_end + n_extend
+        _hmm_end = _hmm_end + n_extend
+                    
+
+
+    # Generate lists for the states and the sequence indices that are included in this alignment
+    hmm_states = all_reference_states[ _hmm_start : _hmm_end ] 
+    sequence_indices = list(range(_seq_start,  _seq_end))
+    h, s = 0, 0 # initialise the current index in the hmm and the sequence
+    
+    state_vector = []
+    # iterate over the state string (or the reference string)
+    for i in range( len(state_string) ):
+        if reference_string[i] == "x": # match state
+            state_type = "m"
+        else: # insert state
+            state_type = "i"
+        
+        if state_string[i] == ".": # overloading if deleted relative to reference. delete_state
+            state_type = "d"
+            sequence_index = None
+        else:
+            sequence_index = sequence_indices[s]    
+        # Store the alignment as the state identifier (uncorrected IMGT annotation) and the index of the sequence
+        
+        state_vector.append(  ((hmm_states[h], state_type),  sequence_index )  )        
+
+        # Updates to the indices         
+        if state_type == "m":
+            h+=1
+            s+=1
+        elif state_type == "i":
+            s+=1
+        else: # delete state
+            h+=1
+        
+    return state_vector
+
+
+def parse_hmmer_output(filedescriptor="", bit_score_threshold=80, hmmer_species=None):
+    """
+    Parse the output of HMMscan and return top alignment and the score table for each input sequence.
+    """
+    results  = []
+    if type(filedescriptor) is str:
+        openfile = open
+    elif type(filedescriptor) is int:
+        openfile = os.fdopen
+    
+    with openfile(filedescriptor) as inputfile:
+        p = HMMERParser( inputfile )
+        for query in p:
+            results.append(_parse_hmmer_query(query,bit_score_threshold=bit_score_threshold,hmmer_species=hmmer_species ))
+
+    return results
+
+
+def run_hmmer(sequence_list,hmm_database="ALL",hmmerpath="", ncpu=None, bit_score_threshold=80, hmmer_species=None):
+    """
+    Run the sequences in sequence list against a precompiled hmm_database.
+
+    Those sequence that have a significant hit with a bit score over a threshold will
+    be recognised and an alignment given. The alignment will be used to number the 
+    sequence.
+
+    @param sequence_list: a list of (name, sequence) tuples. Both are strings
+    @param hmm_database: The hmm database to use. Currently, all hmms are in the ALL database.
+                         The code to develop new models is in build_pipeline in the git repo.
+    @param hmmerpath: The path to hmmer binaries if not in the path
+    @param ncpu: The number of cpu's to allow hmmer to use.
+    """
+
+    # Check that hmm_database is available
+    
+    assert hmm_database in ["ALL"], "Unknown HMM database %s"%hmm_database    
+    HMM = os.path.join( HMM_path, "%s.hmm"%hmm_database )
+
+
+    # Create a fasta file for all the sequences. Label them with their sequence index
+    # This will go to a temp file
+    fasta_filehandle, fasta_filename =  tempfile.mkstemp( ".fasta", text=True )
+    with os.fdopen(fasta_filehandle,'w') as outfile:
+        write_fasta(sequence_list, outfile)
+
+    output_filehandle, output_filename =  tempfile.mkstemp( ".txt", text=True )
+
+    # Run hmmer as a subprocess
+    if hmmerpath:
+        hmmscan = os.path.join(hmmerpath,"hmmscan")
+    else:
+        hmmscan = "hmmscan"
+    try:
+        if ncpu is None:
+            command = [ hmmscan, "-o", output_filename, HMM,  fasta_filename]
+        else:
+            command = [ hmmscan, "-o", output_filename, "--cpu", str(ncpu), HMM,  fasta_filename]
+        process = Popen( command, stdout=PIPE, stderr=PIPE  )
+        _, pr_stderr = process.communicate()
+
+        if pr_stderr:
+            _f = os.fdopen(output_filehandle) # This is to remove the filedescriptor from the os. I have had problems with it before.
+            _f.close()
+            
+            raise HMMscanError(pr_stderr)
+        results = parse_hmmer_output(output_filehandle, bit_score_threshold=bit_score_threshold, hmmer_species=hmmer_species)
+        
+    finally:
+        # clear up
+        os.remove(fasta_filename)
+        os.remove(output_filename)
+        
+    return results
+
+def get_hmm_length( species, ctype ):
+    '''
+    Get the length of an hmm given a species and chain type. 
+    This tells us how many non-insertion positions there could possibly be in a domain (127 or 128 positions under imgt)
+    '''
+    try:
+        return len(list(all_germlines['J'][ctype][species].values())[0].rstrip('-'))
+    except KeyError:
+        return 128
+
+
+def number_sequence_from_alignment(state_vector, sequence, scheme="imgt", chain_type=None):
+    """
+    Given you have an alignment. Give back the numbering
+    
+    @param state_vector: List of states from the hmm. Effectively these are imgt columns but CDR3 has not been redone. 
+    @param sequence: The original sequence string or list.
+    @param scheme: The numbering scheme to apply
+    @param chain_type: The type of chain to apply numbering for. Some schemes do not require this (IMGT). Others (e.g. Chothia/Wolfguy) do.
+    
+    @return: A list of numbering identifier / amino acids tuples over the domain that has been numbered. The indices of the start (inclusive) and end point (exclusive) in the sequence for the numbering 
+    """
+    scheme=scheme.lower()
+    if scheme == "imgt":
+        return number_imgt(state_vector, sequence)
+    elif scheme == "chothia":
+        if chain_type == "H":
+            return number_chothia_heavy(state_vector, sequence)
+        elif chain_type in "KL":
+            return number_chothia_light(state_vector, sequence)
+        else:
+            raise AssertionError("Unimplemented numbering scheme %s for chain %s"%( scheme, chain_type))
+    elif scheme == "kabat":
+        if chain_type == "H":
+            return number_kabat_heavy(state_vector, sequence)
+        elif chain_type in "KL":
+            return number_kabat_light(state_vector, sequence)
+        else:
+            raise AssertionError("Unimplemented numbering scheme %s for chain %s"%( scheme, chain_type))
+    elif scheme == "martin":
+        if chain_type == "H":
+            return number_martin_heavy(state_vector, sequence)
+        elif chain_type in "KL":
+            return number_martin_light(state_vector, sequence)
+        else:
+            raise AssertionError("Unimplemented numbering scheme %s for chain %s"%( scheme, chain_type))
+    elif scheme == "aho":
+        return number_aho(state_vector, sequence, chain_type) # requires the chain type to heuristically put the CDR1 gap in position.
+    elif scheme == "wolfguy":
+        if chain_type == "H":
+            return number_wolfguy_heavy( state_vector, sequence )     
+        elif chain_type in "KL":
+            return number_wolfguy_light( state_vector, sequence )  
+        else:
+            raise AssertionError("Unimplemented numbering scheme %s for chain %s"%( scheme, chain_type))      
+    else:
+        raise AssertionError("Unimplemented numbering scheme %s for chain %s"%( scheme, chain_type))
+
+def number_sequences_from_alignment(sequences, alignments, scheme="imgt", allow=set(["H","K","L","A","B","G","D"]), 
+                                    assign_germline=False, allowed_species=None):
+    '''
+    Given a list of sequences and a corresponding list of alignments from run_hmmer apply a numbering scheme.
+    '''
+
+    # Iteration over the sequence alignments performing the desired numbering 
+    numbered = []
+    alignment_details = []
+    hit_tables = []
+    for i in range(len(sequences)):
+
+        # Unpack
+        hit_table, state_vectors, detailss = alignments[i] # We may have multiple domains per sequence (e.g. single chain fvs). 
+
+        # Iterate over all the domains in the sequence that have been recognised (typcially only 1 with the current hmms available)
+        hit_numbered, hit_details = [], []
+        for di in range( len( state_vectors ) ):
+            state_vector = state_vectors[di]
+            details      = detailss[di]
+            details["scheme"]=scheme
+            details["query_name"]=sequences[i][0]            
+
+            # Only number things that are allowed. We still keep the alignment details and hit_table
+            if state_vector and details["chain_type"] in allow: 
+                try:
+                    # Do the numbering and validate (for development purposes)
+                    hit_numbered.append( validate_numbering(number_sequence_from_alignment(state_vector, sequences[i][1], 
+                                                            scheme=scheme, chain_type=details["chain_type"]), sequences[i] ) )
+                    if assign_germline:
+                        details["germlines"] = run_germline_assignment( state_vector, sequences[i][1], 
+                                                                        details["chain_type"], allowed_species=allowed_species)
+                    hit_details.append( details )
+                except AssertionError as e: # Handle errors. Those I have implemented should be assertion.
+                    print(str(e), file=sys.stderr)
+                    raise e # Validation went wrong. Error message will go to stderr. Want this to be fatal during development.
+                except Exception as e:
+                    print("Error: Something really went wrong that has not been handled", file=sys.stderr)
+                    print(str(e), file=sys.stderr)
+                    raise e
+                
+        if hit_numbered: 
+            numbered.append( hit_numbered )
+            alignment_details.append( hit_details )
+        else: 
+            numbered.append( None )
+            alignment_details.append( None )
+        hit_tables.append(hit_table)
+
+    return numbered, alignment_details, hit_tables
+
+def get_identity( state_sequence, germline_sequence ):
+    """
+    Get the partially matched sequence identity between two aligned sequences. 
+    Partial in the sense that gaps can be in the state_sequence.
+    """
+    # Ensure that the sequences are the expected length
+    assert len( state_sequence) == len(germline_sequence ) == 128
+    n, m = 0, 0
+    for i in range( 128 ):
+        if germline_sequence[i] == "-":continue
+        if state_sequence[i].upper() == germline_sequence[i]: m+=1
+        n+=1
+
+    if not n:
+        return 0    
+    return float(m)/n
+    
+
+def run_germline_assignment(state_vector, sequence, chain_type, allowed_species=None ):
+    """
+    Find the closest sequence identity match.
+    """
+    genes={'v_gene': [None,None],
+           'j_gene': [None,None],
+         }
+
+
+    # Extract the positions that correspond to match (germline) states. 
+    state_dict = dict( ((i, 'm'),None) for i in range(1,129))
+    state_dict.update(dict(state_vector))
+    state_sequence = "".join([ sequence[state_dict[(i, 'm')]] if state_dict[(i,'m')] is not None else "-" for i in range(1,129) ])
+
+    # Iterate over the v-germline sequences of the chain type of interest.
+    # The maximum sequence identity is used to assign the germline 
+    if chain_type in all_germlines["V"]:
+        if allowed_species is not None:
+            if not all( [ sp in all_germlines['V'][chain_type] for sp in allowed_species ] ): # Made non-fatal
+                return {}
+        else:
+            allowed_species = all_species
+        seq_ids = {}
+        for species in allowed_species:
+            if species not in all_germlines["V"][ chain_type ]: continue # Previously bug.
+            for gene, germline_sequence in all_germlines["V"][ chain_type ][ species ].items():
+                seq_ids[ (species, gene) ] = get_identity( state_sequence , germline_sequence )
+        genes['v_gene' ][0] = max( seq_ids, key=lambda x: seq_ids[x] )
+        genes['v_gene' ][1] = seq_ids[ genes['v_gene' ][0] ]
+        
+        # Use the assigned species for the v-gene for the j-gene. 
+        # This assumption may affect exotically engineered abs but in general is fair.
+        species = genes['v_gene' ][0][0]       
+        if chain_type in all_germlines["J"]:
+            if species in all_germlines["J"][chain_type]:
+                seq_ids = {}
+                for gene, germline_sequence in all_germlines["J"][ chain_type ][ species ].items():
+                    seq_ids[ (species, gene) ] = get_identity( state_sequence , germline_sequence )
+                genes['j_gene' ][0] = max( seq_ids, key=lambda x: seq_ids[x] )
+                genes['j_gene' ][1] = seq_ids[ genes['j_gene' ][0] ]
+     
+    return genes
+
+def check_for_j( sequences, alignments, scheme ):
+    '''
+    As the length of CDR3 gets long (over 30ish) an alignment that does not include the J region becomes more favourable.
+    This leads to really long CDR3s not being numberable. 
+
+    To overcome this problem, when no J region is detected we try without the v region.
+    '''
+    for i in range( len( sequences ) ):
+        # Check the alignment for J region
+        if len(alignments[i][1]) ==1: # Only do for single domain chains. 
+
+            # Check whether a J region has been identified. If not check whether there is still a considerable amount of sequence   
+            # remaining. 
+            ali = alignments[i][1][0]
+
+            # Find the last match position. 
+            last_state  = ali[-1][0][0]
+            last_si     = ali[-1][1]
+            if last_state < 120: # No or very little J region
+                if last_si + 30 < len( sequences[i][1] ): # Considerable amount of sequence left...suspicious of a long CDR3
+                    # Find the position of the conserved cysteine (imgt 104). 
+                    cys_si = dict( ali ).get( (104,'m'), None )
+                    if cys_si is not None: # 104 found.
+
+                        # Find the corresponding index in the alignment.
+                        cys_ai = ali.index( ((104, 'm'), cys_si) )
+                
+                        # Try to identify a J region in the remaining sequence after the 104. A low bit score threshold is used.
+                        _, re_states, re_details  = run_hmmer( [(sequences[i][0], sequences[i][1][cys_si+1:])], 
+                                                               bit_score_threshold=10 )[0] 
+
+                        # Check if a J region was detected in the remaining sequence.
+                        if re_states and re_states[0][-1][0][0] >= 126 and re_states[0][0][0][0] <= 117: 
+
+                            # Sandwich the presumed CDR3 region between the V and J regions.
+
+                            vRegion   = ali[:cys_ai+1]
+                            jRegion   = [ (state, index+cys_si+1) for state, index in re_states[0] if state[0] >= 117 ]
+                            cdrRegion = []
+                            next = 105
+                            for si in range( cys_si+1, jRegion[0][1] ):
+                                if next >= 116:
+                                    cdrRegion.append( ( (116, 'i'), si ) )
+                                else:
+                                    cdrRegion.append( ( (next, 'm'), si ) )
+                                    next +=1 
+
+                            # Update the alignment entry.
+                            alignments[i][1][0] = vRegion + cdrRegion + jRegion 
+                            alignments[i][2][0]['query_end'] = jRegion[-1][1] + 1 
+
+
+
+##################################
+# High level numbering functions #
+##################################
+
+# Main function for ANARCI 
+# Name conflict with function, module and package is kept for legacy unless issues are reported in future. 
+def anarci(sequences, scheme="imgt", database="ALL", output=False, outfile=None, csv=False, allow=set(["H","K","L","A","B","G","D"]), 
+           hmmerpath="", ncpu=None, assign_germline=False, allowed_species=None, bit_score_threshold=80):
+    """
+    The main function for anarci. Identify antibody and TCR domains, number them and annotate their germline and species. 
+
+    It is advised to use one of the wrapper functions:
+        o run_anarci   - fasta file or sequence list in. Automated multiprocessing for large jobs. Sequences, numbering, details 
+                         and hit tables out. 
+        o number       - single sequence in, numbering out
+
+    
+    @param sequences: A list or tuple of (Id, Sequence) pairs
+                              e.g. [ ("seq1","EVQLQQSGAEVVRSG ..."),
+                                     ("seq2","DIVMTQSQKFMSTSV ...") ]
+    @param scheme:    The numbering scheme that should be applied. Choose from imgt, chothia, kabat or martin
+    @param output:    Boolean flag to say whether the result should be output.
+    @param outfile:   The name of the file to output to. If output is True and outfile is None then output is printed
+                      to stdout.
+    @param csv:       Boolean flag to say whether the csv output alignment format or the vertical anarci format should be used.
+    @param allow:     A set containing the chain types that should be recognised. If chothia, kabat or martin is used
+                      as the scheme, anarci will ignore tcr chains. Choose a subset of ["H","K","L","A","B","G","D"]
+    @param assign_germline: Using highest sequence identity assign the germline to the chain. Can be more accurate at identifying
+                      species than the best HMM hit alone. (Bool)
+    @param allowed_species: If assign_germline is true, limit the species that can be assigned to a limited set. Useful when the 
+                      animal species is known or when performing closest germline experiments. Choose a subset of ['human',
+                      'mouse','rat','rabbit','rhesus','pig','alpaca'].
+
+
+    @param bit_score_threshold: The threshold score from HMMER at which an alignment should be numbered. Lowering the threshold 
+                      means domain recognition is more permissive and can be useful for numbering heavily engineered molecules. 
+                      However, too low and false positive recognition of other ig-like molecules will occur.
+    @param hmmerpath: The path to hmmscan. If left unspecified then the PATH will be searched. 
+    @param ncpu:      The number of cpu's that hmmer should be allowed to use. If not specified then the hmmscan 
+                      default is used. N.B. hmmscan must be compiled with multithreading enabled for this option to have effect. 
+                      Please consider using the run_anarci function for native multiprocessing with anarci.
+    @param database:  The HMMER database that should be used. Normally not changed unless a custom db is created.
+
+
+    @return: Three lists. Numbered, Alignment_details and Hit_tables.
+             Each list is in the same order as the input sequences list.
+             A description of each entry in the three lists is as followed.
+               o Numbered: will be None if no domain was found for that sequence or a list of domains with their 
+                           numbering, start and finish indices.
+               o Alignment_details: will be None if no domain was found for that sequence or a dictionary for each
+                           domain identified containing the details of the alignment (chain type, e-value, species etc).
+               o Hit_tables: None if no domain was found for that sequence or a nested list for each domain containing
+                           the hit table from hmmscan.
+    
+    """
+    
+    # Validate the input scheme
+    try:
+        scheme = scheme_short_to_long[scheme.lower()]
+    except KeyError:
+        raise AssertionError("Unrecognised or unimplemented scheme: %s"%scheme)        
+
+    # Check we have arguments for output before doing work.
+    if csv:
+        assert outfile, 'If csv output is True then an outfile must be specified'
+        _path, _ = os.path.split(outfile)
+        assert (not _path) or os.path.exists(_path), 'Output directory %s does not exist'%_path
+
+
+    # Perform the alignments of the sequences to the hmm database
+    alignments = run_hmmer(sequences,hmm_database=database,hmmerpath=hmmerpath,ncpu=ncpu,bit_score_threshold=bit_score_threshold,hmmer_species=allowed_species )   
+     
+    # Check the numbering for likely very long CDR3s that will have been missed by the first pass.
+    # Modify alignments in-place
+    check_for_j( sequences, alignments, scheme )
+
+    # Apply the desired numbering scheme to all sequences
+    numbered, alignment_details, hit_tables = number_sequences_from_alignment(sequences, alignments, scheme=scheme, allow=allow, 
+                                                                              assign_germline=assign_germline, 
+                                                                              allowed_species=allowed_species)
+
+    # Output if necessary
+    if output: 
+        if csv:
+            csv_output(sequences, numbered, details, outfile)             
+        else:
+            outto, close=sys.stdout, False
+            if outfile:
+                outto, close = open(outfile,'w'), True
+            anarci_output(numbered, sequences, alignment_details, outto)
+            if close:
+                outto.close()
+
+
+    return numbered, alignment_details, hit_tables
+
+# Wrapper to run anarci using multiple processes and automate fasta file reading.
+def run_anarci( seq, ncpu=1, **kwargs):
+    '''
+    Run the anarci numbering protocol for single or multiple sequences.
+    
+    @param sequences: A list or tuple of (Id, Sequence) pairs
+                              e.g. [ ("seq1","EVQLQQSGAEVVRSG ..."),
+                                     ("seq2","DIVMTQSQKFMSTSV ...") ]
+    @param scheme:    The numbering scheme that should be applied. Choose from imgt, chothia, kabat or martin
+    @param output:    Boolean flag to say whether the result should be output.
+    @param outfile:   The name of the file to output to. If output is True and outfile is None then output is printed
+                      to stdout.
+    @param allow:     A set containing the chain types that should be recognised. If chothia, kabat or martin is used
+                      as the scheme, anarci will ignore tcr chains. Choose a subset of ["H","K","L","A","B","G","D"]
+    @param assign_germline: Using highest sequence identity assign the germline to the chain. Can be more accurate at identifying
+                      species than the best HMM hit alone. (Bool)
+    @param allowed_species: If assign_germline is true, limit the species that can be assigned to a limited set. Useful when the 
+                      animal species is known or when performing closest germline experiments. Choose a subset of ['human',
+                      'mouse','rat','rabbit','rhesus','pig','alpaca'].
+
+    @param bit_score_threshold: The threshold score from HMMER at which an alignment should be numbered. Lowering the threshold 
+                      means domain recognition is more permissive and can be useful for numbering heavily engineered molecules. 
+                      However, too low and false positive recognition of other ig-like molecules will occur.
+    @param hmmerpath: The path to hmmscan. If left unspecified then the PATH will be searched. 
+    @param ncpu:      The number of cpu's that hmmer should be allowed to use. If not specified then the hmmscan 
+                      default is used. N.B. hmmscan must be compiled with multithreading enabled for this option to have effect. 
+                      Please consider using the run_anarci function for native multiprocessing with anarci.
+    @param database:  The HMMER database that should be used. Normally not changed unless a custom db is created.
+
+    @return: Four lists. Sequences, Numbered, Alignment_details and Hit_tables.
+             Each list is in the same order. 
+             A description of each entry in the four lists is as followed.
+               o Sequences: The list of sequences formatted as [(Id,sequence), ...]. 
+               o Numbered: will be None if no domain was found for that sequence or a list of domains with their 
+                           numbering, start and finish indices.
+               o Alignment_details: will be None if no domain was found for that sequence or a dictionary for each
+                           domain identified containing the details of the alignment (chain type, e-value, species etc).
+               o Hit_tables: None if no domain was found for that sequence or a nested list for each domain containing
+                           the hit table from hmmscan.
+
+    '''
+    # Parse the input sequence or fasta file.
+    if isinstance(seq, list) or isinstance(seq,tuple): # A list (or tuple) of (name,sequence) sequences
+        assert all( len(_) == 2 for _ in seq ), "If list or tuple supplied as input format must be [ ('ID1','seq1'), ('ID2', 'seq2'), ... ]"
+        sequences = seq
+    elif os.path.isfile( seq ): # Fasta file.
+        # Read the sequences. All are read into memory currently...
+        sequences = read_fasta( seq ) 
+        ncpu = int(max(1, ncpu )) 
+    elif isinstance(seq, str): # Single sequence
+        validate_sequence( seq )
+        ncpu=1
+        sequences = [ ["Input sequence", seq ]]
+
+    # Handle the arguments to anarci.
+    output  = kwargs.get('output', False )
+    outfile = kwargs.get('outfile', False )
+    csv = kwargs.get( 'csv', False )
+    if csv: # Check output arguments before doing work.
+        assert outfile, 'If csv output is True then an outfile must be specified'
+        _path, _ = os.path.split(outfile)
+        assert (not _path) or os.path.exists(_path), 'Output directory %s does not exist'%_path
+        
+    kwargs['ncpu'] = 1 # Set hmmscan ncpu to 1. HMMER has to be compiled appropriately for this to have an effect. 
+    kwargs['output'] = False # Overide and write the compiled results here. 
+
+    anarci_partial = partial( anarci, **kwargs )        
+    chunksize = math.ceil( float( len(sequences) )/ncpu )
+
+    # Run the anarci function using a pool of workers. Using the map_async to get over the KeyboardInterrupt bug in python2.7
+    if ncpu > 1:
+        pool = Pool( ncpu )
+        results = pool.map_async( anarci_partial, grouper( chunksize, sequences ) ).get()
+        pool.close()
+    else:
+        results = list(map( anarci_partial, grouper( chunksize, sequences ) ))
+
+    # Reformat the results to flat lists.
+    numbered = sum( (_[0] for _ in results), [] )
+    alignment_details = sum( (_[1] for _ in results ), [] )
+    hit_tables = sum( (_[2] for _ in results), [] )
+
+    # Output if necessary
+    if output: 
+        if csv:
+            csv_output(sequences, numbered, alignment_details, outfile)             
+        else:
+            outto, close=sys.stdout, False
+            if outfile:
+                outto, close = open(outfile,'w'), True
+            anarci_output(numbered, sequences, alignment_details, outto)
+            if close:
+                outto.close()
+
+    # Return the results
+    return sequences, numbered, alignment_details, hit_tables
+                
+
+
+# Wrapper function for simple sequence in numbering and chain type out behaviour. 
+def number(sequence, scheme="imgt", database="ALL", allow=set(["H","K","L","A","B","G","D"])):
+    """
+    Given a sequence string, use anarci to number it using the scheme of choice.
+    Only the first domain will be recognised and numbered
+
+    For multiple sequences it is advised to use run_anarci instead of iterative use of this function.
+
+    @param sequence: An amino acid sequence string
+    @param scheme: The numbering scheme that should be applied. Choose from imgt, chothia, kabat or martin
+    @param database: The HMMER database that should be used. Normally not changed unless a custom db is created.
+    @param allow: A set containing the chain types that should be recognised. If chothia, kabat or martin is used
+                  as the scheme, anarci will ignore tcr chains.
+
+    @return: If the sequence can be numbered, a list containing the numbering and sequence; and the chain type. 
+             Otherwise both are False.
+
+    """
+    
+    try:
+        validate_sequence( sequence )  
+        scheme = scheme_short_to_long[scheme.lower()]
+    except KeyError:
+        raise AssertionError("Unrecognised to unimplemented scheme: %s"%scheme)
+    
+    if len(sequence) < 70: # Length check. ANARCI can number fragments of chains well. Encourage full domain numbering. 
+        return False, False
+   
+    try:
+        numbered, alignment_details, _ = anarci( [("sequence_0", sequence)], scheme=scheme, database=database, output=False, allow=allow )
+    except AssertionError: # Catch where the user has tried to number a TCR with an antibody scheme
+        return False, False
+    
+
+    # We return the numbering list and the chain type where kappa and lambda chains are both "L" for light
+    if numbered[0]:
+        return numbered[0][0][0], chain_type_to_class[alignment_details[0][0]["chain_type"]]
+    else:
+        return False, False
+
+if __name__ == "__main__":
+    # Test and example useage of the anarci function. 
+    sequences = [ ("12e8:H","EVQLQQSGAEVVRSGASVKLSCTASGFNIKDYYIHWVKQRPEKGLEWIGWIDPEIGDTEYVPKFQGKATMTADTSSNTAYLQLSSLTSEDTAVYYCNAGHDYDRGRFPYWGQGTLVTVSAAKTTPPSVYPLAP"),
+                  ("12e8:L","DIVMTQSQKFMSTSVGDRVSITCKASQNVGTAVAWYQQKPGQSPKLMIYSASNRYTGVPDRFTGSGSGTDFTLTISNMQSEDLADYFCQQYSSYPLTFGAGTKLELKRADAAPTVSIFPPSSEQLTSGGASV"),
+                  ("scfv:A","DIQMTQSPSSLSASVGDRVTITCRTSGNIHNYLTWYQQKPGKAPQLLIYNAKTLADGVPSRFSGSGSGTQFTLTISSLQPEDFANYYCQHFWSLPFTFGQGTKVEIKRTGGGGSGGGGSGGGGSGGGGSEVQLVESGGGLVQPGGSLRLSCAASGFDFSRYDMSWVRQAPGKRLEWVAYISSGGGSTYFPDTVKGRFTISRDNAKNTLYLQMNSLRAEDTAVYYCARQNKKLTWFDYWGQGTLVTVSSHHHHHH"),
+                  ("lysozyme:A","KVFGRCELAAAMKRHGLDNYRGYSLGNWVCAAKFESNFNTQATNRNTDGSTDYGILQINSRWWCNDGRTPGSRNLCNIPCSALLSSDITASVNCAKKIVSDGNGMNAWVAWRNRCKGTDVQAWIRGCRL")]
+
+    results = anarci(sequences, scheme="imgt", output=True)
+    numbering, alignment_details, hit_tables = results
+
+    expect_one_VH_domain_numbering, expect_one_VL_domain_numbering, expect_VH_then_VL_numbering, expect_None = numbering
+    assert  len(expect_one_VH_domain_numbering) == 1
+    assert  len(expect_one_VL_domain_numbering) == 1
+    assert  len(expect_VH_then_VL_numbering)    == 2
+    assert  expect_None                         == None
+
+
+
+

anarci/schemes.py

@@ -0,0 +1,1691 @@
+#    ANARCI - Antibody Numbering and Antigen Receptor ClassIfication
+#    Copyright (C) 2016 Oxford Protein Informatics Group (OPIG)
+#
+#    This program is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.#
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+'''
+Module containing functions to convert hmm alignment to a numbering scheme. 
+
+Currently implemented
+
+For IG's
+IMGT
+Chothia
+Kabat
+Martin (Extended Chothia)
+Aho 
+Wolfguy
+
+For TR's
+IMGT
+(Aho)
+
+---------------------------------------------------------------------------------------------------------------------
+Functions are written to a template:
+
+There are 128 match states in the HMMs (these are the IMGT states). The alignment to these states must be converted to
+correspond to the scheme of choice. 
+
+We define:
+  - a state string consisting of 'X' and 'I' where:
+    X  means that for the state there is an equivalent position in the numbering scheme.
+    I  means that for the state there is not an equivalent position in the numbering scheme. It should therefore be 
+       considered as an insertion in the scheme.
+       
+  - a region string consisting of characters (integers in the currently implemented schemes). Each character 
+corresponds to a contiguous region. Therefore each state can be assigned a region according to the scheme. 
+
+  - a mapping between region characters and region indices as a dictionary. e.g. the first region character maps
+to 0, second to 1 ...
+
+  - a dictionary containing the difference between state number (imgt) and scheme number at the *beginning* of 
+each region using the region indices as keys and the difference as values.
+
+  - the number of regions defined
+
+  - a list for which delete states should not be included in the numbering (typically those for the cdrs). This
+will allow the length of the region to be the number of residues found instead of the number of possible states plus
+insertions.
+
+ 
+This all goes into the _number_regions function along with the sequence and the state_vector (the alignment from the
+HMM).
+
+_number regions will then divide the aligned part of the sequence into as many regions as defined above. Within each 
+region it will give a numbering according to the input parameters. A list of lists will be returned containing the 
+numbered sequence for each region.
+
+Some of the regions will not be numbered correctly according to the scheme. For example the insertions for the CDRs
+will not necessarily be on the correct residue. For each different scheme these regions are then modified (see code
+for implementation) 
+
+Finally the full numbered sequence is compiled and returned to the calling function.
+---------------------------------------------------------------------------------------------------------------------
+
+Other schemes can be implemented following the template above. 
+
+
+'''
+
+# Alphabet used for insertion (last (-1th) is a blank space for no insertion)
+alphabet = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "AA", "BB", "CC", "DD", "EE", "FF", "GG", "HH", "II", "JJ", "KK", "LL", "MM", "NN", "OO", "PP", "QQ", "RR", "SS", "TT", "UU", "VV", "WW", "XX", "YY", "ZZ", " "]
+
+# Blosum62 matrix. Used in some annotation methods to recognise pre-defined motifs
+blosum62 = {('B', 'N'): 3, ('W', 'L'): -2, ('G', 'G'): 6, ('X', 'S'): 0, ('X', 'D'): -1, ('K', 'G'): -2, ('S', 'E'): 0, ('X', 'M'): -1, ('Y', 'E'): -2, ('W', 'R'): -3, ('I', 'R'): -3, ('X', 'Z'): -1, ('H', 'E'): 0, ('V', 'M'): 1, ('N', 'R'): 0, ('I', 'D'): -3, ('F', 'D'): -3, ('W', 'C'): -2, ('N', 'A'): -2, ('W', 'Q'): -2, ('L', 'Q'): -2, ('S', 'N'): 1, ('Z', 'K'): 1, ('V', 'N'): -3, ('Q', 'N'): 0, ('M', 'K'): -1, ('V', 'H'): -3, ('G', 'E'): -2, ('S', 'L'): -2, ('P', 'R'): -2, ('D', 'A'): -2, ('S', 'C'): -1, ('E', 'D'): 2, ('Y', 'G'): -3, ('W', 'P'): -4, ('X', 'X'): -1, ('Z', 'L'): -3, ('Q', 'A'): -1, ('V', 'Y'): -1, ('W', 'A'): -3, ('G', 'D'): -1, ('X', 'P'): -2, ('K', 'D'): -1, ('T', 'N'): 0, ('Y', 'F'): 3, ('W', 'W'): 11, ('Z', 'M'): -1, ('L', 'D'): -4, ('M', 'R'): -1, ('Y', 'K'): -2, ('F', 'E'): -3, ('M', 'E'): -2, ('S', 'S'): 4, ('X', 'C'): -2, ('Y', 'L'): -1, ('H', 'R'): 0, ('P', 'P'): 7, ('K', 'C'): -3, ('S', 'A'): 1, ('P', 'I'): -3, ('Q', 'Q'): 5, ('L', 'I'): 2, ('P', 'F'): -4, ('B', 'A'): -2, ('Z', 'N'): 0, ('M', 'Q'): 0, ('V', 'I'): 3, ('Q', 'C'): -3, ('I', 'H'): -3, ('Z', 'D'): 1, ('Z', 'P'): -1, ('Y', 'W'): 2, ('T', 'G'): -2, ('B', 'P'): -2, ('P', 'A'): -1, ('C', 'D'): -3, ('Y', 'H'): 2, ('X', 'V'): -1, ('B', 'B'): 4, ('Z', 'F'): -3, ('M', 'L'): 2, ('F', 'G'): -3, ('S', 'M'): -1, ('M', 'G'): -3, ('Z', 'Q'): 3, ('S', 'Q'): 0, ('X', 'A'): 0, ('V', 'T'): 0, ('W', 'F'): 1, ('S', 'H'): -1, ('X', 'N'): -1, ('B', 'Q'): 0, ('K', 'A'): -1, ('I', 'Q'): -3, ('X', 'W'): -2, ('N', 'N'): 6, ('W', 'T'): -2, ('P', 'D'): -1, ('B', 'C'): -3, ('I', 'C'): -1, ('V', 'K'): -2, ('X', 'Y'): -1, ('K', 'R'): 2, ('Z', 'R'): 0, ('W', 'E'): -3, ('T', 'E'): -1, ('B', 'R'): -1, ('L', 'R'): -2, ('Q', 'R'): 1, ('X', 'F'): -1, ('T', 'S'): 1, ('B', 'D'): 4, ('Z', 'A'): -1, ('M', 'N'): -2, ('V', 'D'): -3, ('F', 'A'): -2, ('X', 'E'): -1, ('F', 'H'): -1, ('M', 'A'): -1, ('K', 'Q'): 1, ('Z', 'S'): 0, ('X', 'G'): -1, ('V', 'V'): 4, ('W', 'D'): -4, ('X', 'H'): -1, ('S', 'F'): -2, ('X', 'L'): -1, ('B', 'S'): 0, ('S', 'G'): 0, ('P', 'M'): -2, ('Y', 'M'): -1, ('H', 'D'): -1, ('B', 'E'): 1, ('Z', 'B'): 1, ('I', 'E'): -3, ('V', 'E'): -2, ('X', 'T'): 0, ('X', 'R'): -1, ('R', 'R'): 5, ('Z', 'T'): -1, ('Y', 'D'): -3, ('V', 'W'): -3, ('F', 'L'): 0, ('T', 'C'): -1, ('X', 'Q'): -1, ('B', 'T'): -1, ('K', 'N'): 0, ('T', 'H'): -2, ('Y', 'I'): -1, ('F', 'Q'): -3, ('T', 'I'): -1, ('T', 'Q'): -1, ('P', 'L'): -3, ('R', 'A'): -1, ('B', 'F'): -3, ('Z', 'C'): -3, ('M', 'H'): -2, ('V', 'F'): -1, ('F', 'C'): -2, ('L', 'L'): 4, ('M', 'C'): -1, ('C', 'R'): -3, ('D', 'D'): 6, ('E', 'R'): 0, ('V', 'P'): -2, ('S', 'D'): 0, ('E', 'E'): 5, ('W', 'G'): -2, ('P', 'C'): -3, ('F', 'R'): -3, ('B', 'G'): -1, ('C', 'C'): 9, ('I', 'G'): -4, ('V', 'G'): -3, ('W', 'K'): -3, ('G', 'N'): 0, ('I', 'N'): -3, ('Z', 'V'): -2, ('A', 'A'): 4, ('V', 'Q'): -2, ('F', 'K'): -3, ('T', 'A'): 0, ('B', 'V'): -3, ('K', 'L'): -2, ('L', 'N'): -3, ('Y', 'N'): -2, ('F', 'F'): 6, ('L', 'G'): -4, ('B', 'H'): 0, ('Z', 'E'): 4, ('Q', 'D'): 0, ('X', 'B'): -1, ('Z', 'W'): -3, ('S', 'K'): 0, ('X', 'K'): -1, ('V', 'R'): -3, ('K', 'E'): 1, ('I', 'A'): -1, ('P', 'H'): -2, ('B', 'W'): -4, ('K', 'K'): 5, ('H', 'C'): -3, ('E', 'N'): 0, ('Y', 'Q'): -1, ('H', 'H'): 8, ('B', 'I'): -3, ('C', 'A'): 0, ('I', 'I'): 4, ('V', 'A'): 0, ('W', 'I'): -3, ('T', 'F'): -2, ('V', 'S'): -2, ('T', 'T'): 5, ('F', 'M'): 0, ('L', 'E'): -3, ('M', 'M'): 5, ('Z', 'G'): -2, ('D', 'R'): -2, ('M', 'D'): -3, ('W', 'H'): -2, ('G', 'C'): -3, ('S', 'R'): -1, ('S', 'I'): -2, ('P', 'Q'): -1, ('Y', 'A'): -2, ('X', 'I'): -1, ('E', 'A'): -1, ('B', 'Y'): -3, ('K', 'I'): -3, ('H', 'A'): -2, ('P', 'G'): -2, ('F', 'N'): -3, ('H', 'N'): 1, ('B', 'K'): 0, ('V', 'C'): -1, ('T', 'L'): -1, ('P', 'K'): -1, ('W', 'S'): -3, ('T', 'D'): -1, ('T', 'M'): -1, ('P', 'N'): -2, ('K', 'H'): -1, ('T', 'R'): -1, ('Y', 'R'): -2, ('L', 'C'): -1, ('B', 'L'): -4, ('Z', 'Y'): -2, ('W', 'N'): -4, ('G', 'A'): 0, ('S', 'P'): -1, ('E', 'Q'): 2, ('C', 'N'): -3, ('H', 'Q'): 0, ('D', 'N'): 1, ('Y', 'C'): -2, ('L', 'H'): -3, ('E', 'C'): -4, ('Z', 'H'): 0, ('H', 'G'): -2, ('P', 'E'): -1, ('Y', 'S'): -2, ('G', 'R'): -2, ('B', 'M'): -3, ('Z', 'Z'): 4, ('W', 'M'): -1, ('Y', 'T'): -2, ('Y', 'P'): -3, ('Y', 'Y'): 7, ('T', 'K'): -1, ('Z', 'I'): -3, ('T', 'P'): -1, ('V', 'L'): 1, ('F', 'I'): 0, ('G', 'Q'): -2, ('L', 'A'): -1, ('M', 'I'): 1}
+
+
+def smooth_insertions(state_vector):
+    '''
+    The function aims to correct to the expected imgt alignment. Renumbering functions then translate from the imgt scheme to the
+    appropriate scheme.        
+
+    Handle insertions made by HMMER that we suspect may be in the wrong position.
+    Edge cases include:
+        - Insertions at the C terminal of fw1, fw3 and fw3 regions. Can occur when 'conserved' residues have been mutated and the 
+          same amino acid appears in the the following CDR (e.g. mutate cysteine at 104 but the CDR3 has one or more cysteines)
+        - Same as above possible (but not observed in structure seqs) for N terminal of fw2, fw3 and fw4... TODO
+        - Heavily mutated N terminal regions that are partially recognised (e.g. 3gk8 chain H). Insertions should not be allowed 
+          before N terminal deletions have been used. Preserve deletion locations that are not N terminal (e.g. 10 in IMGT H) if 
+          the gap has been placed by the alignment.
+
+    '''
+    # Small overhead doing these corrections but worth it for reducing edge cases.
+    
+    # Enforce insertion patterns as below. The CDRs are renumbered in each case so that insertions are placed accoring to the scheme    
+#  '11111111111111111111111111222222222222333333333333333334444444444555555555555555555555555555555555555555666666666666677777777777'
+#  '                        mmmi                         mmmi                                             mmmi                      '
+#  '                        mmmi        immm             mmmi      immm                                   mmmi         immm         '
+
+    # Enforce any insertions at the end and beginning of framework regions to be moved into the CDR region for renumbering. 
+    enforced_patterns = [ [(25,'m'),(26,'m'),( 27,'m'),( 28,'i')],
+                          [(38,'i'),(38,'m'),(39,'m'),(40,'m')],
+                          [(54,'m'),(55,'m'),(56,'m'),(57,'i')],
+                          [(65,'i'),(65,'m'),(66,'m'),(67,'m')],
+                          [(103,'m'),(104,'m'),(105,'m'),(106,'i')],
+                          [(117,'i'),(117,'m'),(118,'m'),(119,'m')] ]
+
+    # Insertions in FW1 are only allowed if there are a fewer number of n-terminal deletions made. 
+
+    state_buffer = [] 
+    sv = []
+    for (state_id, state_type ), si in state_vector:
+        if state_id < 23: # Everything before the cysteine at 23.
+            state_buffer.append( ((state_id, state_type ), si) )
+            reg = -1   
+        elif 25 <= state_id < 28: # Add to the buffer 
+            state_buffer.append( ((state_id, state_type ), si) )
+            reg = 0
+        elif 37 < state_id <= 40: # Add to the buffer 
+            state_buffer.append( ((state_id, state_type ), si) )
+            reg = 1
+        elif 54 <= state_id < 57: # Add to the buffer
+            state_buffer.append( ((state_id, state_type ), si) )
+            reg = 2
+        elif 64 < state_id <= 67: # Add to the buffer
+            state_buffer.append( ((state_id, state_type ), si) )
+            reg = 3
+        elif 103 <= state_id < 106: # Add to the buffer
+            state_buffer.append( ((state_id, state_type ), si) )
+            reg = 4
+        elif 116 < state_id <= 119: # Add to the buffer
+            state_buffer.append( ((state_id, state_type ), si) )
+            reg = 5
+        elif len(state_buffer) != 0: # Add the buffer and reset
+
+            # Find the number of insertions in the buffer
+            nins = sum( 1 for s in state_buffer if s[0][1] == 'i' ) 
+
+            # If there are insertions, adjust the alignment
+            if nins > 0: # We have insertions
+
+                if reg == -1: # FW1, only adjust if there are the same or more N terminal deletions than insertions
+                    nt_dels = state_buffer[0][0][0] - 1 # Missing states
+                    for (_id, _type ), _si in state_buffer: # Explicit deletion states.
+                        if _type == 'd' or _si == None:
+                            nt_dels +=1 
+                        else: # First residue found
+                            break
+                    if nt_dels >= nins: # More n terminal deletions than insertions found. Likely misalignment.
+                        
+                        # Preserve the deleted states structure by using the same match annotations
+                        new_states = [ s for s, _ in state_buffer if s[1] == 'm'] 
+                        _first = new_states[0][0]
+
+                        # Remove the deletions so that only residue positions are included
+                        state_buffer = [ s for s in state_buffer if s[0][1] != 'd' ]
+
+                        # Extend N terminal states backwards from the first match states
+                        _add = len( state_buffer ) - len( new_states ) 
+                        assert _add >= 0, 'Implementation logic error' # Should be adding a positive number of positions
+                        new_states = [ (_,'m') for _ in range( _first - _add, _first ) ] + new_states
+                        assert len(new_states)==len(state_buffer), 'Implementation logic error' # Should have the same length
+
+                        # Assign them preserving the order of the sequence. 
+                        for i in range( len(state_buffer ) ):
+                            sv.append( ( new_states[i], state_buffer[i][1]) )
+                    else:
+                        sv += state_buffer # The insertions may be incorrect but unknown what to do. Let the alignment place.
+                else:
+                    # Remove any deletions in the buffer. Unlikely to happen but do anyway
+                    state_buffer = [ s for s in state_buffer if s[0][1] != 'd' ]
+        
+                    # Define the new states defined by the enforced pattern and the length of the buffer
+                    if reg % 2: # nterm fw
+                        new_states = [enforced_patterns[reg][0]]*max( 0, len(state_buffer)-3) + enforced_patterns[reg][ max( 4-len(state_buffer), 1):]
+                    else: # cterm fw
+                        new_states = enforced_patterns[reg][:3] + [enforced_patterns[reg][2]]*max( 0, len(state_buffer)-3)
+                    # Assign them preserving the order of the sequence. 
+                    for i in range( len(state_buffer ) ):
+                        sv.append( ( new_states[i], state_buffer[i][1]) )
+                                
+            else: # Nothing to do - either all match or deletion states.
+                sv += state_buffer
+
+            # Add the current state
+            sv.append( ((state_id, state_type ), si) )
+
+            # Reset state buffer
+            state_buffer = [] 
+            
+        else: # Simply append 
+            sv.append( ((state_id, state_type ), si) )
+    
+
+    return sv
+
+
+# General function to give annotations for regions that have direct mappings onto the hmm alignment (imgt states)
+def _number_regions(sequence, state_vector, state_string , region_string,  region_index_dict, rels, n_regions, exclude_deletions):
+    """
+    General function to number a sequence and divide it into different regions  
+    
+    @param sequence: The sequence string
+    @param state_vector: The list of states from the aligned hmm
+    @param state_string: A string of states for the scheme relative to IMGT (this is X for a direct equivalence, I if needs to be treated as insertion)
+    @param region_string: A string of characters that indicate which hmm states are in each regions for this scheme (i.e. how should the sequence be divided up)
+    @param region_index_dict: A dictionary converting the characters in region string to an index of the regions. 
+    @param rels: The difference of the numbering integer at the *start* of each region
+    @param n_regions: The number of regions
+    @param exclude_deletions: A list of region indices for which deletion states should not be included. Typically the CDRs. 
+                              These will be reannotated in the scheme function. Also allows the reset of insertions. 
+    
+    @return: A list of lists where each region has been numbered according to the scheme. Some regions will need renumbering. This should be taken care of after the function called.
+    
+    """
+
+    state_vector = smooth_insertions( state_vector )
+    
+    _regions = [ [] for _ in range(n_regions) ]
+    
+    # Initialise the insertion index (-1 is a blank space) and the previous state.
+    insertion = -1
+    previous_state_id = 1
+    previous_state_type = 'd'
+    start_index, end_index  = None, None
+    
+    region = None
+
+    # Iterate over the aligned state vector
+    for (state_id, state_type ), si in state_vector:
+       
+        # Retrieve the region index
+        if state_type != "i" or region is None: # BUG_FIX - JD 9/4/15 - do not allow a new region to start as an insertion.
+            region = region_index_dict[region_string[state_id-1]] 
+
+       
+        # Check the state_types
+        if state_type == "m": # It is a match
+            
+            # Check whether this position is in the scheme as an independent state
+            if state_string[state_id-1]=="I": # No, it should be treated as an insertion
+                if previous_state_type != 'd': # Unless there was a deletion beforehand in which case this should be a real pos.
+                    insertion +=1 # Increment the insertion annotation index
+                rels[region] -= 1 # Update the relative numbering from the imgt states
+            else: # Yes 
+                insertion = -1 # Reset the insertions 
+            
+            # Add the numbering annotation to the appropriate region list            
+            _regions[region].append( ( (state_id + rels[region], alphabet[insertion] ), sequence[si]  ) )
+            previous_state_id = state_id # Record the previous state ID
+            if start_index is None:
+                start_index = si
+            end_index = si
+
+            previous_state_type = state_type
+            
+        elif state_type == "i": # It is an insertion
+            insertion +=1 # Increment the insertion annotation index
+            
+            # Add the numbering annotation to the appropriate region list
+            _regions[region].append( ( (previous_state_id + rels[region], alphabet[insertion]), sequence[si]  ) )
+            if start_index is None:
+                start_index = si
+            end_index = si
+
+            previous_state_type = state_type
+
+        else: # It is a deletion
+            previous_state_type = state_type
+            
+            # Check whether this position is in the scheme as an independent state
+            if state_string[state_id-1]=="I": # No, therefore irrelevant to the scheme.
+                rels[region] -= 1 # Update the relative numbering from the imgt states
+                continue 
+            
+            insertion = -1 # Reset the insertions
+            previous_state_id = state_id # Record the previous state ID, should not be needed (no delete to insert state transition)
+
+
+        # Reset the inssertion index if necessary and allowed. (Means the insertion code is meaningless and will be reannotated)
+        if insertion >= 25 and region in exclude_deletions:
+            insertion = 0 
+        
+        assert insertion < 25, "Too many insertions for numbering scheme to handle" # We ran out of letters.
+            
+    return _regions, start_index, end_index
+
+
+# Functions to perform the numbering and the corrections for each of the implemented schemes.
+# These have been written fairly verbosely so that the template of how to generate a function for a new scheme is more clear.
+# They have two stages: Perform the mapping between imgt and the scheme; Renumber those regions that do not map nicely onto imgt (e.g. CDR insertions)
+    
+
+    
+########
+# IMGT # 
+########
+# - Renumbering of the CDR 1 and 2 regions in IMGT has now been implemented to ensure consistency with the gapping rules of the 
+# scheme. Previously gaps were defined using the HMM alignment as the underlying model was already based on the IMGT scheme. This 
+# worked well in original test cases but appears to give inaccurate annotations in a significant number of cases in NGS size 
+# sequence sets. We therefore now explicitly renumber the CDR 1 and 2 as with all the other schemes. 
+
+def number_imgt(state_vector, sequence):
+    """    
+    Apply the IMGT numbering scheme for heavy or light chains
+    
+    Rules should be implemented using two strings - the state string and the region string. 
+
+    There are 128 states in the HMMs. Treat X as a direct match in IMGT scheme, I is an insertion. (All X's for IMGT)
+    XXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXX XXXXXXXXXXXXXXXXX XXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXX XXXXXXXXXXX
+    11111111111111111111111111 222222222222 33333333333333333 4444444444 555555555555555555555555555555555555555 6666666666666 77777777777
+
+    Regions - (N.B These do not match up with any particular definition of CDR)
+    1. All positions before CDR1
+    2. CDR1 positions
+    3. Positions between CDR1/2
+    4. CDR2 positions
+    5. Positions between CDR2/3
+    6. CDR positions 105 (inc) to 118 (exc)
+    7. Positions after CDR3    
+    
+    """
+    
+    # Set up the numbering 
+ 
+    # State string - 'X' means the imgt position exists in the scheme. 'I' means that it should be treated as an insertion of the previous number
+    state_string =  'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
+                    
+    # Region string - regions that should be treated separately in putting the numbering together 
+    region_string = '11111111111111111111111111222222222222333333333333333334444444444555555555555555555555555555555555555555666666666666677777777777'
+
+    region_index_dict = {
+                         "1":0,
+                         "2":1,
+                         "3":2,
+                         "4":3,
+                         "5":4,
+                         "6":5,
+                         "7":6
+                         }
+    
+    # Define how the scheme's numbering differs from IMGT at the start of each region. 
+    # This is updated in the loop below
+    rels              =  {0:0, 
+                          1:0,
+                          2:0,
+                          3:0,
+                          4:0,
+                          5:0,
+                          6:0,
+                          7:0
+                          }
+    
+    n_regions = 7
+
+    exclude_deletions = [1,3,5]    
+    
+    _regions, startindex, endindex = _number_regions(sequence, state_vector, state_string , region_string,  region_index_dict, rels, n_regions, exclude_deletions)
+    
+    ###############
+    # Renumbering #
+    ###############
+
+    _numbering = [ _regions[0], # Fw1
+                   [],          # CDR1
+                   _regions[2], # Fw2
+                   [],          # CDR2
+                   _regions[4], # Fw3
+                   [],          # CDR3
+                   _regions[6], # Fw4
+
+                 ]
+
+    # The alignment from HMMER should be correct for CDRs 1 and 2. Testing has shown not always the case and 'manual' renumbering 
+    # is required as with the other schemes.
+    
+    # CDR1
+    # CDR1 has a range from 27 (inc.) to 39 (exc.) and has a theoretical maximum length of 12.
+    cdr1seq    = "".join([ x[1] for x in _regions[1] if x[1] != "-" ])
+    cdr1length = len(cdr1seq) 
+    si = 0
+    prev_state = 26
+    for ann in get_imgt_cdr(cdr1length, 12, 27, 39):
+        if not ann:
+            _numbering[1].append( ((prev_state+1, ' '), '-') )
+            prev_state += 1
+        else:
+            _numbering[1].append( (ann, cdr1seq[si]) )
+            prev_state = ann[0]
+            si += 1
+
+    # CDR2 
+    # CDR2 has a range from 56 (inc.) to 66 (exc.) and has a theoretical length of 10.
+    cdr2seq    = "".join([ x[1] for x in _regions[3] if x[1] != "-" ])
+    cdr2length = len(cdr2seq)
+    si = 0
+    prev_state = 55
+    for ann in get_imgt_cdr(cdr2length, 10, 56, 66):
+        if not ann:
+            _numbering[3].append( ((prev_state+1, ' '), '-') )
+            prev_state += 1
+        else:
+            _numbering[3].append( (ann, cdr2seq[si]) )
+            prev_state = ann[0]
+            si += 1
+
+    # FW3. We allow the HMM to place insertions. Technically all insertion points are taken care of but in reality insertions can
+    # and do occur. No specification of where the insertions should be placed.
+
+
+    # CDR3 
+    # CDR3 has a range from 105 (inc.) to 118 (exc.). Insertions are placed on 112 and 111 symetrically. IMGT has a technical 
+    # maximum length of 65 (13 positions, 26*2 insertions) . In practice ANARCI will not recognise CDR3s of this length.
+    cdr3seq    = "".join([ x[1] for x in _regions[5] if x[1] != "-" ])
+    cdr3length = len(cdr3seq)
+    if cdr3length > 117: return [], startindex, endindex # Too many insertions. Do not apply numbering. 
+    si = 0
+    previous_state_id = 104
+    for ann in get_imgt_cdr(cdr3length, 13, 105, 118):
+        if ann is None:
+            _numbering[5].append( ((previous_state_id+1, " "), "-"   ) )
+            previous_state_id+=1
+        else:
+            _numbering[5].append( (ann, cdr3seq[si] ) )
+            previous_state_id = ann[0]
+            si+=1
+  
+    # Return the full vector and the start and end indices of the numbered region of the sequence
+    return gap_missing( _numbering ), startindex, endindex
+  
+def get_imgt_cdr(length, maxlength, start, end):
+    """
+    Symmetrically number a CDR loop (e.g. CDRL1/CDRH2 for IMGT)
+    @param length:      Define the length of target CDR
+    @param maxlength:   Define the theoretical limit (e.g. L1 = 12 for the IMGT scheme)
+    @param start, end:  Start and end position numbers
+    """
+    annotations = [ None for _ in range(max(length, maxlength)) ]
+    if length == 0:
+        return annotations
+    elif length == 1:
+        annotations[0] = (start, ' ')
+        return annotations
+
+    front, back = 0, -1
+    #az = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" 
+    #za = "ZYXWVUTSRQPONMLKJIHGFEDCBA"
+
+    az = alphabet[:-1]
+    za = az[::-1]
+
+    for i in range(min(length, maxlength)):
+        if i % 2:
+            annotations[back] = (end + back, " ")
+            back -= 1
+        else:
+            annotations[front] = (start + front, " ")
+            front += 1
+
+    # Add insertions around the centre point
+    centrepoint = [ i for i,v in enumerate(annotations) if v == None ]
+    if not centrepoint:
+        return annotations
+
+    centre_left  = annotations[min(centrepoint)-1][0] # Get the index right before the first None
+    centre_right = annotations[max(centrepoint)+1][0] # Get the index right after  the first None
+
+    # For cases with an even max length
+    if not maxlength % 2:
+        frontfactor, backfactor = maxlength//2, maxlength//2
+    # For cases with an odd max length
+    else:
+        frontfactor, backfactor = (maxlength//2)+1, maxlength//2
+
+    for i in range(max(0, length-maxlength)):
+        if not i % 2:
+            annotations[back] = (centre_right, za[back + backfactor])
+            back -= 1
+        else:
+            annotations[front] = (centre_left, az[front - frontfactor])
+            front += 1
+    
+    return annotations
+
+
+#######
+# Aho # 
+#######
+# Heuristic regapping based on the AHo specification as detailed on AAAAA website. Gap order depends on the chain type
+def number_aho(state_vector, sequence, chain_type):
+    """    
+    Apply the Aho numbering scheme
+    
+    Rules should be implemented using two strings - the state string and the region string. 
+
+    There are 128 states in the HMMs. Treat X as a direct match in IMGT scheme, I is an insertion. (All X's for IMGT)
+
+    XXXXXXX XXX XXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXX XXXXXXXXXXXXX XXXXXXXXXXX
+    AAAAAAA BBB CCCCCCCCCCCCCC DDDDDDDDDDDDDDDD EEEEEEEEEEEEEEE FFFFFFFFFFFFFFFFFFFF HHHHHHHHHHHHHHHH IIIIIIIIIIIII JJJJJJJJJJJJJ KKKKKKKKKKK
+
+
+    Regions - (N.B These do not match up with any particular definition of CDR)
+    A. EMPTY (now included in B)
+    B. 1-10 inclusive. Indel occurs at 8
+    C. 11-24 inclusive.
+    D. 25-42 inclusive (deletion surround 28) 32-42 inclusive (deletions surround 36)
+    E. 43-57 inclusive 
+    F. 58-77 inclusive (deletions surround 63). Alpha chains have deletions at 74,75
+    G. EMPTY (now included in H)
+    H. 78-93 inclusive  gaps on 86 then 85, insertions on 85 linearly
+    I. 94-106 inclusive
+    J. 107-138 inclusive gaps on 123 symetrically.
+    K. 139-149 inclusive.
+    
+    """
+    
+    # Set up the numbering 
+ 
+    # State string - 'X' means the imgt position exists in the scheme. 'I' means that it should be treated as an insertion of the previous number
+    state_string =  'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
+                    
+    # Region string - regions that should be treated separately in putting the numbering together 
+    region_string =  'BBBBBBBBBBCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFFFHHHHHHHHHHHHHHHHIIIIIIIIIIIIIJJJJJJJJJJJJJKKKKKKKKKKK'
+#                     1         2             3               4              5                   7               8            9            10
+
+
+    region_index_dict = dict( list(zip( "ABCDEFGHIJK", list(range(11)) )) )
+    
+    # Define how the scheme's numbering differs from IMGT at the start of each region. 
+    # This is updated in the loop below
+    rels              =  {0:0, 
+                         1:0,
+                         2:0,
+                         3:0,
+                         4:2,
+                         5:2,
+                         6:2,
+                         7:2,
+                         8:2,
+                         9:2,
+                         10:21}
+
+    n_regions = 11
+    
+    exclude_deletions = [1,3,4,5,7,9]    
+    
+    _regions, startindex, endindex = _number_regions(sequence, state_vector, state_string , region_string,  region_index_dict, rels, n_regions, exclude_deletions)
+    
+    ###############
+    # Renumbering #
+    ###############
+
+    _numbering = [ _regions[0], _regions[1], _regions[2],[], _regions[4], [], _regions[6], [], _regions[8],_regions[9],_regions[10] ]
+
+    ##################################
+    # Move the indel in fw 1 onto 8  #
+    ##################################
+
+    # Place indels on 8 
+    # Find the first recognised residue and change the expected length of the stretch given the starting point. 
+    # This prevents n terminal deletions being placed at 8 incorrectly.
+    length = len( _regions[1] )
+    if length > 0:
+        start = _regions[1][0][0][0] 
+        stretch_len = 10 - (start -1)
+        if length > stretch_len: # Insertions are present. Place on 8
+            annotations = [ (_," ") for _ in range(start,9) ] + [ (8,alphabet[_]) for _ in range( length - stretch_len ) ] + [(9," "),(10," ")]
+        else:
+            ordered_deletions = [(8," ")] + [(_," ") for _ in range(start, 11) if _ != 8]
+            annotations = sorted( ordered_deletions[max(stretch_len-length, 0):] )
+        _numbering[1] = [ (annotations[i], _regions[1][i][1]) for i in range(length) ]
+
+    #########
+    # CDR 1 # - divided in two parts in the Aho scheme.
+    ######### - gaps at 28 depending on the chain type.
+
+    # "VH domains, as well as the majority of the VA domains, have a one-residue gap in position 28, VK and VB domains a two-residue
+    # gap in position 27 and 28."
+
+    # We use the link below as the reference for the scheme.
+    # https://www.bioc.uzh.ch/plueckthun/antibody/Numbering/Alignment.html
+
+    # Some of the header lines in these images are offset by one (VH)! The gaps really are centered at 28 and 36
+    # https://www.bioc.uzh.ch/plueckthun/antibody/Sequences/Rearranged/PDB_VK.html
+    # https://www.bioc.uzh.ch/plueckthun/antibody/Sequences/Rearranged/PDB_VL.html
+    # https://www.bioc.uzh.ch/plueckthun/antibody/Sequences/Rearranged/PDB_VH.html
+    # https://www.bioc.uzh.ch/plueckthun/antibody/Sequences/Rearranged/PDB_VA.html
+    # https://www.bioc.uzh.ch/plueckthun/antibody/Sequences/Rearranged/PDB_VB.html
+    # https://www.bioc.uzh.ch/plueckthun/antibody/Sequences/Rearranged/PDB_VG.html
+    # https://www.bioc.uzh.ch/plueckthun/antibody/Sequences/Rearranged/PDB_VD.html
+
+    # We gap the CDR1 in a heuristic way using the gaps. 
+    # This means that CDR1 gapping will not always be correct. For example if one grafts a Kappa CDR1 loop onto a Lambda framework
+    # the gapping patter might now be incorrect. 
+    # Not a fan of being so prescriptive.
+
+    # The CDR1 region included here ranges from AHo 25 to AHo 42 inclusive
+    
+    # The order in which the two loops are gapped is dependent on the chain type (see alignments in URLs above).
+    # Not all lengths are defined as not all lengths were crystallised in 2001 (or today). Where no example of the length was 
+    # available the rule followed is to continue gapping the C terminal 'loop', then the N terminal 'loop', then 31 then the fw. 
+    # In all cases I have commented where the gapping is undefined. Note that for alpha chains the gapping rules are inconsistent.
+
+    _L = 28,36,35,37,34,38,27,29,33,39,32,40,26,30,25,31,41,42
+    #                           |-> undefined by AHo. Gapping C terminal loop then N terminal then 31, then fw.                              
+    _K = 28,27,36,35,37,34,38,33,39,32,40,29,26,30,25,31,41,42
+    #                                 |-> undefined by AHo. Gapping C terminal loop then N terminal then fw.                              
+    _H = 28,36,35,37,34,38,27,33,39,32,40,29,26,30,25,31,41,42 
+    #                        |-> undefined by AHo. Gapping C terminal loop then N terminal then fw.                              
+    #                            N.B. The header on the alignment image for PDB_VH is offset by 1!
+    _A = 28,36,35,37,34,38,33,39,27,32,40,29,26,30,25,31,41,42    
+    #                              |-> undefined by AHo. Gapping C terminal loop then N terminal then fw.     
+    #                            N.B The gapping is inconsistent for alpha chains. I follow the paper's statement that most VA have
+    #                                one gap at 28 and remove 28 and 27 before removing 40. 
+    _B = 28,36,35,37,34,38,33,39,27,32,40,29,26,30,25,31,41,42
+    #                              |-> undefined by AHo. Gapping C terminal loop then N terminal then 31, then fw.
+    _D = 28,36,35,37,34,38,27,33,39,32,40,29,26,30,25,31,41,42
+    #                         |-> undefined by AHo. Gapping C terminal loop then N terminal then 31, then fw.
+    #                         N.B only two sequence patterns available.                                
+    _G = 28,36,35,37,34,38,27,33,39,32,40,29,26,30,25,31,41,42
+    #                         |-> undefined by AHo. Gapping C terminal loop then N terminal then 31, then fw.
+    #                         N.B only one sequence patterns available. Delta copied.
+    
+    ordered_deletions = { 'L':_L,'K':_K, 'H':_H, 'A':_A, 'B':_B, 'D':_D, 'G':_G } 
+
+    length = len( _regions[3] )
+
+    annotations = [ (i, ' ') for i in sorted( ordered_deletions[chain_type][ max(18-length, 0): ] ) ]
+
+    # Insertions are not described in the AHo scheme but must be included as there is a significant number of CDRH1s that are 
+    # longer than the number of positions.
+    insertions = max( length-18 , 0 ) 
+    if insertions > 26: 
+        return [], startindex, endindex # Too many insertions. Do not apply numbering. 
+    elif insertions > 0:
+        # They are placed on residue 36 alphabetically.
+        insertat = annotations.index( (36, ' ') )+1 # Always 12 
+        assert insertat == 12, 'AHo numbering failed'  
+        annotations = annotations[:insertat] + [ (36, alphabet[a]) for a in range( insertions ) ] + annotations[insertat:]
+
+    _numbering[3] = [ (annotations[i], _regions[3][i][1]) for i in range(length) ]
+
+    #########
+    # CDR 2 #
+    #########
+    # Gaps are placed symetically at 63.
+    # For VA a second gap is placed at 74 and 75 according to the text in the paper. However, all the reference sequences show a
+    # gap at 73 and 74 see:
+    #      https://www.bioc.uzh.ch/plueckthun/antibody/Sequences/Rearranged/PDB_VA.html 
+    # and 
+    #      https://www.bioc.uzh.ch/plueckthun/antibody/Numbering/Alignment.html
+    # Either I am mis-interpreting the text in the paper or there is something a little inconsistent here...
+    # Given that *all* the numbered examples show the VA gap at 73 and 74 on the AAAAA website I have decided to implement this. 
+    #
+    
+    # This region describes 58 to 77 inclusive
+    
+    if chain_type == 'A':
+        ordered_deletions = [74,73,63,62,64,61,65,60,66,59,67,58,68,69,70,71,72,75,76,77]
+    else:
+        ordered_deletions = [63,62,64,61,65,60,66,59,67,58,68,69,70,71,72,73,74,75,76,77]
+
+    length = len(_regions[5])
+
+    annotations = [ (i, ' ') for i in sorted( ordered_deletions[ max(20-length, 0): ] ) ]
+
+    # Insertions are not described in the AHo scheme but must be included.
+    insertions = max( length-20 , 0 ) 
+    if insertions > 26: 
+        return [], startindex, endindex # Too many insertions. Do not apply numbering. 
+    elif insertions > 0:
+        # They are placed on residue 63 alphabetically.
+        insertat = annotations.index( (63, ' ') )+1 # Always 6
+        assert insertat == 6, 'AHo numbering failed'  
+        annotations = annotations[:insertat] + [ (63, alphabet[a]) for a in range( insertions ) ] + annotations[insertat:]
+
+    _numbering[5] = [ (annotations[i], _regions[5][i][1]) for i in range(length) ]
+
+    #########
+    # FW3   ############################################
+    # Move deletions onto 86 then 85. Insertions on 85 #
+    ####################################################
+    ordered_deletions = [86,85,87,84,88,83,89,82,90,81,91,80,92,79,93,78]
+    length=len( _regions[7] )
+
+    annotations = [ (i, ' ') for i in sorted( ordered_deletions[ max(16-length, 0): ] ) ]
+
+    # Insertions are not described in the AHo scheme but must be included.
+    insertions = max( length-16 , 0 ) 
+    if insertions > 26: 
+        return [], startindex, endindex # Too many insertions. Do not apply numbering. 
+    elif insertions > 0:
+        # They are placed on residue 85 alphabetically.
+        insertat = annotations.index( (85, ' ') )+1 # Always 8
+        assert insertat == 8, 'AHo numbering failed'  
+        annotations = annotations[:insertat] + [ (85, alphabet[a]) for a in range( insertions ) ] + annotations[insertat:]
+
+    _numbering[7] = [ (annotations[i], _regions[7][i][1]) for i in range(length) ]
+
+
+    #########
+    # CDR 3 #
+    #########
+    # Deletions on 123. 
+    # Point of the Aho scheme is that they have accounted for all possible positions.
+    # Assumption is that no more insertions will occur.... 
+    # We'll put insertions on 123 linearly.(i.e.ABCDEF...) if they ever do.
+
+    ordered_deletions = [123,124,122,125,121,126,120,127,119,128,118,129,117,130,116,131,115,132,114,133,113,134,112,135,111,
+                         136,110,137,109,138,108,107]
+    
+    length=len( _regions[9] )
+
+    annotations = [ (i, ' ') for i in sorted( ordered_deletions[ max(32-length, 0): ] ) ]
+
+    # Insertions are not described in the AHo scheme but must be included.
+    insertions = max( length-32 , 0 ) 
+    if insertions > 26: 
+        return [], startindex, endindex # Too many insertions. Do not apply numbering. 
+    elif insertions > 0:
+        # They are placed on residue 123 alphabetically.
+        insertat = annotations.index( (123, ' ') )+1 # Always 17
+        assert insertat == 17, 'AHo numbering failed'  
+        annotations = annotations[:insertat] + [ (123, alphabet[a]) for a in range( insertions ) ] + annotations[insertat:]
+
+    _numbering[9] = [ (annotations[i], _regions[9][i][1]) for i in range(length) ]
+
+    # AHo includes one extra position than IMGT in what it considers the variable domain for light chains. 
+    #If the last state is 148 and there is at least one more residue left, then add the residue to the numbering. 
+    numbering = gap_missing( _numbering )
+    if len(numbering) > 0:
+        if numbering[-1][0] == (148, ' ') and numbering[-1][1] != '-' and endindex+1 < len(sequence):
+            numbering.append( ( (149, ' '), sequence[endindex+1]) )
+            endindex +=1
+
+    return numbering, startindex, endindex
+
+
+###########
+# Chothia #
+###########
+
+# Heavy chains
+def number_chothia_heavy(state_vector, sequence):
+    """
+    Apply the Chothia numbering scheme for heavy chains
+    
+    Rules should be implemented using two strings - the state string and the region string. 
+
+    There are 128 states in the HMMs. Treat X as a direct match in Chothia scheme, I is an insertion.
+
+    XXXXXXXXXI XXXXXXXXXXXXX XXXXXXXIIIIXX XXXXXXXXXXXXXXXXXX XXXIXIIXXXX XXXXXXXIXXXXXXXXXXXXXXXXXXIIIXXXXXXXXXX XXXXXXXXIIIXX XXXXXXXXXXX'
+    1111111111 2222222222222 3333333333333 444444444444444444 55555555555 666666666666666666666666666666666666666 7777777777777 88888888888'     
+    
+    Regions - (N.B These do not match up with any particular definition of CDR)
+     1  -  Put the insertions at Chothia position 6
+     2  -  Simple mapping (treat "I" states as inserts and not own match states)
+     3  -  CDRH1 - 30 (inc) to 34 (exc) put insertions on 31
+     4  -  Simple mapping (treat "I" states as inserts and not own match states)
+     5  -  CDRH2 - 52 (inc) 58 (exc) put insertions on 52 
+     6  -  Simple mapping (treat "I" states as inserts and not own match states)
+     7  -  CDRH3 93 (inc) to 103 (exc) put insertion on 100
+     8  -  Simple mapping (treat "I" states as inserts and not own match states)
+
+
+    Regions 1,3,5 and 7 are renumbered
+    
+    """
+
+    # State string - 'X' means the imgt position exists in the scheme. 'I' means that it should be treated as an insertion of the previous number
+    state_string =  'XXXXXXXXXIXXXXXXXXXXXXXXXXXXXXIIIIXXXXXXXXXXXXXXXXXXXXXXXIXIIXXXXXXXXXXXIXXXXXXXXXXXXXXXXXXIIIXXXXXXXXXXXXXXXXXXIIIXXXXXXXXXXXXX'
+                    
+    # Region string - regions that should be treated separately in putting the numbering together 
+    region_string = '11111111112222222222222333333333333333444444444444444455555555555666666666666666666666666666666666666666777777777777788888888888'
+
+    region_index_dict = {"1":0,"2":1,"3":2,"4":3,"5":4,"6":5,"7":6,"8":7}
+    
+    # Define how the scheme's numbering differs from IMGT at the start of each region. 
+    # This is updated in the loop below
+    rels              =  {0:0, 
+                         1:-1,
+                         2:-1,
+                         3:-5,
+                         4:-5,
+                         5:-8,
+                         6:-12,
+                         7:-15}    
+    
+    n_regions = 8
+    
+    exclude_deletions = [0,2,4,6] # Don't put deletions in these regions
+
+    _regions, startindex, endindex = _number_regions(sequence, state_vector, state_string , region_string,  region_index_dict, rels, n_regions, exclude_deletions)
+    
+    
+    ###############
+    # Renumbering #
+    ###############
+
+    _numbering = [ [], _regions[1] , [], _regions[3] , [], _regions[5], [], _regions[7] ]
+    
+    # Chothia H region 1 (index 0)
+    # Insertions are placed at Chothia position 6.
+    # Count how many we recognised as insertion by the hmm
+    insertions = len( [ 1 for _ in _regions[0] if _[0][1] != " " ] ) 
+    # We will place all insertion in this region at Chothia position 6.
+    if insertions:
+        start = _regions[0][0][0][0] # The starting Chothia number as found by the HMM (could easily start from 2 for example)
+        # I have a feeling this may be a source of a bug in very unusual cases. Can't break for now. Will catch mistakes in a validate function. 
+        length = len( _regions[0] )
+        annotations = [ (_, " ") for _ in range(start, 7) ] + [ (6, alphabet[_]) for _ in range(insertions) ] + [(7," "),(8," "),(9," ")]
+        _numbering[0] =  [ (annotations[i], _regions[0][i][1]) for i in range(length) ]
+    else:
+        _numbering[0] = _regions[0]
+
+    
+    # CDR1 
+    # Chothia H region 3 (index 2)
+    # put insertions onto 31
+    length = len( _regions[2] )
+    insertions = max(length - 11, 0) # Pulled back to the cysteine as heavily engineered cdr1's are not playing nicely
+
+    if insertions:
+        annotations = [(_, " ") for _ in range(23,32)] + [(31, alphabet[i]) for i in range(insertions) ] + [(32," "),(33," ")]
+    else:
+        annotations = [(_, " ") for _ in range(23,32)][:length-2] + [(32," "),(33," ")][:length]
+
+    _numbering[2] = [ (annotations[i], _regions[2][i][1]) for i in range(length) ]
+ 
+    # CDR2
+    # Chothia H region 5 (index 4) 
+    # put insertions onto 52
+    length = len( _regions[4] )
+    # 50 to 57 inclusive
+    insertions = max(length - 8, 0) # Eight positions can be accounted for, the remainder are insertions
+    # Delete in the order, 52, 51, 50,53, 54 ,55, 56, 57
+    annotations  =  [(50, " "),(51, " "), (52, " ")][:max(0,length-5)]
+    annotations += [(52, alphabet[i]) for i in range(insertions) ]
+    annotations += [(53, " "),(54, " "),(55, " "),(56, " "),(57, " ")][ abs( min(0,length-5) ):]
+    _numbering[4] = [ (annotations[i], _regions[4][i][1]) for i in range(length) ]
+
+    # FW3 - insertions are annotated on 82. The first three are normal positions and annotated automatically. 
+    # Additional insertions do not occur with the kabat or the chothia numbering scheme.
+    # It does not make sense to place more than A, B, C on 82 as Martin and AHo work show that this is not a place that accepts 
+    # additional insertions. 
+    # The decision here is to allow the alignment to place additional insertions. This is in contrast to Martin where the region
+    # is renumbered to place insertions on 72. 
+     
+    # CDR3
+    # Chothia H region 7 (index 6) 
+    # put insertions onto 100
+    length = len( _regions[6] )    
+    if length > 36: return [], startindex, endindex # Too many insertions. Do not apply numbering. 
+    annotations = get_cdr3_annotations(length, scheme="chothia", chain_type="heavy")
+    _numbering[6]  = [ (annotations[i], _regions[6][i][1]) for i in range(length)  ]
+
+    # Return the full vector and the start and end indices of the numbered region of the sequence
+    return gap_missing( _numbering ), startindex, endindex                                     
+
+# Light chains
+def number_chothia_light(state_vector, sequence):
+    """
+    Apply the Chothia numbering scheme for light chains
+    
+    Rules should be implemented using two strings - the state string and the region string. 
+
+    There are 128 states in the HMMs. Treat X as a direct match in Chothia scheme, I is an insertion.
+    XXXXXXXXXXXXXXXXXXXXXXXXXXXXX IIIIIIX XXXXXXXXXXXXXXXXXXXX XIIIIIIIXXX XXXXXIXXXXXXXIIXXXXXXXXXXXXXXXXXXXXXX XXXXXIIIIXX XXXXXXXXXXXXX
+    11111111111111111111111111111 2222222 33333333333333333333 44444444444 5555555555555555555555555555555555555 66666666666 7777777777777
+     
+    
+    Regions - (N.B These do not match up with any particular definition of CDR)
+     1  -  Simple mapping (treat "I" states as inserts and not own match states)
+     2  -  CDRL1 - 24 (inc) to 35 (exc) put insertions on 30
+     3  -  Simple mapping (treat "I" states as inserts and not own match states)
+     4  -  CDRL2 - 51 (inc) 55 (exc) put insertions on 52
+     5  -  Simple mapping (treat "I" states as inserts and not own match states)
+     6  -  CDRL3 89 (inc) to 98 (exc) put insertion on 95
+     7  -  Simple mapping (treat "I" states as inserts and not own match states)
+    
+    Region 2, 3 and 5 are renumbered
+    
+    """
+    
+    # Set up the numbering 
+ 
+    # State string - 'X' means the imgt position exists in the scheme. 'I' means that it should be treated as an insertion of the previous number
+    state_string =  'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXIIIIIIXXXXXXXXXXXXXXXXXXXXXXIIIIIIIXXXXXXXXIXXXXXXXIIXXXXXXXXXXXXXXXXXXXXXXXXXXXIIIIXXXXXXXXXXXXXXX'
+                    
+    # Region string - regions that should be treated separately in putting the numbering together 
+    region_string = '11111111111111111111111222222222222222223333333333333333444444444445555555555555555555555555555555555555666666666666677777777777'
+
+    region_index_dict = {"1":0,"2":1,"3":2,"4":3,"5":4,"6":5,"7":6}
+    
+    # Define how the scheme's numbering differs from IMGT at the start of each region. 
+    # This is updated in the loop below
+    rels              =  {0:0, 
+                         1: 0,
+                         2:-6,
+                         3:-6,
+                         4:-13,
+                         5:-16,
+                         6:-20,
+                         }    
+
+    
+    n_regions = 7
+    
+    exclude_deletions = [1,3,4,5]
+
+    _regions, startindex, endindex = _number_regions(sequence, state_vector, state_string , region_string,  region_index_dict, rels, n_regions, exclude_deletions)
+    
+    _numbering = [ _regions[0], [], _regions[2], [], _regions[4], [], _regions[6] ]
+    
+    
+    ###############
+    # Renumbering #
+    ###############
+
+    # CDR1 
+    # Chothia L region 2 (index 1)
+    # put insertions onto 30
+    length = len( _regions[1] )
+    insertions = max(length - 11, 0) # Eleven positions can be accounted for, the remainder are insertions
+    # Delete forward from 31 
+    annotations  =  [(24, " "),(25, " "), (26, " "), (27, " "), (28, " "),(29, " "),(30, " ")][:max(0,length)] 
+    annotations += [(30, alphabet[i]) for i in range(insertions) ]
+    annotations += [(31, " "),(32, " "),(33, " "),(34, " ")][ abs( min(0,length-11) ):] 
+    _numbering[1] = [ (annotations[i], _regions[1][i][1]) for i in range(length) ]
+
+
+    # CDR2
+    # Chothia L region 4 (index 3) 
+    # put insertions onto 52. 
+    length = len( _regions[3] )
+    insertions = max( length - 4, 0 )
+    if insertions > 0:
+        annotations  = [(51, " "),(52, " ")] + [(52, alphabet[i]) for i in range(insertions) ] + [(53, " "),(54, " ")]
+        _numbering[3] = [ (annotations[i], _regions[3][i][1]) for i in range(length) ]
+    else: # How to gap L2 in Chothia/Kabat/Martin is unclear so we let the alignment do it.
+        _numbering[3] = _regions[3]
+    
+    # FW3
+    # Insertions on 68. First deletion 68. Otherwise default to alignment
+    length = len( _regions[4] )
+    insertions = max(length - 34, 0)
+    if insertions > 0: # Insertions on 68
+        annotations = [(i," ") for i in range(55,69)]+[(68, alphabet[i]) for i in range(insertions) ]+[(i," ") for i in range(69,89)]
+        _numbering[4] = [ (annotations[i], _regions[4][i][1]) for i in range(length) ]
+    elif length == 33: # First deletion on 68
+        annotations = [(i," ") for i in range(55,68)]+[(i," ") for i in range(69,89)]            
+        _numbering[4] = [ (annotations[i], _regions[4][i][1]) for i in range(length) ]
+    else: # More deletions - allow alignment to place them 
+        _numbering[4] = _regions[4]
+
+
+    # CDR3
+    # Chothia L region 6 (index 5) 
+    # put insertions onto 95
+    length = len( _regions[5] )    
+
+    if length > 35: return [], startindex, endindex # Too many insertions. Do not apply numbering. 
+    annotations = get_cdr3_annotations(length, scheme="chothia", chain_type="light")
+    _numbering[5]  = [ (annotations[i], _regions[5][i][1]) for i in range(length)  ]
+
+    # Return the full vector and the start and end indices of the numbered region of the sequence
+
+    return gap_missing( _numbering ), startindex, endindex    
+
+
+#########
+# Kabat #
+#########
+
+# Heavy chains
+def number_kabat_heavy(state_vector, sequence):
+    """
+    Apply the Kabat numbering scheme for heavy chains
+    
+    Rules should be implemented using two strings - the state string and the region string. 
+
+    There are 128 states in the HMMs. Treat X as a direct match in Kabat scheme, I is an insertion.
+    XXXXXXXXXI XXXXXXXXXXXXXXXXXXXX IIIIXXXXXX XXXXXXXXXXXXXXXX XIXII XXXXXXXXXXXIXXXXXXXXXXXXXXXXXXIIIXXXXXXXXXXXX XXXXXXIII XXXXXXXXXXXXX
+    1111111111 22222222222222222222 3333333333 4444444444444444 55555 666666666666666666666666666666666666666666666 777777777 8888888888888
+     
+    
+    Regions - (N.B These do not match up with any particular definition of CDR)
+     1  -  Put the insertions at Chothia position 6
+     2  -  Simple mapping (treat "I" states as inserts and not own match states)
+     3  -  CDRH1 - 30 (inc) to 36 (exc) put insertions on 35
+     4  -  Simple mapping (treat "I" states as inserts and not own match states)
+     5  -  CDRH2 - 52 (inc) 58 (exc) put insertions on 52 
+     6  -  Simple mapping (treat "I" states as inserts and not own match states)
+     7  -  CDRH3 93 (inc) to 103 (exc) put insertion on 100
+     8  -  Simple mapping (treat "I" states as inserts and not own match states)
+
+    """
+ 
+    # Set up the numbering 
+ 
+    # State string - 'X' means the imgt position exists in the scheme. 'I' means that it should be treated as an insertion of the previous number
+    state_string =  'XXXXXXXXXIXXXXXXXXXXXXXXXXXXXXIIIIXXXXXXXXXXXXXXXXXXXXXXXIXIIXXXXXXXXXXXIXXXXXXXXXXXXXXXXXXIIIXXXXXXXXXXXXXXXXXXIIIXXXXXXXXXXXXX'
+                    
+    # Region string - regions that should be treated separately in putting the numbering together 
+    region_string = '11111111112222222222222333333333333333334444444444444455555555555666666666666666666666666666666666666666777777777777788888888888'
+
+    region_index_dict = {"1":0,"2":1,"3":2,"4":3,"5":4,"6":5,"7":6,"8":7}
+    
+    # Define how the scheme's numbering differs from IMGT at the start of each region. 
+    # This is updated in the loop below
+    rels              =  {0:0, 
+                         1:-1,
+                         2:-1,
+                         3:-5,
+                         4:-5,
+                         5:-8,
+                         6:-12,
+                         7:-15}    
+    
+    n_regions = 8
+    
+    exclude_deletions = [2,4,6]
+
+    _regions, startindex, endindex = _number_regions(sequence, state_vector, state_string , region_string,  region_index_dict, rels, n_regions, exclude_deletions)
+    
+
+    ###############
+    # Renumbering #
+    ###############
+        
+    # Renumbering required for 0, 2, 4, 6 regions in Chothia heavy
+    
+    _numbering = [ [], _regions[1] , [], _regions[3] , [], _regions[5], [], _regions[7] ]
+
+
+    # Kabat H region 1 (index 0)
+    # Insertions are placed at Kabat position 6.
+    # Count how many we recognised as insertion by the hmm
+    insertions = len( [ 1 for _ in _regions[0] if _[0][1] != " " ] ) 
+    # We will place all insertion in this region at Kabat position 6.
+    if insertions:
+        start = _regions[0][0][0][0] # The starting Kabat number as found by the HMM (could easily start from 2 for example)
+        # I have a feeling this may be a source of a bug in very unusual cases. Can't break for now. Will catch mistakes in a validate function. 
+        length = len( _regions[0] )
+        annotations = [ (_, " ") for _ in range(start, 7) ] + [ (6, alphabet[_]) for _ in range(insertions) ] + [(7," "),(8," "),(9," ")]
+        _numbering[0] =  [ (annotations[i], _regions[0][i][1]) for i in range(length) ]
+    else:
+        _numbering[0] = _regions[0]
+    
+    
+    # CDR1 
+    # Kabat H region 3 (index 2)
+    # Put insertions onto 35. Delete from 35 backwards
+    length = len( _regions[2] )
+    insertions = max(0,length - 13)
+    annotations = [(_,' ') for _ in range(23, 36)][:length] 
+    annotations += [(35, alphabet[i]) for i in range(insertions) ]
+    _numbering[2] = [ (annotations[i], _regions[2][i][1]) for i in range(length) ]
+ 
+    # CDR2
+    # Chothia H region 5 (index 4) 
+    # put insertions onto 52
+    length = len( _regions[4] )
+    # 50 to 57 inclusive
+    insertions = max(length - 8, 0) # Eight positions can be accounted for, the remainder are insertions
+    # Delete in the order, 52, 51, 50,53, 54 ,55, 56, 57
+    annotations  =  [(50, " "),(51, " "), (52, " ")][:max(0,length-5)]
+    annotations += [(52, alphabet[i]) for i in range(insertions) ]
+    annotations += [(53, " "),(54, " "),(55, " "),(56, " "),(57, " ")][ abs( min(0,length-5) ):]
+    _numbering[4] = [ (annotations[i], _regions[4][i][1]) for i in range(length) ]
+
+    # FW3 - insertions are annotated on 82. The first three are normal positions and annotated automatically. 
+    # Additional insertions do not occur with the kabat or the chothia numbering scheme.
+    # It does not make sense to place more than A, B, C on 82 as Martin and AHo work show that this is not a place that accepts 
+    # additional insertions. 
+    # The decision here is to allow the alignment to place additional insertions. This is in contrast to Martin where the region
+    # is renumbered to place insertions on 72. 
+     
+    # CDR3
+    # Chothia H region 7 (index 6) 
+    # put insertions onto 100
+    length = len( _regions[6] )    
+    if length > 36: return [], startindex, endindex # Too many insertions. Do not apply numbering. 
+    annotations = get_cdr3_annotations(length, scheme="kabat", chain_type="heavy") #  Chothia and Kabat the same here
+    _numbering[6]  = [ (annotations[i], _regions[6][i][1]) for i in range(length)  ]
+
+    # Return the full vector and the start and end indices of the numbered region of the sequence
+    return gap_missing( _numbering ), startindex, endindex            
+           
+# Light chains    
+def number_kabat_light(state_vector, sequence):
+    """
+    Apply the Kabat numbering scheme for light chains
+    
+    Rules should be implemented using two strings - the state string and the region string. 
+
+    There are 128 states in the HMMs. Treat X as a direct match in Kabat scheme, I is an insertion.
+    XXXXXXXXXXXXXXXXXXXXXXXXXXXXX IIIIIIX XXXXXXXXXXXXXXXXXXXX XIIIIIIIXXX XXXXXIXXXXXXXIIXXXXXXXXXXXXXXXXXXXXXX XXXXXIIIIXX XXXXXXXXXXXXX
+    11111111111111111111111111111 2222222 33333333333333333333 44444444444 5555555555555555555555555555555555555 66666666666 7777777777777
+     
+    
+    Regions - (N.B These do not match up with any particular definition of CDR)
+     1  -  Simple mapping (treat "I" states as inserts and not own match states)
+     2  -  CDRL1 - 24 (inc) to 35 (exc) put insertions on 27
+     3  -  Simple mapping (treat "I" states as inserts and not own match states)
+     4  -  CDRL2 - 51 (inc) 55 (exc) put insertions on 52
+     5  -  Simple mapping (treat "I" states as inserts and not own match states)
+     6  -  CDRL3 89 (inc) to 96 (exc) put insertion on 95
+     7  -  Simple mapping (treat "I" states as inserts and not own match states)
+    
+    """
+    
+    # Set up the numbering 
+ 
+ 
+    # State string - 'X' means the imgt position exists in the scheme. 'I' means that it should be treated as an insertion of the previous number
+    state_string =  'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXIIIIIIXXXXXXXXXXXXXXXXXXXXXXIIIIIIIXXXXXXXXIXXXXXXXIIXXXXXXXXXXXXXXXXXXXXXXXXXXXIIIIXXXXXXXXXXXXXXX'
+                    
+    # Region string - regions that should be treated separately in putting the numbering together 
+    region_string = '11111111111111111111111222222222222222223333333333333333444444444445555555555555555555555555555555555555666666666666677777777777'
+    
+    region_index_dict = {"1":0,"2":1,"3":2,"4":3,"5":4,"6":5,"7":6}
+    
+    # Define how the scheme's numbering differs from IMGT at the start of each region. 
+    # This is updated in the loop below
+    rels              =  {0:0, 
+                         1: 0,
+                         2:-6,
+                         3:-6,
+                         4:-13,
+                         5:-16,
+                         6:-20,
+                         }    
+    
+    n_regions = 7
+    
+    exclude_deletions = [1,3,5]
+
+    _regions, startindex, endindex = _number_regions(sequence, state_vector, state_string , region_string,  region_index_dict, rels, n_regions, exclude_deletions)
+    
+    _numbering = [ _regions[0], [], _regions[2], [], _regions[4], [], _regions[6] ]
+    
+    
+    ###############
+    # Renumbering #
+    ###############
+    
+    # CDR1 
+    # Kabat L region 2 (index 1)
+    # put insertions onto 27
+    length = len( _regions[1] )
+    insertions = max(length - 11, 0) # Eleven positions can be accounted for, the remainder are insertions
+    # Delete forward from 28 
+    annotations  =  [(24, " "),(25, " "), (26, " "), (27, " ")][:max(0,length)] 
+    annotations += [(27, alphabet[i]) for i in range(insertions) ]
+    annotations += [(28, " "),(29, " "),(30, " "),(31, " "),(32, " "),(33, " "),(34, " ")][ abs( min(0,length-11) ):] 
+    _numbering[1] = [ (annotations[i], _regions[1][i][1]) for i in range(length) ]
+  
+    # CDR2
+    # Chothia L region 4 (index 3) 
+    # put insertions onto 52. 
+    length = len( _regions[3] )
+    insertions = max( length - 4, 0 )
+    if insertions > 0:
+        annotations  = [(51, " "),(52, " ")] + [(52, alphabet[i]) for i in range(insertions) ] + [(53, " "),(54, " ")]
+        _numbering[3] = [ (annotations[i], _regions[3][i][1]) for i in range(length) ]
+    else: # How to gap L2 in Chothia/Kabat/Martin is unclear so we let the alignment do it.
+        _numbering[3] = _regions[3]
+
+
+    # FW3
+    # All insertions are placed by alignment. This is in contrast to Martin (and Chothia) where they are placed on 68. 
+    # The kabat scheme was defined using a sequence alignment alone. In keeping with this, insertions in FW3 are also only placed
+    # with respect to the sequence alignment (the HMM).
+
+    # CDR3
+    # Chothia L region 6 (index 5) 
+    # put insertions onto 95
+    length = len( _regions[5] )    
+
+    if length > 35: return [], startindex, endindex # Too many insertions. Do not apply numbering. 
+    annotations = get_cdr3_annotations(length, scheme="kabat", chain_type="light")
+    _numbering[5]  = [ (annotations[i], _regions[5][i][1]) for i in range(length)  ]
+
+    return gap_missing( _numbering ), startindex, endindex    
+
+
+
+
+#############################
+# Martin (extended Chothia) #
+#############################
+
+# Heavy chains
+def number_martin_heavy(state_vector, sequence):
+    """
+    Apply the Martin (extended Chothia) numbering scheme for heavy chains
+    
+    Rules should be implemented using two strings - the state string and the region string. 
+
+    There are 128 states in the HMMs. Treat X as a direct match in Martin scheme, I is an insertion.
+    XXXXXXXXXI XXXXXXXXXXXXXXXXXXXX IIIIXX XXXXXXXXXXXXXXXXXXXX XIXII XXXXXXXXXXXIXXXXXXXXIIIXXXXXXXXXXXXXXXXXXXXXX XXXXXXIII XXXXXXXXXXXXX
+    1111111111 22222222222222222222 333333 44444444444444444444 55555 666666666666666666666666666666666666666666666 777777777 8888888888888
+     
+    
+    Regions - (N.B These do not match up with any particular definition of CDR)
+     1  -  Put the insertions at Chothia position 8
+     2  -  Simple mapping (treat "I" states as inserts and not own match states)
+     3  -  CDRH1 - 30 (inc) to 34 (exc) put insertions on 31
+     4  -  Simple mapping (treat "I" states as inserts and not own match states)
+     5  -  CDRH2 - 52 (inc) 58 (exc) put insertions on 52 
+     6  -  Simple mapping (treat "I" states as inserts and not own match states)
+     7  -  CDRH3 93 (inc) to 103 (exc) put insertion on 100
+     8  -  Simple mapping (treat "I" states as inserts and not own match states)
+
+
+    Regions 1,3,5 and 7 are renumbered
+    
+    """
+ 
+    # Set up the numbering 
+ 
+ 
+    # State string - 'X' means the imgt position exists in the scheme. 'I' means that it should be treated as an insertion of the previous number
+    state_string =  'XXXXXXXXXIXXXXXXXXXXXXXXXXXXXXIIIIXXXXXXXXXXXXXXXXXXXXXXXIXIIXXXXXXXXXXXIXXXXXXXXIIIXXXXXXXXXXXXXXXXXXXXXXXXXXXXIIIXXXXXXXXXXXXX'
+                    
+    # Region string - regions that should be treated separately in putting the numbering together 
+    region_string = '11111111112222222222222333333333333333444444444444444455555555555666666666666666666666666666666666666666777777777777788888888888'
+    
+    region_index_dict = {"1":0,"2":1,"3":2,"4":3,"5":4,"6":5,"7":6,"8":7}
+    
+    # Define how the scheme's numbering differs from IMGT at the start of each region. 
+    # This is updated in the loop below
+    rels              =  {0:0, 
+                         1:-1,
+                         2:-1,
+                         3:-5,
+                         4:-5,
+                         5:-8,
+                         6:-12,
+                         7:-15}    
+    
+    n_regions = 8
+    
+    exclude_deletions = [2,4,5,6]
+
+    _regions, startindex, endindex = _number_regions(sequence, state_vector, state_string , region_string,  region_index_dict, rels, n_regions, exclude_deletions)
+    
+
+    ###############
+    # Renumbering #
+    ###############
+        
+    # Renumbering required for 0, 2, 4, 6 regions in Chothia heavy
+    
+    _numbering = [ [], _regions[1] , [], _regions[3] , [], _regions[5], [], _regions[7] ]
+    
+    # Chothia H region 1 (index 0)
+    # Insertions are placed at Chothia position 8.
+    # Count how many we recognised as insertion by the hmm
+    insertions = len( [ 1 for _ in _regions[0] if _[0][1] != " " ] ) 
+    # We will place all insertion in this region at Chothia position 8.
+    if insertions:
+        start = _regions[0][0][0][0] # The starting Chothia number as found by the HMM (could easily start from 2 for example)
+        # I have a feeling this may be a source of a bug in very unusual cases. Can't break for now. Will catch mistakes in a validate function. 
+        length = len( _regions[0] )
+        annotations = [ (_, " ") for _ in range(start, 9) ] + [ (8, alphabet[_]) for _ in range(insertions) ] + [(9," ")]
+        _numbering[0] =  [ (annotations[i], _regions[0][i][1]) for i in range(length) ]
+    else:
+        _numbering[0] = _regions[0]
+
+    
+    # CDR1 
+    # Chothia H region 3 (index 2)
+    # put insertions onto 31
+    length = len( _regions[2] )
+    insertions = max(length - 11, 0) # Pulled back to the cysteine as heavily engineered cdr1's are not playing nicely
+    if insertions:
+        annotations = [(_, " ") for _ in range(23,32)] + [(31, alphabet[i]) for i in range(insertions) ] + [(32," "),(33," ")]
+    else:
+        annotations = [(_, " ") for _ in range(23,32)][:length-2] + [(32," "),(33," ")][:length]
+    _numbering[2] = [ (annotations[i], _regions[2][i][1]) for i in range(length) ]
+ 
+    # CDR2
+    # Chothia H region 5 (index 4) 
+    # put insertions onto 52
+    length = len( _regions[4] )
+    # 50 to 57 inclusive
+    insertions = max(length - 8, 0) # Eight positions can be accounted for, the remainder are insertions
+    # Delete in the order, 52, 51, 50,53, 54 ,55, 56, 57
+    annotations  =  [(50, " "),(51, " "), (52, " ")][:max(0,length-5)]
+    annotations += [(52, alphabet[i]) for i in range(insertions) ]
+    annotations += [(53, " "),(54, " "),(55, " "),(56, " "),(57, " ")][ abs( min(0,length-5) ):]
+    _numbering[4] = [ (annotations[i], _regions[4][i][1]) for i in range(length) ]
+
+    # FW3 
+    # Place all insertions on 72 explicitly.
+    # This is in contrast to Chothia implementation where 3 insertions are on 82 and then further insertions are placed by the 
+    # alignment
+    # Gaps are placed according to the alignment. 
+    length = len( _regions[5] )
+    insertions = max(length - 35, 0)
+    if insertions > 0: # Insertions on 72
+        annotations = [(i,' ') for i in range(58,73)]+[(72, alphabet[i]) for i in range(insertions) ]+[(i,' ') for i in range(73,93)]
+        _numbering[5] = [ (annotations[i], _regions[5][i][1]) for i in range(length) ]
+    else: # Deletions - all alignment to place them. 
+        _numbering[4] = _regions[4]
+
+     
+    # CDR3
+    # Chothia H region 7 (index 6) 
+    # put insertions onto 100
+    length = len( _regions[6] )    
+    if length > 36: return [], startindex, endindex # Too many insertions. Do not apply numbering. 
+    annotations = get_cdr3_annotations(length, scheme="chothia", chain_type="heavy")
+    _numbering[6]  = [ (annotations[i], _regions[6][i][1]) for i in range(length)  ]
+
+    # Return the full vector and the start and end indices of the numbered region of the sequence
+    return gap_missing( _numbering ), startindex, endindex                                    
+
+# Light chains
+def number_martin_light(state_vector, sequence):
+    """
+    Apply the Martin numbering scheme for light chains
+    
+    Rules should be implemented using two strings - the state string and the region string. 
+
+    There are 128 states in the HMMs. Treat X as a direct match in Martin scheme, I is an insertion.
+    XXXXXXXXXXXXXXXXXXXXXXXXXXXXX IIIIIIX XXXXXXXXXXXXXXXXXXXX XIIIIIIIXXX XXXXXIXXXXXXXIIXXXXXXXXXXXXXXXXXXXXXX XXXXXIIIIXX XXXXXXXXXXXXX
+    11111111111111111111111111111 2222222 33333333333333333333 44444444444 5555555555555555555555555555555555555 66666666666 7777777777777
+     
+    
+    Regions - (N.B These do not match up with any particular definition of CDR)
+     1  -  Simple mapping (treat "I" states as inserts and not own match states)
+     2  -  CDRL1 - 30 (inc) to 31 (exc) put insertions on 30
+     3  -  Simple mapping (treat "I" states as inserts and not own match states)
+     4  -  CDRL2 - 51 (inc) 55 (exc) put insertions on 52 
+     5  -  Simple mapping (treat "I" states as inserts and not own match states)
+     6  -  CDRL3 89 (inc) to 96 (exc) put insertion on 95
+     7  -  Simple mapping (treat "I" states as inserts and not own match states)
+    
+    Region 2, 3 and 5 are renumbered
+    
+    """
+    
+    # The Martin and Chothia specification for light chains are very similar. Martin is more explicit in the location of indels 
+    # but unlike the heavy chain these are additional instead of changes to the Chothia scheme. Thus, Chothia light is implemented
+    # as martin light.
+    return number_chothia_light(state_vector,sequence)
+
+
+###########
+# Wolfguy #
+###########
+# The Wolfguy numbering scheme is an in-house scheme used at Roche. It has been described publicly in the paper:
+# Prediction of VH-VL domain orientation for antibody variable domain modeling. Bujotzek A. et al. Protein 2015 83(4) 681-95
+#
+# It is similar in gapping as IMGT and is defined only for heavy and light antibody chains. 
+# Unlike other schemes the numbering denotes both the chain (heavy 101-499, light 501-799) and the region (less than -50 framework
+# greater than -50 CDR). All CDRs of length less than 50 can be handled without the need for insertion codes. Numbering of the 
+# framework behaves similarly to IMGT in that all positions are assumed to be accounted for. Framework insertions are placed by 
+# the alignment. 
+#
+# Numbering of all CDRs is performed symmetrically with the exception of CDRL1. In this case the CDR is numbered according to a 
+# pattern specific to the canonical class. This is recognised by length and by sequence similarity to a consensus sequence. If a 
+# length has not been observed it is numbered symmetrically. 
+
+
+def number_wolfguy_heavy(state_vector, sequence):
+    """
+    Apply the wolfguy numbering scheme for heavy chains 
+
+    The scheme numbers the sequence using different segments so that the numbering tells you
+    where in the antibody the sequence is describing. 
+
+    XXXXXXXXXIXXXXXXXXXXXXXXXX XXXXXXXXXXXXXX XXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXIX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXX XXXXXXXXXXX
+    11111111111111111111111111 22222222222222 33333333333333 44444444444444444444 555555555555555555555555555555 6666666666666 77777777777'
+    
+    Regions - (N.B These do not match up with any particular definition of CDR)
+     1  -  Simple mapping (treat "I" states as inserts and not own match states)
+     2  -  CDRH1 - 155-199 (inc). Gap symmetrically about 175-176.
+     3  -  Simple mapping (treat "I" states as inserts and not own match states)
+     4  -  CDRH2 - 251-299 (inc). Gap symmetrically about 271-272, then gap back from 294.
+     5  -  Simple mapping (treat "I" states as inserts and not own match states)
+     6  -  CDRH3 331,332 and 351-399 (inc). Gap according to the  
+     7  -  Simple mapping (treat "I" states as inserts and not own match states)
+    
+     Start gaps on rhs each time.
+    """
+    # Set up the numbering 
+ 
+    # State string - 'X' means the imgt position exists in the scheme. 'I' means that it should be treated as an insertion of the previous number
+    state_string =  'XXXXXXXXXIXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXIXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
+
+    # Region string - regions that should be treated separately in putting the numbering together 
+    region_string = '11111111111111111111111111222222222222223333333333333344444444444444444444555555555555555555555555555555666666666666677777777777'
+
+    region_index_dict = {"1":0,"2":1,"3":2,"4":3,"5":4,"6":5,"7":6}
+    
+    # Define how the scheme's numbering differs from IMGT at the start of each region. 
+    # This is updated in the loop below
+    rels              =  {0:100, 
+                         1:124,
+                         2:160,
+                         3:196,
+                         4:226,
+                         5:244,
+                         6:283}    
+    
+    n_regions = 7
+    
+    exclude_deletions = [1,3,5]
+
+    _regions, startindex, endindex = _number_regions(sequence, state_vector, state_string , region_string,  region_index_dict, rels, n_regions, exclude_deletions)
+    
+    ###############
+    # Renumbering #
+    ###############
+        
+    # Renumbering required for 1, 3, 5 regions in wolfguy heavy    
+    _numbering = [ _regions[0], [] , _regions[2], [], _regions[4] , [], _regions[6] ]
+
+    # CDRH1
+    # Delete symmetrically about 177. Delete right first.
+    # May have to change this to reflect where the point of symmetry is
+    ordered_deletions = [151]
+    for p1,p2 in zip( list(range(152,176)), list(range(199, 175,-1))): ordered_deletions += [ p1,p2 ]
+    length = len( _regions[1] )
+    annotations = sorted(ordered_deletions[:length])
+    _numbering[1]  = [ ((annotations[i]," "), _regions[1][i][1]) for i in range(length)  ]
+    
+    # CDRH2
+    # Delete symmetrically about 271. Delete right first.
+    # Then delete right from 288
+    ordered_deletions = [251]
+    for p1,p2 in zip( list(range(252,271)), list(range(290, 271,-1))): ordered_deletions += [ p1,p2 ]
+    ordered_deletions.append( 271 )
+    ordered_deletions = list(range( 299, 290, -1)) + ordered_deletions
+    length = len( _regions[3] )
+    annotations = sorted(ordered_deletions[:length])
+    _numbering[3]  = [ ((annotations[i]," "), _regions[3][i][1]) for i in range(length)  ]
+
+    # CDRH3	
+    # Delete symmetrically about 374. Delete right first. 
+    # Scheme changes at length 8
+    # Scheme changes at length 12
+    ordered_deletions = []
+    for p1,p2 in zip( list(range(356,374)), list(range(391, 373,-1))): ordered_deletions += [ p1,p2 ]
+    ordered_deletions = [ 354, 394, 355, 393, 392 ] + ordered_deletions 
+    ordered_deletions = [331,332] + [ 399, 398, 351, 352, 397, 353, 396, 395 ] + ordered_deletions
+    length = len( _regions[5] )
+
+    if length > len(ordered_deletions): return [], startindex, endindex # Too many insertions. Do not apply numbering.     
+    annotations = sorted(ordered_deletions[:length])
+    _numbering[5]  = [ ((annotations[i]," "), _regions[5][i][1]) for i in range(length)  ]    
+  
+    # Return the full vector and the start and end indices of the numbered region of the sequence
+    return sum( _numbering, [] ), startindex, endindex   
+            
+
+def number_wolfguy_light(state_vector, sequence):
+    """
+    Apply the wolfguy numbering scheme for light chains 
+
+    The scheme numbers the sequence using different segments so that the numbering tells you
+    where in the antibody the sequence is describing. 
+
+    XXXXXXX XXX XXXXXXXXXXXXX XXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXX XXXXXXXXXXXXXX XXXIXXXXXXX XXXX XXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXX XXXXXXXXXXX
+    1111111 AAA BBBBBBBBBBBBB 22222222222222222 333333333333333 44444444444444 55555555555 6666 77777777777777777777 8888888888888 99999999999
+
+    Regions - (N.B These do not match up with any particular definition of CDR)
+     1  -  Simple mapping (treat "I" states as inserts and not own match states)
+     A  -  Move indels onto 508
+     B  -  Simple mapping (treat "I" states as inserts and not own match states)
+     2  -  CDRL1 - 551-599 (inc). Assign via the matching consensus sequence and length.
+     3  -  Simple mapping (treat "I" states as inserts and not own match states)
+     4  -  CDRL2 - 651-699 (inc). Gap about 673 then right from 694
+     5  -  Simple mapping (treat "I" states as inserts and not own match states)
+     6  -  Move indels onto 713 and 714
+     7  -  Simple mapping (treat "I" states as inserts and not own match states)
+     8  -  CDRL3 751-799 (inc). Gap symmetrically about 374-375 
+     9  -  Simple mapping (treat "I" states as inserts and not own match states)
+    
+    """
+    # Set up the numbering 
+ 
+    # State string - 'X' means the imgt position exists in the scheme. 'I' means that it should be treated as an insertion of the previous number
+    state_string =  'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXIXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
+                    
+    # Region string - regions that should be treated separately in putting the numbering together 
+    region_string = '1111111AAABBBBBBBBBBBBB222222222222222223333333333333334444444444444455555555555666677777777777777777777888888888888899999999999'
+
+    region_index_dict = {"1":0,"A":1,"B":2,"2":3,"3":4,"4":5,"5":6,"6":7,"7":8,"8":9,"9":10}
+    
+    # Define how the scheme's numbering differs from IMGT at the start of each region. 
+    # This is updated in the loop below
+    rels              =  {0:500,
+                         1:500,
+                         2:500,    
+                         3:527,
+                         4:560,
+                         5:595,
+                         6:631,
+                         7:630,
+                         8:630,                                                  
+                         9:646,
+                         10:683}    
+    
+    n_regions = 11
+    
+    exclude_deletions = [1,3,5,7,9]
+
+    _regions, startindex, endindex = _number_regions(sequence, state_vector, state_string , region_string,  region_index_dict, rels, n_regions, exclude_deletions)
+    
+    ###############
+    # Renumbering #
+    ###############
+        
+    # Renumbering required for 1, 3, 5 regions in wolfguy heavy    
+    _numbering = [ _regions[0], [], _regions[2], [] , _regions[4], [], _regions[6], [], _regions[8], [], _regions[10] ]
+
+
+    # Gaps in the first section go 508 instead of the imgt 510 equivalent
+    length = len(_regions[1] )
+    annotations = sorted([ (510,' '), (509, ' '), (508, ' ')][ :length ] + [(508,a) for a in alphabet[:max(0, length-3)]])  
+    _numbering[1]  = [ (annotations[i], _regions[1][i][1]) for i in range(length)  ]
+    
+    # CDRL1
+    # Number by predicting the canonical 
+    length = len(_regions[3] )
+    annotations = _get_wolfguy_L1( _regions[3], length)
+    _numbering[3]  = [ ((annotations[i]," "), _regions[3][i][1]) for i in range(length)  ]
+    
+    # CDRL2
+    # Delete about 673. Finally delete right from 694. Maintain 651 as the last deletion
+    ordered_deletions = []
+    for p1,p2 in zip( list(range(652,673)), list(range(694, 672,-1))): ordered_deletions += [ p2,p1 ]
+    ordered_deletions = [651] + list(range( 699, 694, -1)) + ordered_deletions + [673]
+
+    length = len( _regions[5] )
+    annotations = sorted(ordered_deletions[:length])
+    _numbering[5]  = [ ((annotations[i]," "), _regions[5][i][1]) for i in range(length)  ]
+
+
+    # The placement of the indel in wolfguy is different to that in imgt
+    length = len( _regions[7] )
+    insertions = max( 0, length - 4 )
+    annotations = [(711, ' '), (712, ' '), (713, ' '), (714, ' ')][:length] + [ (714, a) for a in alphabet[:insertions] ]    
+    _numbering[7]  = [ (annotations[i], _regions[7][i][1]) for i in range(length)  ]  
+    
+    # CDRL3
+    # Delete symmetrically about 775. Delete right first. Finally delete 798 and 799
+    ordered_deletions = []
+    for p1,p2 in zip( list(range(751,775)), list(range(799, 775,-1))): ordered_deletions += [ p1,p2 ]
+    ordered_deletions.append( 775 )
+  
+    length = len( _regions[9] )
+    if length > len(ordered_deletions): return [], startindex, endindex # Too many insertions. Do not apply numbering. 
+    annotations = sorted(ordered_deletions[:length])
+    _numbering[9]  = [ ((annotations[i]," "), _regions[9][i][1]) for i in range(length)  ]  
+  
+    # Return the full vector and the start and end indices of the numbered region of the sequence
+    return sum( _numbering, [] ), startindex, endindex  
+
+
+def _get_wolfguy_L1(seq, length):
+    """
+    Wolfguy's L1 annotation is based on recognising the length and the sequence pattern defined
+    by a set of rules. If the length has not been characterised, we number symmetrically about the
+    middle of the loop.
+    """
+    
+    # These are the annotations for different lengths of L1 according to the wolfguy definitions.
+    L1_sequences = {
+    9: [['9',     'XXXXXXXXX', [551, 552, 554, 556, 563, 572, 597, 598, 599]]], 
+    10: [['10',   'XXXXXXXXXX', [551, 552, 553, 556, 561, 562, 571, 597, 598, 599]]], 
+    11: [['11a',  'RASQDISSYLA', [551, 552, 553, 556, 561, 562, 571, 596, 597, 598, 599]], 
+         ['11b',  'GGNNIGSKSVH', [551, 552, 554, 556, 561, 562, 571, 572, 597, 598, 599]], 
+         ['11b.2','SGDQLPKKYAY', [551, 552, 554, 556, 561, 562, 571, 572, 597, 598, 599]]], 
+    12: [['12a',  'TLSSQHSTYTIE', [551, 552, 553, 554, 555, 556, 561, 563, 572, 597, 598, 599]], 
+         ['12b',  'TASSSVSSSYLH', [551, 552, 553, 556, 561, 562, 571, 595, 596, 597, 598, 599]], 
+         ['12c',  'RASQSVxNNYLA', [551, 552, 553, 556, 561, 562, 571, 581, 596, 597, 598, 599]], 
+         ['12d',  'rSShSIrSrrVh', [551, 552, 553, 556, 561, 562, 571, 581, 596, 597, 598, 599]]], 
+    13: [['13a',  'SGSSSNIGNNYVS', [551, 552, 554, 555, 556, 557, 561, 562, 571, 572, 597, 598, 599]], 
+         ['13b',  'TRSSGSLANYYVQ', [551, 552, 553, 554, 556, 561, 562, 563, 571, 572, 597, 598, 599]]], 
+    14: [['14a',  'RSSTGAVTTSNYAN', [551, 552, 553, 554, 555, 561, 562, 563, 564, 571, 572, 597, 598, 599]], 
+         ['14b',  'TGTSSDVGGYNYVS', [551, 552, 554, 555, 556, 557, 561, 562, 571, 572, 596, 597, 598, 599]]], 
+    15: [['15',   'XXXXXXXXXXXXXXX', [551, 552, 553, 556, 561, 562, 563, 581, 582, 594, 595, 596, 597, 598, 599]]], 
+    16: [['16',   'XXXXXXXXXXXXXXXX', [551, 552, 553, 556, 561, 562, 563, 581, 582, 583, 594, 595, 596, 597, 598, 599]]], 
+    17: [['17',   'XXXXXXXXXXXXXXXXX', [551, 552, 553, 556, 561, 562, 563, 581, 582, 583, 584, 594, 595, 596, 597, 598, 599]]]
+    }    
+
+    if length in L1_sequences: # Use the pre-defined motif 
+        # Find the maximum scoring canonical form for this length. 
+        curr_max = None, -10000
+        for canonical in L1_sequences[length]:
+            sub_score = 0
+            for i in range( length ):
+                try:
+                    sub_score += blosum62[ (seq[i][1].upper(), canonical[1][i].upper() ) ]
+                except KeyError:
+                    sub_score += blosum62[ (canonical[1][i].upper(), seq[i][1].upper() ) ]
+            if sub_score > curr_max[1]:
+                curr_max = canonical, sub_score
+
+        # return the annotations
+        return curr_max[0][2]
+    else: # Use a symmetric numbering about the anchors.
+        ordered_deletions = []
+        for p1,p2 in zip( list(range(551,575)), list(range(599, 575,-1))): ordered_deletions += [ p2,p1 ]
+        ordered_deletions.append(575)
+        return sorted( ordered_deletions[:length] )
+
+def gap_missing( numbering ):
+    '''
+    Place gaps when a number is missing. All except wolfguy are continuously numbered
+    '''
+    # Gaps placed where a number is not present
+    num = [ ((0,' '),'-') ]
+    for p, a in sum( numbering, [] ):  
+        if p[0] > num[-1][0][0]+1:
+            for _i in range( num[-1][0][0]+1, p[0] ):
+                num.append( ((_i, ' '), '-' ) )
+        num.append( (p,a) )
+    return num[1:]
+
+
+######################
+# Annotation of CDR3 #
+######################
+    
+def get_cdr3_annotations(length, scheme="imgt", chain_type=""):
+    """
+    Given a length of a cdr3 give back a list of the annotations that should be applied to the sequence.
+    
+    This function should be depreciated
+    """
+    az = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" 
+    za = "ZYXWVUTSRQPONMLKJIHGFEDCBA"
+    
+    if scheme=="imgt":
+        start, end = 105, 118 # start (inclusive) end (exclusive)
+        annotations = [None for _ in range(max(length,13))]
+        front = 0
+        back  = -1
+        assert (length-13) < 50, "Too many insertions for numbering scheme to handle" # We ran out of letters.
+        for i in range(min(length,13)):
+            if i%2:
+                annotations[back] = (end+back, " ")
+                back -= 1
+            else:
+                annotations[front] = (start+front, " ")
+                front += 1
+        for i in range(max(0,length-13)): # add insertions onto 111 and 112 in turn
+            if i%2:
+                annotations[back] = (112, za[back+6])
+                back-=1
+            else:
+                annotations[front] = (111, az[front-7])
+                front +=1        
+        return annotations
+
+    elif scheme in [ "chothia", "kabat"] and chain_type=="heavy": # For chothia and kabat
+        # Number forwards from 93
+        insertions = max(length - 10, 0)
+        assert insertions < 27, "Too many insertions for numbering scheme to handle" # We ran out of letters.
+        ordered_deletions = [ (100, ' '), (99,' '), (98,' '), (97,' '), (96,' '), (95,' '), (101,' '),(102,' '),(94,' '), (93,' ') ]
+        annotations = sorted( ordered_deletions[ max(0, 10-length): ] + [ (100,a) for a in az[:insertions ] ] )
+        return annotations
+
+    elif scheme in [ "chothia", "kabat"] and chain_type=="light":
+        # Number forwards from 89
+        insertions = max(length - 9, 0)
+        assert insertions < 27, "Too many insertions for numbering scheme to handle" # We ran out of letters.
+        ordered_deletions = [ (95,' '),(94,' '),(93,' '),( 92,' '),(91,' '),(96,' '),(97,' '),(90,' '),(89,' ') ]
+        annotations = sorted( ordered_deletions[ max(0, 9-length): ] + [ (95,a) for a in az[:insertions ] ] )
+        return annotations
+
+    else:
+        raise AssertionError("Unimplemented scheme")
+

app.py

@@ -194,7 +194,7 @@ def main():
         )
 
         if uploaded_file is None:
-            with st.expander('Download examples', expanded=True):
+            with st.expander("Don't know what to upload? Try these examples", expanded=True):
                 with open('./data/examples/7DK2_AB_C.pdb', 'r') as f:
                     st.download_button(
                         'RBD + Antibody Complex', 

requirements.txt

@@ -2,8 +2,6 @@
 torch
 torchvision
 biopython==1.79
-git+https://github.com/oxpig/ANARCI.git
-git+https://github.com/prihoda/AbNumber.git
 joblib
 lmdb
 tqdm