validators.py

Go to the documentation of this file.

#!/usr/bin/env python
# -*- coding: utf-8 -*-


import wave
import StringIO
from functools import wraps
from exceptions import ParameterException
from exceptions import UnsupportedLanguageException
from exceptions import InvalidAudioDataException

def accepts(**types):
    """ check function argument types

    @param types: parameter types (kwdict)
    @type  types: dict
    @raise ParameterException: parameter type exception
    """
    def check_accepts(f):
        @wraps(f)
        def wrapper(*args, **kwds):
            for cnt, val in enumerate(args):
                if types.has_key(f.func_code.co_varnames[cnt]) and \
                    not isinstance(val, types[f.func_code.co_varnames[cnt]]):
                    raise ParameterException("argument '%s'=%r does not match %s" % \
                                (f.func_code.co_varnames[cnt], val, types[f.func_code.co_varnames[cnt]]))
                    del types[f.func_code.co_varnames[cnt]]

            for key, val in kwds.iteritems():
                if types.has_key(key) and not isinstance(val, types[key]):
                    raise ParameterException("argument '%s'=%r does not match %s" % (key, val, types[key]))

            return f(*args, **kwds)
        return wrapper
    return check_accepts


def check_wave_data(data, framerate, nchannel, sampwidth, maxlength):
    """ check wave file error.

    @param data: parameter data
    @type  data: str
    @param framerate: wave file framerate
    @type  framerate: int
    @param nchannel: wave file channel
    @type  nchannel: int
    @param sampwidth: sampling width (1=>8bit, 2=>16bit, 4=>32bit)
    @type  sampwidth: int
    @param maxlength: max wave length [ms]
    @type  maxlength: int
    @raises InvalidAudioDataException
    """
    try:
        wav_buffer = StringIO.StringIO(data)
        wav_file = wave.open(wav_buffer, 'rb')
        framerate_ = wav_file.getframerate()
        sampwidth_ = wav_file.getsampwidth()
        channels_ = wav_file.getnchannels()
        nframes_ = wav_file.getnframes()

        read_data = wav_file.readframes(nframes_)
        read_data_size = len(read_data)
        header_data_size = sampwidth_ * channels_ * nframes_
        wave_length_ = int(float(wav_file.getnframes()) / wav_file.getframerate() * 1000.0)

        if framerate_ != framerate:
            msg = 'the wav file frame rate MUST be %d. curr: %d' % (framerate, framerate_)
            raise InvalidAudioDataException(msg)

        if sampwidth_ != sampwidth:
            msg = 'the wav file samplewidth MUST be %dbit. curr: %d' % (sampwidth*8, sampwidth_*8)
            raise InvalidAudioDataException(msg)

        if channels_ != nchannel:
            msg = 'the wav file channels MUST be %d. curr: %d' % (nchannel, channels_)
            raise InvalidAudioDataException(msg)

        if header_data_size != read_data_size:
            msg = 'the wav file is broken. data_size(by header): %d data_size(by data): %d' % (header_data_size, read_data_size)
            raise InvalidAudioDataException(msg)

        if wave_length_ > maxlength:
            msg = 'the playing time of the wav file is too long. max %d[ms] curr: %d[ms]' % (maxlength, wave_length_)
            raise InvalidAudioDataException(msg)

        if wave_length_ == 0:
            msg = 'the playing time of the wav file is zero.'
            raise InvalidAudioDataException(msg)

    except wave.Error as err:
        raise InvalidAudioDataException('the input audio data MUST be wav format. Exception: %s' % str(err))


def check_language(language, supported_languages):
    """ check supported language

    @param param_name: check parameter name
    @type  param_name: str
    @param languages: supported languages in the client
    @type  languages: list
    @raises UnsupportedLanguageException
    """
    # check supported language
    if not language in supported_languages:
        raise UnsupportedLanguageException('%s is unsupported language. supported languages are %s' % (language, supported_languages));