使用正则表达式验证输入

Question

Verification and classified Input with RE

here now using input like '1-1-AA' and spilts every point with '-' But input can various for example "chr1-1-CG", "3-1-CA","CHRX-34-AT", and etc.

Which first position should accept "chr1, chr2, ... chr 23, chrX, ChrY", second position should only accept positive number, third and fourth one should only accept one letter from {A,C,G,T}

so Im thinking about using '''re.findall''' and use error cases to return warning for incorrect input. But not sure how to give errors with regular expression.

can anyone help?

def _check_input(var_str):  # maybe better to check each input seperately
    """
    Checks if the input is a valid variant string
    :param var_str: string supposed to be in the format 'chr-pos-ref-alt'
    :return: bool which tells wether the input is valid
    """
    pattern = re.compile(
        r"""([1-9]|[1][0-9]|[2][0-2]|[XY])  # the chromosome
                        -(\d+)     # the position
                        -[ACGT]+   #RawDescriptionHelpFormatter,
                        -[ACGT]+  # alt""",
        re.X,
    )
    if re.fullmatch(pattern, var_str) is None:
        return False
    else:
        return True


def string_to_dict(inp):
    """
    Converts a variant string into a dictionary
    :param inp: string which should be a valid variant
    :return: dictionary with the variants keys and values
    """
    inp_list = inp.split("-")
    inp_dict = {
        "chr": inp_list[0],
        "pos": inp_list[1],
        "ref": inp_list[2],
        "alt": inp_list[3],
    }
    return inp_dict

Answer 1

Regex is great to check the global validity of sequence. Unfortunately I do not see how you can achieve error checking using one single regex.

So I think you can use the regex to check the full validity of the input. If it is not valid then you can add some more code to warn the user on what might be wrong.

import re


def _check_input(var_str):
    """
    Checks if the input is a valid variant string
    :param var_str: string supposed to be in the format 'chr-pos-ref-alt'
    :return: a match object
    :raises: ValueError on invalid input        
    """
    pattern = re.compile(
        r"(?:chr)?(?P<chr>[1-9]|[1][0-9]|[2][0-3]|[XY])"  # the chromosome
        r"-(?P<pos>\d+)"  # the position
        r"-(?P<ref>[ACGT])"  # RawDescriptionHelpFormatter
        r"-(?P<alt>[ACGT])",  # alt
        re.X | re.IGNORECASE,
    )
    match = re.match(pattern, var_str)

    if not match:
        _input_error_suggestion(var_str)

    return match # you can access values like so match['chr'], match['pos'], match['ref'], match['alt']

def _input_error_suggestion(var_str):
    parts = var_str.split('-')

    if len(parts) != 4:
        raise ValueError('Input should have 4 parts separated by -')

    chr, pos, nucleotide1, nucleotide2 = parts

    # check part 1
    chr_pattern = re.compile(r'(?:chr)?([1-9]|[1][0-9]|[2][0-3]|[XY])', re.IGNORECASE)
    if not re.match(chr_pattern, chr):
        raise ValueError('Input first part should be a chromosome chr1, chr2, ..., chr 23, chrX, chrY')

    # check part 2
    try:
        p = int(pos)
    except ValueError:
        raise ValueError('Input second part should be an integer')
    if p < 0:
        raise ValueError('Input second part should be a positive integer')

    # check part 3 and 4
    for i, n in enumerate((nucleotide1, nucleotide2)):
        if n not in 'ACGT':
            raise ValueError(f"Input part {3 + i} should be one of {{A,C,G,T}}")

    # something else
    raise ValueError(f"Input was malformed, it should be in the format 'chr-pos-ref-alt'")

side notes:

I improved the original regex by

• adding the optional "chr",
• naming groups,
• one and only one letter per nucleotide,
• fixing the missing chromosome 23 and
• allowing to be case insensitive.