def checkPeriods(name):
words = wordList(name)
for word in words:
if word[-1] == ',':
word = word[:-1]
numPeriods = word.count('.')
if not numPeriods:
continue
letters = justLetters(word)
numLetters = len(letters)
if word[-1] != '.':
notify.info('word "%s" does not end in a period' %
TextEncoder().encodeWtext(word))
return OTPLocalizer.NCPeriodUsage
if numPeriods > 2:
notify.info('word "%s" has too many periods' %
TextEncoder().encodeWtext(word))
return OTPLocalizer.NCPeriodUsage
if numPeriods == 2:
if not (word[1] == '.' and word[3] == '.'):
notify.info('word "%s" does not fit the J.T. pattern' %
TextEncoder().encodeWtext(word))
return OTPLocalizer.NCPeriodUsage
return None
def test_text_encode_utf16be():
encoder = TextEncoder()
encoder.set_encoding(TextEncoder.E_utf16be)
for c in valid_characters():
enc = encoder.encode_wtext(c)
assert enc == c.encode('utf-16-be')
def checkJapanese(name):
asciiSpace = range(32, 33)
asciiDigits = range(48, 64)
hiragana = range(12353, 12448)
katakana = range(12449, 12544)
halfwidthKatakana = range(65381, 65440)
halfwidthCharacter = set(asciiSpace + halfwidthKatakana)
allowedUtf8 = set(asciiSpace + hiragana + katakana + halfwidthKatakana)
te = TextEncoder()
dc = 0.0
for char in (ord(char) for char in te.decodeText(name)):
if char not in allowedUtf8:
if char in asciiDigits:
notify.info('name contains not allowed ascii digits')
return OTPLocalizer.NCNoDigits
else:
notify.info('name contains not allowed utf8 char: 0x%04x' % char)
return OTPLocalizer.NCBadCharacter % te.encodeWtext(unichr(char))
elif char in halfwidthCharacter:
dc += 0.5
else:
dc += 1
if dc < 2:
notify.info('name is too short: %0.1f' % dc)
return OTPLocalizer.NCTooShort
elif dc > 8:
notify.info('name has been occupied more than eight display cells: %0.1f' % dc)
return OTPLocalizer.NCGeneric
def checkJapanese(name):
asciiSpace = range(32, 33)
asciiDigits = range(48, 64)
hiragana = range(12353, 12448)
katakana = range(12449, 12544)
halfwidthKatakana = range(65381, 65440)
halfwidthCharacter = set(asciiSpace + halfwidthKatakana)
allowedUtf8 = set(asciiSpace + hiragana + katakana + halfwidthKatakana)
te = TextEncoder()
dc = 0.0
for char in (ord(char) for char in te.decodeText(name)):
if char not in allowedUtf8:
if char in asciiDigits:
notify.info('name contains not allowed ascii digits')
return OTPLocalizer.NCNoDigits
else:
notify.info('name contains not allowed utf8 char: 0x%04x' %
char)
return OTPLocalizer.NCBadCharacter % te.encodeWtext(
unichr(char))
elif char in halfwidthCharacter:
dc += 0.5
else:
dc += 1
if dc < 2:
notify.info('name is too short: %0.1f' % dc)
return OTPLocalizer.NCTooShort
elif dc > 8:
notify.info(
'name has been occupied more than eight display cells: %0.1f' %
dc)
return OTPLocalizer.NCGeneric
def test_text_encode_iso8859():
encoder = TextEncoder()
encoder.set_encoding(TextEncoder.E_iso8859)
for i in xrange(255):
c = unichr(i)
enc = encoder.encode_wtext(c)
assert enc == c.encode('latin-1')
def badCharacters(name, _validCharacter=_validCharacter):
for char in name:
if not _validCharacter(char):
if char in string.digits:
notify.info('name contains digits')
return OTPLocalizer.NCNoDigits
notify.info('name contains bad char: %s' % TextEncoder().encodeWtext(char))
return OTPLocalizer.NCBadCharacter % TextEncoder().encodeWtext(char)
def perWord(word):
word = word
letters = justLetters(word)
if len(letters) > 2:
letters = TextEncoder().decodeText(TextEncoder.lower(TextEncoder().encodeWtext(letters)))
filtered = filterString(letters, letters[0])
if filtered == letters:
notify.info('word "%s" uses only one letter' % TextEncoder().encodeWtext(word))
return OTPLocalizer.NCGeneric
def fontHasCharacters(name, font = font):
if font:
tn = TextNode('NameCheck')
tn.setFont(font)
for c in name:
# Define c as unicode
if not tn.hasCharacter(chr(ord(c))):
notify.info('name contains bad char: %s' % TextEncoder().encodeWtext(c))
return OTPLocalizer.NCBadCharacter % TextEncoder().encodeWtext(c)
def test_text_decode_utf16be():
encoder = TextEncoder()
encoder.set_encoding(TextEncoder.E_utf16be)
for c in valid_characters():
enc = c.encode('utf-16be')
dec = encoder.decode_text(enc)
assert len(c) == len(dec)
assert c == dec
def allCaps(name):
letters = justLetters(name)
if len(letters) > 2:
upperLetters = TextEncoder().decodeText(TextEncoder.upper(TextEncoder().encodeWtext(letters)))
for i in xrange(len(upperLetters)):
if not upperLetters[0].isupper():
return
if upperLetters == letters:
notify.info('name is all caps')
return OTPLocalizer.NCAllCaps
def test_text_decode_iso8859():
encoder = TextEncoder()
encoder.set_encoding(TextEncoder.E_iso8859)
for i in xrange(255):
enc = unichr(i).encode('latin-1')
assert len(enc) == 1
dec = encoder.decode_text(enc)
assert len(dec) == 1
assert ord(dec) == i
def test_text_decode_utf8():
encoder = TextEncoder()
encoder.set_encoding(TextEncoder.E_utf8)
for c in valid_characters():
enc = c.encode('utf-8')
assert len(enc) <= 4
dec = encoder.decode_text(enc)
assert len(dec) == 1
assert dec == c
def __typedAName(self, *args):
self.notify.debug('__typedAName')
self.nameEntry['focus'] = 0
name = self.nameEntry.get()
name = TextEncoder().decodeText(name)
name = name.strip()
name = TextEncoder().encodeWtext(name)
self.nameEntry.enterText(name)
problem = self.nameIsValid(self.nameEntry.get())
if problem:
self.rejectName(problem)
return
self.checkNameTyped(justCheck=True)
def __typedAName(self, *args):
self.notify.debug('__typedAName')
self.nameEntry['focus'] = 0
name = self.nameEntry.get()
name = TextEncoder().decodeText(name)
name = name.strip()
name = TextEncoder().encodeWtext(name)
self.nameEntry.enterText(name)
problem = self.nameIsValid(self.nameEntry.get())
if problem:
self.rejectName(problem)
return
self.checkNameTyped(justCheck=True)
def hasLetters(name):
words = wordList(name)
for word in words:
letters = justLetters(word)
if len(letters) == 0:
notify.info('word "%s" has no letters' % TextEncoder().encodeWtext(word))
return OTPLocalizer.NCNeedLetters
def makeSign(topStr, signStr, textId):
top = self.geom.find('**/' + topStr)
sign = top.find('**/' + signStr)
locator = top.find('**/sign_origin')
signText = DirectGui.OnscreenText(text=TextEncoder.upper(TTLocalizer.GlobalStreetNames[textId][-1]), font=ToontownGlobals.getSuitFont(), scale=TTLocalizer.BCHQLsignText, fg=(0, 0, 0, 1), parent=sign)
signText.setPosHpr(locator, 0, -0.1, -0.25, 0, 0, 0)
signText.setDepthWrite(0)
def repeatedChars(name):
count = 1
lastChar = None
i = 0
while i < len(name):
char = name[i]
i += 1
if char == lastChar:
count += 1
else:
count = 1
lastChar = char
if count > 2:
notify.info('character %s is repeated too many times' % TextEncoder().encodeWtext(char))
return OTPLocalizer.NCRepeatedChar % TextEncoder().encodeWtext(char)
return
def perWord(word):
word = word
letters = justLetters(word)
if len(letters) > 2:
letters = TextEncoder().decodeText(TextEncoder.lower(TextEncoder().encodeWtext(letters)))
filtered = filterString(letters, letters[0])
if filtered == letters:
notify.info('word "%s" uses only one letter' % TextEncoder().encodeWtext(word))
return OTPLocalizer.NCGeneric
def allCaps(name):
letters = justLetters(name)
if len(letters) > 2:
upperLetters = TextEncoder().decodeText(TextEncoder.upper(TextEncoder().encodeWtext(letters)))
for i in xrange(len(upperLetters)):
if not upperLetters[0].isupper():
return
if upperLetters == letters:
notify.info('name is all caps')
return OTPLocalizer.NCAllCaps
def checkApostrophes(name):
words = wordList(name)
for word in words:
numApos = word.count("'")
if numApos > 2:
notify.info('word "%s" has too many apostrophes.' % TextEncoder().encodeWtext(word))
return OTPLocalizer.NCApostrophes
numApos = name.count("'")
if numApos > 3:
notify.info('name has too many apostrophes.')
return OTPLocalizer.NCApostrophes
def perWord(word):
if '.' in word:
return
for char in word:
if ord(char) >= 128:
return
letters = filterString(word, string.letters)
if len(letters) > 2:
vowels = filterString(letters, 'aeiouyAEIOUY')
if len(vowels) == 0:
notify.info('word "%s" has no vowels' % TextEncoder().encodeWtext(word))
return OTPLocalizer.NCNeedVowels
return
def test_text_append_unicode_char():
encoder = TextEncoder()
encoder.set_encoding(TextEncoder.E_iso8859)
code_points = []
for code_point in [0, 1, 127, 128, 255, 256, 0xfffd, 0x10000, 0x10ffff]:
if code_point <= sys.maxunicode:
code_points.append(code_point)
encoder.append_unicode_char(code_point)
encoded = encoder.get_wtext()
assert len(encoded) == len(code_points)
for a, b in zip(code_points, encoded):
assert a == ord(b)
def match(npcName, name = name):
name = TextEncoder().encodeWtext(name)
name = string.strip(name)
return TextEncoder.upper(npcName) == TextEncoder.upper(name)
def match(npcName, name = name):
name = TextEncoder().encodeWtext(name)
name = name.strip()
return TextEncoder.upper(npcName) == TextEncoder.upper(name)
def checkName(name, otherCheckFuncs=[], font=None):
def longEnough(name):
if len(name) < 2:
notify.info('name is too short')
return OTPLocalizer.NCTooShort
def emptyName(name):
if name.strip() == '':
notify.info('name is empty')
return OTPLocalizer.NCTooShort
def printableChars(name):
for char in name:
if ord(char) < 128 and char not in string.printable:
notify.info('name contains non-printable char #%s' % ord(char))
return OTPLocalizer.NCGeneric
validAsciiChars = set(".,'-" + string.letters + string.whitespace)
def _validCharacter(c, validAsciiChars=validAsciiChars, font=font):
if c in validAsciiChars:
return True
if c.isalpha() or c.isspace():
return True
return False
def badCharacters(name, _validCharacter=_validCharacter):
for char in name:
if not _validCharacter(char):
if char in string.digits:
notify.info('name contains digits')
return OTPLocalizer.NCNoDigits
else:
notify.info('name contains bad char: %s' %
TextEncoder().encodeWtext(char))
return OTPLocalizer.NCBadCharacter % TextEncoder(
).encodeWtext(char)
def fontHasCharacters(name, font=font):
if font:
tn = TextNode('NameCheck')
tn.setFont(font)
for c in name:
# Define c as unicode
if not tn.hasCharacter(unichr(ord(c))):
notify.info('name contains bad char: %s' %
TextEncoder().encodeWtext(c))
return OTPLocalizer.NCBadCharacter % TextEncoder(
).encodeWtext(c)
def hasLetters(name):
words = wordList(name)
for word in words:
letters = justLetters(word)
if len(letters) == 0:
notify.info('word "%s" has no letters' %
TextEncoder().encodeWtext(word))
return OTPLocalizer.NCNeedLetters
def hasVowels(name):
def perWord(word):
if '.' in word:
return None
for char in word:
if ord(char) >= 128:
return None
letters = filterString(word, string.letters)
if len(letters) > 2:
vowels = filterString(letters, 'aeiouyAEIOUY')
if len(vowels) == 0:
notify.info('word "%s" has no vowels' %
TextEncoder().encodeWtext(word))
return OTPLocalizer.NCNeedVowels
return None
for word in wordList(name):
problem = perWord(word)
if problem:
return problem
def monoLetter(name):
def perWord(word):
word = word
letters = justLetters(word)
if len(letters) > 2:
letters = TextEncoder().decodeText(
TextEncoder.lower(TextEncoder().encodeWtext(letters)))
filtered = filterString(letters, letters[0])
if filtered == letters:
notify.info('word "%s" uses only one letter' %
TextEncoder().encodeWtext(word))
return OTPLocalizer.NCGeneric
for word in wordList(name):
problem = perWord(word)
if problem:
return problem
def checkDashes(name):
def validDash(index, name=name):
if index == 0 or i == len(name) - 1:
return 0
if not name[i - 1].isalpha():
return 0
if not name[i + 1].isalpha():
return 0
return 1
i = 0
while 1:
i = name.find('-', i, len(name))
if i < 0:
return None
if not validDash(i):
notify.info('name makes invalid use of dashes')
return OTPLocalizer.NCDashUsage
i += 1
def checkCommas(name):
def validComma(index, name=name):
if index == 0 or i == len(name) - 1:
return OTPLocalizer.NCCommaEdge
if name[i - 1].isspace():
return OTPLocalizer.NCCommaAfterWord
if not name[i + 1].isspace():
return OTPLocalizer.NCCommaUsage
return None
i = 0
while 1:
i = name.find(',', i, len(name))
if i < 0:
return None
problem = validComma(i)
if problem:
notify.info('name makes invalid use of commas')
return problem
i += 1
def checkPeriods(name):
words = wordList(name)
for word in words:
if word[-1] == ',':
word = word[:-1]
numPeriods = word.count('.')
if not numPeriods:
continue
letters = justLetters(word)
numLetters = len(letters)
if word[-1] != '.':
notify.info('word "%s" does not end in a period' %
TextEncoder().encodeWtext(word))
return OTPLocalizer.NCPeriodUsage
if numPeriods > 2:
notify.info('word "%s" has too many periods' %
TextEncoder().encodeWtext(word))
return OTPLocalizer.NCPeriodUsage
if numPeriods == 2:
if not (word[1] == '.' and word[3] == '.'):
notify.info('word "%s" does not fit the J.T. pattern' %
TextEncoder().encodeWtext(word))
return OTPLocalizer.NCPeriodUsage
return None
def checkApostrophes(name):
words = wordList(name)
for word in words:
numApos = word.count("'")
if numApos > 2:
notify.info('word "%s" has too many apostrophes.' %
TextEncoder().encodeWtext(word))
return OTPLocalizer.NCApostrophes
numApos = name.count("'")
if numApos > 3:
notify.info('name has too many apostrophes.')
return OTPLocalizer.NCApostrophes
def tooManyWords(name):
if len(wordList(name)) > 4:
notify.info('name has too many words')
return OTPLocalizer.NCTooManyWords
def allCaps(name):
letters = justLetters(name)
if len(letters) > 2:
upperLetters = TextEncoder().decodeText(
TextEncoder.upper(TextEncoder().encodeWtext(letters)))
for i in xrange(len(upperLetters)):
if not upperLetters[0].isupper():
return
if upperLetters == letters:
notify.info('name is all caps')
return OTPLocalizer.NCAllCaps
def mixedCase(name):
words = wordList(name)
for word in words:
if len(word) > 2:
capitals = justUpper(word)
if len(capitals) > 2:
notify.info('name has mixed case')
return OTPLocalizer.NCMixedCase
def checkJapanese(name):
asciiSpace = range(32, 33)
asciiDigits = range(48, 64)
hiragana = range(12353, 12448)
katakana = range(12449, 12544)
halfwidthKatakana = range(65381, 65440)
halfwidthCharacter = set(asciiSpace + halfwidthKatakana)
allowedUtf8 = set(asciiSpace + hiragana + katakana + halfwidthKatakana)
te = TextEncoder()
dc = 0.0
for char in (ord(char) for char in te.decodeText(name)):
if char not in allowedUtf8:
if char in asciiDigits:
notify.info('name contains not allowed ascii digits')
return OTPLocalizer.NCNoDigits
else:
notify.info('name contains not allowed utf8 char: 0x%04x' %
char)
return OTPLocalizer.NCBadCharacter % te.encodeWtext(
unichr(char))
elif char in halfwidthCharacter:
dc += 0.5
else:
dc += 1
if dc < 2:
notify.info('name is too short: %0.1f' % dc)
return OTPLocalizer.NCTooShort
elif dc > 8:
notify.info(
'name has been occupied more than eight display cells: %0.1f' %
dc)
return OTPLocalizer.NCGeneric
def repeatedChars(name):
count = 1
lastChar = None
i = 0
while i < len(name):
char = name[i]
i += 1
if char == lastChar:
count += 1
else:
count = 1
lastChar = char
if count > 2:
notify.info('character %s is repeated too many times' %
TextEncoder().encodeWtext(char))
return OTPLocalizer.NCRepeatedChar % TextEncoder().encodeWtext(
char)
return
checks = [
printableChars, badCharacters, fontHasCharacters, longEnough,
emptyName, hasLetters, hasVowels, monoLetter, checkDashes, checkCommas,
checkPeriods, checkApostrophes, tooManyWords, allCaps, mixedCase,
repeatedChars
] + otherCheckFuncs
symmetricChecks = []
name = TextEncoder().decodeText(name)
notify.info('checking name "%s"...' % TextEncoder().encodeWtext(name))
for check in checks:
problem = check(name[:])
if not problem and check in symmetricChecks:
nName = name[:]
bName.reverse()
problem = check(bName)
print 'problem = %s' % problem
if problem:
return problem
return None
