return True if word_in has any English letters in the string
429394
def has_english( word_in ):
    
    return not all_tamil(word_in) and len(word_in) > 0 and any([l in word_in for l in string.ascii_letters])
769403
def is_in(self, search_list, pair):
        
        index = -1
        for nr, i in enumerate(search_list):
            if(np.all(i == pair)):
                return nr
        return index
261714
function getCorrection(words, match) {
	for (const word of words) {
		const pattern = getPattern(word);
		if (!getRegExp([pattern]).test(match)) {
			continue;
		}

		const corrected = match.replace(new RegExp(`\\b${pattern}`, 'i'), word);
		return matchCasing(corrected, match);
	}

	return false;
}
1005093
public static boolean checkAbreviations(String string, int i)
    {
        // Check first character
        for (int index = 0; index < ABREVIATIONS.length; index++)
        {
            if (ABREVIATIONS[index].length() > 1)
                if (string.charAt(i) == ABREVIATIONS[index].charAt(0))
                    if (string.length() > i + 1)
                        if (string.charAt(i+1) == ABREVIATIONS[index].charAt(1))
                            if (string.length() > i + 2)
                                if (string.charAt(i+2) == ABREVIATIONS[index].charAt(2))
                                    return true;
        }
        // Check second character
        for (int index = 0; index < ABREVIATIONS.length; index++)
        {
            if (ABREVIATIONS[index].length() > 2)
                if (i > 0)
                    if (string.charAt(i-1) == ABREVIATIONS[index].charAt(0))
                        if (string.charAt(i) == ABREVIATIONS[index].charAt(1))
                            if (string.length() > i + 1)
                                if (string.charAt(i+1) == ABREVIATIONS[index].charAt(2))
                                    return true;
        }
        return false;
    }
1006351
public static boolean isStringTrue(String in) {
    if (in == null)
      return false;
    return in.equalsIgnoreCase("TRUE") || in.equalsIgnoreCase("YES") || in.equals("1");
  }
998234
public static boolean isWord(String wordString) {
        return Optional.ofNullable(wordPattern)
                .orElseGet(() -> wordPattern = Pattern.compile(WordPattern))
                .matcher(wordString).matches();
    }
1217934
def correct_word(word_string):
    '''
    
    '''
    if word_string is None:
        return ""
    elif isinstance(word_string, str):
        return max(find_candidates(word_string), key=find_word_prob)
    else:
        raise InputError("string or none type variable not passed as argument to correct_word")
353630
def validate_words(word_list):
    '''
    
    '''
    if word_list is None:
        return {}
    elif isinstance(word_list, list):
        if not word_list:
            return {}
        else:
            return set(word for word in word_list if word in WORD_DISTRIBUTION)
    else:
        raise InputError("list variable not passed as argument to validate_words")
858909
private static boolean hasManyCaps(final String word) {
        if ("i".equalsIgnoreCase(word)) return false;
        int capCharCount = 0;
        for (int i = 0; i < word.length(); i++) {
            if (isUpperCase(word.charAt(i))) capCharCount++;
            if (capCharCount == 2) return true;
        }
        return false;
    }
1296375
def is_inside_any(dir_list, fname):
    """"""
    for dirname in dir_list:
        if is_inside(dirname, fname):
            return True
    return False
1147390
def is_letter(char, strict=True):
	
	if (char in chart.consonants) or (char in chart.vowels):
		return True

	if not strict:
		return unicodedata.category(char) in ['Ll', 'Lo', 'Lt', 'Lu']

	return False
342906
def is_present(p):
    
    return lexeme(p).optional().map(lambda v: False if v is None else True)
603145
def has_content_in(page, language):
    
    if page is None:
        return False
    return Content.objects.filter(page=page, language=language).count() > 0
444136
def is_unicode(string):
    """"""
    str_type = str(type(string))

    if str_type.find('str') > 0 or str_type.find('unicode') > 0:
        return True

    return False
586393
private static boolean isCollationCorrect(String collation) {
    return containsIgnoreCase(collation, CASE_SENSITIVE_ACCENT_SENSITIVE)
      || containsIgnoreCase(collation, BIN)
      || containsIgnoreCase(collation, BIN2);
  }
854625
function isNameAbbreviation(wordCount, words) {
    if (words.length > 0) {
        if (wordCount < 5 && words[0].length < 6 && isCapitalized(words[0])) {
            return true;
        }

        var capitalized = words.filter(function(str) {
            return /[A-Z]/.test(str.charAt(0));
        });

        return capitalized.length >= 3;
    }

    return false;
}
876427
def exists(self, word):
		

		node = self.__get_node(word)
		if node:
			return bool(node.output != nil)
		else:
			return False