Returns true if a word is probably not Latin
498022
public static boolean noLatin(String s) {
    return(s.indexOf('h')>0 || s.indexOf('j')>0 || s.indexOf('k')>0 ||
           s.indexOf('w')>0 || s.indexOf('y')>0 || s.indexOf('z')>0 ||
           s.indexOf("ou")>0 || s.indexOf("sh")>0 || s.indexOf("ch")>0 ||
           s.endsWith("aus"));
  }
150793
def guess_language(file_name, local_file):
    

    lexer = None

    language = get_language_from_extension(file_name)
    if language:
        lexer = get_lexer(language)
    else:
        lexer = smart_guess_lexer(file_name, local_file)
        if lexer:
            language = u(lexer.name)

    return language, lexer
584017
def _detect_term_type():
        
        if os.name == 'nt':
            if os.environ.get('TERM') == 'xterm':
                # maybe MinTTY
                return 'mintty'
            else:
                return 'nt'
        if platform.system().upper().startswith('CYGWIN'):
            return 'cygwin'
        return 'posix'
555512
public function isAutoLiteral()
    {
        return $this->smarty->auto_literal && isset($this->value[ $this->ldel_length ]) ?
            strpos(" \n\t\r", $this->value[ $this->ldel_length ]) !== false : false;
    }
1145160
def _is_ctype(self, ctype):
        """"""
        if not self.valid:
            return False
        mime = self.content_type
        return self.ContentMimetypes.get(mime) == ctype
499445
def is_simplified(s):
    
    chinese = _get_hanzi(s)
    if not chinese:
        return False
    elif chinese.issubset(_SHARED_CHARACTERS):
        return True
    elif chinese.issubset(_SIMPLIFIED_CHARACTERS):
        return True
    return False
238429
def _is_suffix(self, t):
        """"""
        return t not in NOT_SUFFIX and (t.replace('.', '') in SUFFIXES or t.replace('.', '') in SUFFIXES_LOWER)
586393
private static boolean isCollationCorrect(String collation) {
    return containsIgnoreCase(collation, CASE_SENSITIVE_ACCENT_SENSITIVE)
      || containsIgnoreCase(collation, BIN)
      || containsIgnoreCase(collation, BIN2);
  }
1161402
def identify_greek_word(input)
      input.each_char do |char|
        if (!GREEK_CHARACTERS.include?(char))
          return false
        end
      end

      true
    end
1327997
def is_unicode_string(string):
    """"""
    try:
        if sys.version_info >= (3, 0):
            # isn't a python 3 str actually unicode
            if not isinstance(string, str):
                string.decode('utf-8')

        else:
            string.decode('utf-8')
    except UnicodeError:
        raise aomi.exceptions.Validation('Not a unicode string')
41053
def is_text(bytesio):
    
    text_chars = (
        bytearray([7, 8, 9, 10, 11, 12, 13, 27]) +
        bytearray(range(0x20, 0x7F)) +
        bytearray(range(0x80, 0X100))
    )
    return not bool(bytesio.read(1024).translate(None, text_chars))
662043
private boolean haveExperimentalLanguagePrefix() {
        if (id.length > 2) {
            char c = id[1];
            if (c == HYPHEN || c == UNDERSCORE) {
                c = id[0];
                return c == 'x' || c == 'X' || c == 'i' || c == 'I';
            }
        }
        return false;
    }
1070426
def is_diacritic(char, strict=True):
	
	if char in chart.diacritics:
		return True

	if not strict:
		return (unicodedata.category(char) in ['Lm', 'Mn', 'Sk']) \
				and (not is_suprasegmental(char)) \
				and (not is_tie_bar(char)) \
				and (not 0xA700 <= ord(char) <= 0xA71F)

	return False
7516
def _looks_like_script(self, path):
        
        fp = open(path, 'rb')
        try:
            sample = fp.read(512).decode('latin-1')
            return not set(sample).difference(string.printable)
        finally:
            fp.close()
1069590
private static boolean isName(final String _text, final boolean isFirstWord, final boolean nextWordIsName) {
        if (hasManyCaps(_text)) return true;
        else if (startsWithCap(_text)) {
            if (isFirstWord) {
                // if the word is the first word in a sentence and
                // ends with -ly (adv) -> consider it not a name
                if (_text.endsWith("ly")) return false;

                // we need to deal with the first word in the sentence very carefully.
                // as we can not tell if the first word is a name by detecting upper case characters.
                final String type_original = Dictionary.checkup(_text);
                final String type_lowercase = Dictionary.checkup(toEngLowerCase(_text));
                if (type_original == null) {
                    // if the word cannot be found in the dictionary, we consider it as a name entity.
                    if (type_lowercase == null) return true;
                }
                else if ("NNP".equals(type_original)) return true;
                //noinspection IfMayBeConditional,SimplifiableIfStatement
                if (startsWith(type_lowercase, "IN", "CC", "RB", "WRB"/*, "JJ"*/, ".")) return false;
                else return nextWordIsName;
            }
            else return true;
        }
        else return false;
    }
224783
def isglob(value):
    
    if os.name == 'nt':
        if isinstance(value, basestring):
            value = glob.glob(value)
    return value
356060
public boolean isPrefixOf(Word<?> other) {
        int len = length(), otherLen = other.length();
        if (otherLen < len) {
            return false;
        }

        for (int i = 0; i < len; i++) {
            I sym1 = getSymbol(i);
            Object sym2 = other.getSymbol(i);

            if (!Objects.equals(sym1, sym2)) {
                return false;
            }
        }
        return true;
    }