635 lines
26 KiB
Python
635 lines
26 KiB
Python
|
# coding=utf8
|
|||
|
|
#############################################################################
|
|||
|
|
##
|
|||
|
|
## Copyright (C) 2020 The Qt Company Ltd.
|
|||
|
|
## Contact: https://www.qt.io/licensing/
|
|||
|
|
##
|
|||
|
|
## This file is part of the test suite of the Qt Toolkit.
|
|||
|
|
##
|
|||
|
|
## $QT_BEGIN_LICENSE:GPL-EXCEPT$
|
|||
|
|
## Commercial License Usage
|
|||
|
|
## Licensees holding valid commercial Qt licenses may use this file in
|
|||
|
|
## accordance with the commercial license agreement provided with the
|
|||
|
|
## Software or, alternatively, in accordance with the terms contained in
|
|||
|
|
## a written agreement between you and The Qt Company. For licensing terms
|
|||
|
|
## and conditions see https://www.qt.io/terms-conditions. For further
|
|||
|
|
## information use the contact form at https://www.qt.io/contact-us.
|
|||
|
|
##
|
|||
|
|
## GNU General Public License Usage
|
|||
|
|
## Alternatively, this file may be used under the terms of the GNU
|
|||
|
|
## General Public License version 3 as published by the Free Software
|
|||
|
|
## Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
|
|||
|
|
## included in the packaging of this file. Please review the following
|
|||
|
|
## information to ensure the GNU General Public License requirements will
|
|||
|
|
## be met: https://www.gnu.org/licenses/gpl-3.0.html.
|
|||
|
|
##
|
|||
|
|
## $QT_END_LICENSE$
|
|||
|
|
##
|
|||
|
|
#############################################################################
|
|||
|
|
"""Shared serialization-scanning code for QLocaleXML format.
|
|||
|
|
|
|||
|
|
Provides classes:
|
|||
|
|
Locale -- common data-type representing one locale as a namespace
|
|||
|
|
QLocaleXmlWriter -- helper to write a QLocaleXML file
|
|||
|
|
QLocaleXmlReader -- helper to read a QLocaleXML file back in
|
|||
|
|
|
|||
|
|
Support:
|
|||
|
|
Spacer -- provides control over indentation of the output.
|
|||
|
|
"""
|
|||
|
|
from __future__ import print_function
|
|||
|
|
from xml.sax.saxutils import escape
|
|||
|
|
|
|||
|
|
from localetools import Error
|
|||
|
|
|
|||
|
|
# Tools used by Locale:
|
|||
|
|
def camel(seq):
|
|||
|
|
yield seq.next()
|
|||
|
|
for word in seq:
|
|||
|
|
yield word.capitalize()
|
|||
|
|
|
|||
|
|
def camelCase(words):
|
|||
|
|
return ''.join(camel(iter(words)))
|
|||
|
|
|
|||
|
|
def addEscapes(s):
|
|||
|
|
return ''.join(c if n < 128 else '\\x{:02x}'.format(n)
|
|||
|
|
for n, c in ((ord(c), c) for c in s))
|
|||
|
|
|
|||
|
|
def ordStr(c):
|
|||
|
|
if len(c) == 1:
|
|||
|
|
return str(ord(c))
|
|||
|
|
raise Error('Unable to handle value "{}"'.format(addEscapes(c)))
|
|||
|
|
|
|||
|
|
# Fix for a problem with QLocale returning a character instead of
|
|||
|
|
# strings for QLocale::exponential() and others. So we fallback to
|
|||
|
|
# default values in these cases.
|
|||
|
|
def fixOrdStr(c, d):
|
|||
|
|
return str(ord(c if len(c) == 1 else d))
|
|||
|
|
|
|||
|
|
def startCount(c, text): # strspn
|
|||
|
|
"""First index in text where it doesn't have a character in c"""
|
|||
|
|
assert text and text[0] in c
|
|||
|
|
try:
|
|||
|
|
return (j for j, d in enumerate(text) if d not in c).next()
|
|||
|
|
except StopIteration:
|
|||
|
|
return len(text)
|
|||
|
|
|
|||
|
|
def convertFormat(format):
|
|||
|
|
"""Convert date/time format-specier from CLDR to Qt
|
|||
|
|
|
|||
|
|
Match up (as best we can) the differences between:
|
|||
|
|
* https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table
|
|||
|
|
* QDateTimeParser::parseFormat() and QLocalePrivate::dateTimeToString()
|
|||
|
|
"""
|
|||
|
|
# Compare and contrast dateconverter.py's convert_date().
|
|||
|
|
# Need to (check consistency and) reduce redundancy !
|
|||
|
|
result = ""
|
|||
|
|
i = 0
|
|||
|
|
while i < len(format):
|
|||
|
|
if format[i] == "'":
|
|||
|
|
result += "'"
|
|||
|
|
i += 1
|
|||
|
|
while i < len(format) and format[i] != "'":
|
|||
|
|
result += format[i]
|
|||
|
|
i += 1
|
|||
|
|
if i < len(format):
|
|||
|
|
result += "'"
|
|||
|
|
i += 1
|
|||
|
|
else:
|
|||
|
|
s = format[i:]
|
|||
|
|
if s.startswith('E'): # week-day
|
|||
|
|
n = startCount('E', s)
|
|||
|
|
if n < 3:
|
|||
|
|
result += 'ddd'
|
|||
|
|
elif n == 4:
|
|||
|
|
result += 'dddd'
|
|||
|
|
else: # 5: narrow, 6 short; but should be name, not number :-(
|
|||
|
|
result += 'd' if n < 6 else 'dd'
|
|||
|
|
i += n
|
|||
|
|
elif s[0] in 'ab': # am/pm
|
|||
|
|
# 'b' should distinguish noon/midnight, too :-(
|
|||
|
|
result += "AP"
|
|||
|
|
i += startCount('ab', s)
|
|||
|
|
elif s.startswith('S'): # fractions of seconds: count('S') == number of decimals to show
|
|||
|
|
result += 'z'
|
|||
|
|
i += startCount('S', s)
|
|||
|
|
elif s.startswith('V'): # long time zone specifiers (and a deprecated short ID)
|
|||
|
|
result += 't'
|
|||
|
|
i += startCount('V', s)
|
|||
|
|
elif s[0] in 'zv': # zone
|
|||
|
|
# Should use full name, e.g. "Central European Time", if 'zzzz' :-(
|
|||
|
|
# 'v' should get generic non-location format, e.g. PT for "Pacific Time", no DST indicator
|
|||
|
|
result += "t"
|
|||
|
|
i += startCount('zv', s)
|
|||
|
|
else:
|
|||
|
|
result += format[i]
|
|||
|
|
i += 1
|
|||
|
|
|
|||
|
|
return result
|
|||
|
|
|
|||
|
|
class QLocaleXmlReader (object):
|
|||
|
|
def __init__(self, filename):
|
|||
|
|
self.root = self.__parse(filename)
|
|||
|
|
# Lists of (id, name, code) triples:
|
|||
|
|
languages = tuple(self.__loadMap('language'))
|
|||
|
|
scripts = tuple(self.__loadMap('script'))
|
|||
|
|
countries = tuple(self.__loadMap('country'))
|
|||
|
|
self.__likely = tuple(self.__likelySubtagsMap())
|
|||
|
|
# Mappings {ID: (name, code)}
|
|||
|
|
self.languages = dict((v[0], v[1:]) for v in languages)
|
|||
|
|
self.scripts = dict((v[0], v[1:]) for v in scripts)
|
|||
|
|
self.countries = dict((v[0], v[1:]) for v in countries)
|
|||
|
|
# Private mappings {name: (ID, code)}
|
|||
|
|
self.__langByName = dict((v[1], (v[0], v[2])) for v in languages)
|
|||
|
|
self.__textByName = dict((v[1], (v[0], v[2])) for v in scripts)
|
|||
|
|
self.__landByName = dict((v[1], (v[0], v[2])) for v in countries)
|
|||
|
|
# Other properties:
|
|||
|
|
self.dupes = set(v[1] for v in languages) & set(v[1] for v in countries)
|
|||
|
|
self.cldrVersion = self.__firstChildText(self.root, "version")
|
|||
|
|
|
|||
|
|
def loadLocaleMap(self, calendars, grumble = lambda text: None):
|
|||
|
|
kid = self.__firstChildText
|
|||
|
|
likely = dict(self.__likely)
|
|||
|
|
for elt in self.__eachEltInGroup(self.root, 'localeList', 'locale'):
|
|||
|
|
locale = Locale.fromXmlData(lambda k: kid(elt, k), calendars)
|
|||
|
|
language = self.__langByName[locale.language][0]
|
|||
|
|
script = self.__textByName[locale.script][0]
|
|||
|
|
country = self.__landByName[locale.country][0]
|
|||
|
|
|
|||
|
|
if language != 1: # C
|
|||
|
|
if country == 0:
|
|||
|
|
grumble('loadLocaleMap: No country id for "{}"\n'.format(locale.language))
|
|||
|
|
|
|||
|
|
if script == 0:
|
|||
|
|
# Find default script for the given language and country - see:
|
|||
|
|
# http://www.unicode.org/reports/tr35/#Likely_Subtags
|
|||
|
|
try:
|
|||
|
|
try:
|
|||
|
|
to = likely[(locale.language, 'AnyScript', locale.country)]
|
|||
|
|
except KeyError:
|
|||
|
|
to = likely[(locale.language, 'AnyScript', 'AnyCountry')]
|
|||
|
|
except KeyError:
|
|||
|
|
pass
|
|||
|
|
else:
|
|||
|
|
locale.script = to[1]
|
|||
|
|
script = self.__textByName[locale.script][0]
|
|||
|
|
|
|||
|
|
yield (language, script, country), locale
|
|||
|
|
|
|||
|
|
def languageIndices(self, locales):
|
|||
|
|
index = 0
|
|||
|
|
for key, value in self.languages.iteritems():
|
|||
|
|
i, count = 0, locales.count(key)
|
|||
|
|
if count > 0:
|
|||
|
|
i = index
|
|||
|
|
index += count
|
|||
|
|
yield i, value[0]
|
|||
|
|
|
|||
|
|
def likelyMap(self):
|
|||
|
|
def tag(t):
|
|||
|
|
lang, script, land = t
|
|||
|
|
yield lang[1] if lang[0] else 'und'
|
|||
|
|
if script[0]: yield script[1]
|
|||
|
|
if land[0]: yield land[1]
|
|||
|
|
|
|||
|
|
def ids(t):
|
|||
|
|
return tuple(x[0] for x in t)
|
|||
|
|
|
|||
|
|
for i, pair in enumerate(self.__likely, 1):
|
|||
|
|
have = self.__fromNames(pair[0])
|
|||
|
|
give = self.__fromNames(pair[1])
|
|||
|
|
yield ('_'.join(tag(have)), ids(have),
|
|||
|
|
'_'.join(tag(give)), ids(give),
|
|||
|
|
i == len(self.__likely))
|
|||
|
|
|
|||
|
|
def defaultMap(self):
|
|||
|
|
"""Map language and script to their default country by ID.
|
|||
|
|
|
|||
|
|
Yields ((language, script), country) wherever the likely
|
|||
|
|
sub-tags mapping says language's default locale uses the given
|
|||
|
|
script and country."""
|
|||
|
|
for have, give in self.__likely:
|
|||
|
|
if have[1:] == ('AnyScript', 'AnyCountry') and give[2] != 'AnyCountry':
|
|||
|
|
assert have[0] == give[0], (have, give)
|
|||
|
|
yield ((self.__langByName[give[0]][0],
|
|||
|
|
self.__textByName[give[1]][0]),
|
|||
|
|
self.__landByName[give[2]][0])
|
|||
|
|
|
|||
|
|
# Implementation details:
|
|||
|
|
def __loadMap(self, category):
|
|||
|
|
kid = self.__firstChildText
|
|||
|
|
for element in self.__eachEltInGroup(self.root, category + 'List', category):
|
|||
|
|
yield int(kid(element, 'id')), kid(element, 'name'), kid(element, 'code')
|
|||
|
|
|
|||
|
|
def __likelySubtagsMap(self):
|
|||
|
|
def triplet(element, keys=('language', 'script', 'country'), kid = self.__firstChildText):
|
|||
|
|
return tuple(kid(element, key) for key in keys)
|
|||
|
|
|
|||
|
|
kid = self.__firstChildElt
|
|||
|
|
for elt in self.__eachEltInGroup(self.root, 'likelySubtags', 'likelySubtag'):
|
|||
|
|
yield triplet(kid(elt, "from")), triplet(kid(elt, "to"))
|
|||
|
|
|
|||
|
|
def __fromNames(self, names):
|
|||
|
|
return self.__langByName[names[0]], self.__textByName[names[1]], self.__landByName[names[2]]
|
|||
|
|
|
|||
|
|
# DOM access:
|
|||
|
|
from xml.dom import minidom
|
|||
|
|
@staticmethod
|
|||
|
|
def __parse(filename, read = minidom.parse):
|
|||
|
|
return read(filename).documentElement
|
|||
|
|
|
|||
|
|
@staticmethod
|
|||
|
|
def __isNodeNamed(elt, name, TYPE=minidom.Node.ELEMENT_NODE):
|
|||
|
|
return elt.nodeType == TYPE and elt.nodeName == name
|
|||
|
|
del minidom
|
|||
|
|
|
|||
|
|
@staticmethod
|
|||
|
|
def __eltWords(elt):
|
|||
|
|
child = elt.firstChild
|
|||
|
|
while child:
|
|||
|
|
if child.nodeType == elt.TEXT_NODE:
|
|||
|
|
yield child.nodeValue
|
|||
|
|
child = child.nextSibling
|
|||
|
|
|
|||
|
|
@classmethod
|
|||
|
|
def __firstChildElt(cls, parent, name):
|
|||
|
|
child = parent.firstChild
|
|||
|
|
while child:
|
|||
|
|
if cls.__isNodeNamed(child, name):
|
|||
|
|
return child
|
|||
|
|
child = child.nextSibling
|
|||
|
|
|
|||
|
|
raise Error('No {} child found'.format(name))
|
|||
|
|
|
|||
|
|
@classmethod
|
|||
|
|
def __firstChildText(cls, elt, key):
|
|||
|
|
return ' '.join(cls.__eltWords(cls.__firstChildElt(elt, key)))
|
|||
|
|
|
|||
|
|
@classmethod
|
|||
|
|
def __eachEltInGroup(cls, parent, group, key):
|
|||
|
|
try:
|
|||
|
|
element = cls.__firstChildElt(parent, group).firstChild
|
|||
|
|
except Error:
|
|||
|
|
element = None
|
|||
|
|
|
|||
|
|
while element:
|
|||
|
|
if cls.__isNodeNamed(element, key):
|
|||
|
|
yield element
|
|||
|
|
element = element.nextSibling
|
|||
|
|
|
|||
|
|
|
|||
|
|
class Spacer (object):
|
|||
|
|
def __init__(self, indent = None, initial = ''):
|
|||
|
|
"""Prepare to manage indentation and line breaks.
|
|||
|
|
|
|||
|
|
Arguments are both optional.
|
|||
|
|
|
|||
|
|
First argument, indent, is either None (its default, for
|
|||
|
|
'minifying'), an ingeter (number of spaces) or the unit of
|
|||
|
|
text that is to be used for each indentation level (e.g. '\t'
|
|||
|
|
to use tabs). If indent is None, no indentation is added, nor
|
|||
|
|
are line-breaks; otherwise, self(text), for non-empty text,
|
|||
|
|
shall end with a newline and begin with indentation.
|
|||
|
|
|
|||
|
|
Second argument, initial, is the initial indentation; it is
|
|||
|
|
ignored if indent is None. Indentation increases after each
|
|||
|
|
call to self(text) in which text starts with a tag and doesn't
|
|||
|
|
include its end-tag; indentation decreases if text starts with
|
|||
|
|
an end-tag. The text is not parsed any more carefully than
|
|||
|
|
just described.
|
|||
|
|
"""
|
|||
|
|
if indent is None:
|
|||
|
|
self.__call = lambda x: x
|
|||
|
|
else:
|
|||
|
|
self.__each = ' ' * indent if isinstance(indent, int) else indent
|
|||
|
|
self.current = initial
|
|||
|
|
self.__call = self.__wrap
|
|||
|
|
|
|||
|
|
def __wrap(self, line):
|
|||
|
|
if not line:
|
|||
|
|
return '\n'
|
|||
|
|
|
|||
|
|
indent = self.current
|
|||
|
|
if line.startswith('</'):
|
|||
|
|
indent = self.current = indent[:-len(self.__each)]
|
|||
|
|
elif line.startswith('<') and not line.startswith('<!'):
|
|||
|
|
cut = line.find('>')
|
|||
|
|
tag = (line[1:] if cut < 0 else line[1 : cut]).strip().split()[0]
|
|||
|
|
if '</{}>'.format(tag) not in line:
|
|||
|
|
self.current += self.__each
|
|||
|
|
return indent + line + '\n'
|
|||
|
|
|
|||
|
|
def __call__(self, line):
|
|||
|
|
return self.__call(line)
|
|||
|
|
|
|||
|
|
class QLocaleXmlWriter (object):
|
|||
|
|
def __init__(self, save = None, space = Spacer(4)):
|
|||
|
|
"""Set up to write digested CLDR data as QLocale XML.
|
|||
|
|
|
|||
|
|
Arguments are both optional.
|
|||
|
|
|
|||
|
|
First argument, save, is None (its default) or a callable that
|
|||
|
|
will write content to where you intend to save it. If None, it
|
|||
|
|
is replaced with a callable that prints the given content,
|
|||
|
|
suppressing the newline (but see the following); this is
|
|||
|
|
equivalent to passing sys.stdout.write.
|
|||
|
|
|
|||
|
|
Second argument, space, is an object to call on each text
|
|||
|
|
output to prepend indentation and append newlines, or not as
|
|||
|
|
the case may be. The default is a Spacer(4), which grows
|
|||
|
|
indent by four spaces after each unmatched new tag and shrinks
|
|||
|
|
back on a close-tag (its parsing is naive, but adequate to how
|
|||
|
|
this class uses it), while adding a newline to each line.
|
|||
|
|
"""
|
|||
|
|
self.__rawOutput = self.__printit if save is None else save
|
|||
|
|
self.__wrap = space
|
|||
|
|
self.__write('<localeDatabase>')
|
|||
|
|
|
|||
|
|
# Output of various sections, in their usual order:
|
|||
|
|
def enumData(self, languages, scripts, countries):
|
|||
|
|
self.__enumTable('languageList', languages)
|
|||
|
|
self.__enumTable('scriptList', scripts)
|
|||
|
|
self.__enumTable('countryList', countries)
|
|||
|
|
|
|||
|
|
def likelySubTags(self, entries):
|
|||
|
|
self.__openTag('likelySubtags')
|
|||
|
|
for have, give in entries:
|
|||
|
|
self.__openTag('likelySubtag')
|
|||
|
|
self.__likelySubTag('from', have)
|
|||
|
|
self.__likelySubTag('to', give)
|
|||
|
|
self.__closeTag('likelySubtag')
|
|||
|
|
self.__closeTag('likelySubtags')
|
|||
|
|
|
|||
|
|
def locales(self, locales, calendars):
|
|||
|
|
self.__openTag('localeList')
|
|||
|
|
self.__openTag('locale')
|
|||
|
|
Locale.C(calendars).toXml(self.inTag, calendars)
|
|||
|
|
self.__closeTag('locale')
|
|||
|
|
keys = locales.keys()
|
|||
|
|
keys.sort()
|
|||
|
|
for key in keys:
|
|||
|
|
self.__openTag('locale')
|
|||
|
|
locales[key].toXml(self.inTag, calendars)
|
|||
|
|
self.__closeTag('locale')
|
|||
|
|
self.__closeTag('localeList')
|
|||
|
|
|
|||
|
|
def version(self, cldrVersion):
|
|||
|
|
self.inTag('version', cldrVersion)
|
|||
|
|
|
|||
|
|
def inTag(self, tag, text):
|
|||
|
|
self.__write('<{0}>{1}</{0}>'.format(tag, text))
|
|||
|
|
|
|||
|
|
def close(self):
|
|||
|
|
if self.__rawOutput != self.__complain:
|
|||
|
|
self.__write('</localeDatabase>')
|
|||
|
|
self.__rawOutput = self.__complain
|
|||
|
|
|
|||
|
|
# Implementation details
|
|||
|
|
@staticmethod
|
|||
|
|
def __printit(text):
|
|||
|
|
print(text, end='')
|
|||
|
|
@staticmethod
|
|||
|
|
def __complain(text):
|
|||
|
|
raise Error('Attempted to write data after closing :-(')
|
|||
|
|
|
|||
|
|
def __enumTable(self, tag, table):
|
|||
|
|
self.__openTag(tag)
|
|||
|
|
for key, value in table.iteritems():
|
|||
|
|
self.__openTag(tag[:-4])
|
|||
|
|
self.inTag('name', value[0])
|
|||
|
|
self.inTag('id', key)
|
|||
|
|
self.inTag('code', value[1])
|
|||
|
|
self.__closeTag(tag[:-4])
|
|||
|
|
self.__closeTag(tag)
|
|||
|
|
|
|||
|
|
def __likelySubTag(self, tag, likely):
|
|||
|
|
self.__openTag(tag)
|
|||
|
|
self.inTag('language', likely[0])
|
|||
|
|
self.inTag('script', likely[1])
|
|||
|
|
self.inTag('country', likely[2])
|
|||
|
|
# self.inTag('variant', likely[3])
|
|||
|
|
self.__closeTag(tag)
|
|||
|
|
|
|||
|
|
def __openTag(self, tag):
|
|||
|
|
self.__write('<{}>'.format(tag))
|
|||
|
|
def __closeTag(self, tag):
|
|||
|
|
self.__write('</{}>'.format(tag))
|
|||
|
|
|
|||
|
|
def __write(self, line):
|
|||
|
|
self.__rawOutput(self.__wrap(line))
|
|||
|
|
|
|||
|
|
class Locale (object):
|
|||
|
|
"""Holder for the assorted data representing one locale.
|
|||
|
|
|
|||
|
|
Implemented as a namespace; its constructor and update() have the
|
|||
|
|
same signatures as those of a dict, acting on the instance's
|
|||
|
|
__dict__, so the results are accessed as attributes rather than
|
|||
|
|
mapping keys."""
|
|||
|
|
def __init__(self, data=None, **kw):
|
|||
|
|
self.update(data, **kw)
|
|||
|
|
|
|||
|
|
def update(self, data=None, **kw):
|
|||
|
|
if data: self.__dict__.update(data)
|
|||
|
|
if kw: self.__dict__.update(kw)
|
|||
|
|
|
|||
|
|
def __len__(self): # Used when testing as a boolean
|
|||
|
|
return len(self.__dict__)
|
|||
|
|
|
|||
|
|
@staticmethod
|
|||
|
|
def propsMonthDay(scale, lengths=('long', 'short', 'narrow')):
|
|||
|
|
for L in lengths:
|
|||
|
|
yield camelCase((L, scale))
|
|||
|
|
yield camelCase(('standalone', L, scale))
|
|||
|
|
|
|||
|
|
# Expected to be numbers, read with int():
|
|||
|
|
__asint = ("decimal", "group", "zero",
|
|||
|
|
"list", "percent", "minus", "plus", "exp",
|
|||
|
|
"currencyDigits", "currencyRounding")
|
|||
|
|
# Single character; use the code-point number for each:
|
|||
|
|
__asord = ("quotationStart", "quotationEnd",
|
|||
|
|
"alternateQuotationStart", "alternateQuotationEnd")
|
|||
|
|
# Convert day-name to Qt day-of-week number:
|
|||
|
|
__asdow = ("firstDayOfWeek", "weekendStart", "weekendEnd")
|
|||
|
|
# Convert from CLDR format-strings to QDateTimeParser ones:
|
|||
|
|
__asfmt = ("longDateFormat", "shortDateFormat", "longTimeFormat", "shortTimeFormat")
|
|||
|
|
# Just use the raw text:
|
|||
|
|
__astxt = ("language", "languageEndonym", "script", "country", "countryEndonym",
|
|||
|
|
"listPatternPartStart", "listPatternPartMiddle",
|
|||
|
|
"listPatternPartEnd", "listPatternPartTwo", "am", "pm",
|
|||
|
|
'byte_unit', 'byte_si_quantified', 'byte_iec_quantified',
|
|||
|
|
"currencyIsoCode", "currencySymbol", "currencyDisplayName",
|
|||
|
|
"currencyFormat", "currencyNegativeFormat")
|
|||
|
|
|
|||
|
|
# Day-of-Week numbering used by Qt:
|
|||
|
|
__qDoW = {"mon": 1, "tue": 2, "wed": 3, "thu": 4, "fri": 5, "sat": 6, "sun": 7}
|
|||
|
|
|
|||
|
|
@classmethod
|
|||
|
|
def fromXmlData(cls, lookup, calendars=('gregorian',)):
|
|||
|
|
"""Constructor from the contents of XML elements.
|
|||
|
|
|
|||
|
|
Single parameter, lookup, is called with the names of XML
|
|||
|
|
elements that should contain the relevant data, within a CLDR
|
|||
|
|
locale element (within a localeList element); these names are
|
|||
|
|
used for the attributes of the object constructed. Attribute
|
|||
|
|
values are obtained by suitably digesting the returned element
|
|||
|
|
texts.\n"""
|
|||
|
|
data = {}
|
|||
|
|
for k in cls.__asint:
|
|||
|
|
data['listDelim' if k == 'list' else k] = int(lookup(k))
|
|||
|
|
|
|||
|
|
for k in cls.__asord:
|
|||
|
|
value = lookup(k)
|
|||
|
|
assert len(value) == 1, \
|
|||
|
|
(k, value, 'value should be exactly one character')
|
|||
|
|
data[k] = ord(value)
|
|||
|
|
|
|||
|
|
for k in cls.__asdow:
|
|||
|
|
data[k] = cls.__qDoW[lookup(k)]
|
|||
|
|
|
|||
|
|
for k in cls.__asfmt:
|
|||
|
|
data[k] = convertFormat(lookup(k))
|
|||
|
|
|
|||
|
|
for k in cls.__astxt + tuple(cls.propsMonthDay('days')):
|
|||
|
|
data[k] = lookup(k)
|
|||
|
|
|
|||
|
|
for k in cls.propsMonthDay('months'):
|
|||
|
|
data[k] = dict((cal, lookup('_'.join((k, cal)))) for cal in calendars)
|
|||
|
|
|
|||
|
|
return cls(data)
|
|||
|
|
|
|||
|
|
def toXml(self, write, calendars=('gregorian',)):
|
|||
|
|
"""Writes its data as QLocale XML.
|
|||
|
|
|
|||
|
|
First argument, write, is a callable taking the name and
|
|||
|
|
content of an XML element; it is expected to be the inTag
|
|||
|
|
bound method of a QLocaleXmlWriter instance.
|
|||
|
|
|
|||
|
|
Optional second argument is a list of calendar names, in the
|
|||
|
|
form used by CLDR; its default is ('gregorian',).
|
|||
|
|
"""
|
|||
|
|
get = lambda k: getattr(self, k)
|
|||
|
|
for key in ('language', 'script', 'country'):
|
|||
|
|
write(key, get(key))
|
|||
|
|
write('{}code'.format(key), get('{}_code'.format(key)))
|
|||
|
|
|
|||
|
|
for key in ('decimal', 'group', 'zero'):
|
|||
|
|
write(key, ordStr(get(key)))
|
|||
|
|
for key, std in (('list', ';'), ('percent', '%'),
|
|||
|
|
('minus', '-'), ('plus', '+'), ('exp', 'e')):
|
|||
|
|
write(key, fixOrdStr(get(key), std))
|
|||
|
|
|
|||
|
|
for key in ('languageEndonym', 'countryEndonym',
|
|||
|
|
'quotationStart', 'quotationEnd',
|
|||
|
|
'alternateQuotationStart', 'alternateQuotationEnd',
|
|||
|
|
'listPatternPartStart', 'listPatternPartMiddle',
|
|||
|
|
'listPatternPartEnd', 'listPatternPartTwo',
|
|||
|
|
'byte_unit', 'byte_si_quantified', 'byte_iec_quantified',
|
|||
|
|
'am', 'pm', 'firstDayOfWeek',
|
|||
|
|
'weekendStart', 'weekendEnd',
|
|||
|
|
'longDateFormat', 'shortDateFormat',
|
|||
|
|
'longTimeFormat', 'shortTimeFormat',
|
|||
|
|
'currencyIsoCode', 'currencySymbol', 'currencyDisplayName',
|
|||
|
|
'currencyFormat', 'currencyNegativeFormat'
|
|||
|
|
) + tuple(self.propsMonthDay('days')) + tuple(
|
|||
|
|
'_'.join((k, cal))
|
|||
|
|
for k in self.propsMonthDay('months')
|
|||
|
|
for cal in calendars):
|
|||
|
|
write(key, escape(get(key)).encode('utf-8'))
|
|||
|
|
|
|||
|
|
for key in ('currencyDigits', 'currencyRounding'):
|
|||
|
|
write(key, get(key))
|
|||
|
|
|
|||
|
|
# Tools used by __monthNames:
|
|||
|
|
def fullName(i, name): return name
|
|||
|
|
def firstThree(i, name): return name[:3]
|
|||
|
|
def initial(i, name): return name[:1]
|
|||
|
|
def number(i, name): return str(i + 1)
|
|||
|
|
def islamicShort(i, name):
|
|||
|
|
if not name: return name
|
|||
|
|
if name == 'Shawwal': return 'Shaw.'
|
|||
|
|
words = name.split()
|
|||
|
|
if words[0].startswith('Dhu'):
|
|||
|
|
words[0] = words[0][:7] + '.'
|
|||
|
|
elif len(words[0]) > 3:
|
|||
|
|
words[0] = words[0][:3] + '.'
|
|||
|
|
return ' '.join(words)
|
|||
|
|
@staticmethod
|
|||
|
|
def __monthNames(calendars,
|
|||
|
|
known={ # Map calendar to (names, extractors...):
|
|||
|
|
# TODO: do we even need these ? CLDR's root.xml seems to
|
|||
|
|
# have them, complete with yeartype="leap" handling for
|
|||
|
|
# Hebrew's extra.
|
|||
|
|
'gregorian': (('January', 'February', 'March', 'April', 'May', 'June', 'July',
|
|||
|
|
'August', 'September', 'October', 'November', 'December'),
|
|||
|
|
# Extractor pairs, (plain, standalone)
|
|||
|
|
(fullName, fullName), # long
|
|||
|
|
(firstThree, firstThree), # short
|
|||
|
|
(number, initial)), # narrow
|
|||
|
|
'persian': (('Farvardin', 'Ordibehesht', 'Khordad', 'Tir', 'Mordad',
|
|||
|
|
'Shahrivar', 'Mehr', 'Aban', 'Azar', 'Dey', 'Bahman', 'Esfand'),
|
|||
|
|
(fullName, fullName),
|
|||
|
|
(firstThree, firstThree),
|
|||
|
|
(number, initial)),
|
|||
|
|
'islamic': ((u'Muharram', u'Safar', u'Rabiʻ I', u'Rabiʻ II', u'Jumada I',
|
|||
|
|
u'Jumada II', u'Rajab', u'Shaʻban', u'Ramadan', u'Shawwal',
|
|||
|
|
u'Dhuʻl-Qiʻdah', u'Dhuʻl-Hijjah'),
|
|||
|
|
(fullName, fullName),
|
|||
|
|
(islamicShort, islamicShort),
|
|||
|
|
(number, number)),
|
|||
|
|
'hebrew': (('Tishri', 'Heshvan', 'Kislev', 'Tevet', 'Shevat', 'Adar I',
|
|||
|
|
'Adar', 'Nisan', 'Iyar', 'Sivan', 'Tamuz', 'Av'),
|
|||
|
|
(fullName, fullName),
|
|||
|
|
(fullName, fullName),
|
|||
|
|
(number, number)),
|
|||
|
|
},
|
|||
|
|
sizes=('long', 'short', 'narrow')):
|
|||
|
|
for cal in calendars:
|
|||
|
|
try:
|
|||
|
|
data = known[cal]
|
|||
|
|
except KeyError as e: # Need to add an entry to known, above.
|
|||
|
|
e.args += ('Unsupported calendar:', cal)
|
|||
|
|
raise
|
|||
|
|
names, get = data[0] + ('',), data[1:]
|
|||
|
|
for n, size in enumerate(sizes):
|
|||
|
|
yield ('_'.join((camelCase((size, 'months')), cal)),
|
|||
|
|
';'.join(get[n][0](i, x) for i, x in enumerate(names)))
|
|||
|
|
yield ('_'.join((camelCase(('standalone', size, 'months')), cal)),
|
|||
|
|
';'.join(get[n][1](i, x) for i, x in enumerate(names)))
|
|||
|
|
del fullName, firstThree, initial, number, islamicShort
|
|||
|
|
|
|||
|
|
@classmethod
|
|||
|
|
def C(cls, calendars=('gregorian',),
|
|||
|
|
# Empty entry at end to ensure final separator when join()ed:
|
|||
|
|
days = ('Sunday', 'Monday', 'Tuesday', 'Wednesday',
|
|||
|
|
'Thursday', 'Friday', 'Saturday', ''),
|
|||
|
|
quantifiers=('k', 'M', 'G', 'T', 'P', 'E')):
|
|||
|
|
"""Returns an object representing the C locale."""
|
|||
|
|
return cls(cls.__monthNames(calendars),
|
|||
|
|
language='C', language_code='0', languageEndonym='',
|
|||
|
|
script='AnyScript', script_code='0',
|
|||
|
|
country='AnyCountry', country_code='0', countryEndonym='',
|
|||
|
|
decimal='.', group=',', list=';', percent='%',
|
|||
|
|
zero='0', minus='-', plus='+', exp='e',
|
|||
|
|
quotationStart='"', quotationEnd='"',
|
|||
|
|
alternateQuotationStart='\'', alternateQuotationEnd='\'',
|
|||
|
|
listPatternPartStart='%1, %2',
|
|||
|
|
listPatternPartMiddle='%1, %2',
|
|||
|
|
listPatternPartEnd='%1, %2',
|
|||
|
|
listPatternPartTwo='%1, %2',
|
|||
|
|
byte_unit='bytes',
|
|||
|
|
byte_si_quantified=';'.join(q + 'B' for q in quantifiers),
|
|||
|
|
byte_iec_quantified=';'.join(q.upper() + 'iB' for q in quantifiers),
|
|||
|
|
am='AM', pm='PM', firstDayOfWeek='mon',
|
|||
|
|
weekendStart='sat', weekendEnd='sun',
|
|||
|
|
longDateFormat='EEEE, d MMMM yyyy', shortDateFormat='d MMM yyyy',
|
|||
|
|
longTimeFormat='HH:mm:ss z', shortTimeFormat='HH:mm:ss',
|
|||
|
|
longDays=';'.join(days),
|
|||
|
|
shortDays=';'.join(d[:3] for d in days),
|
|||
|
|
narrowDays='7;1;2;3;4;5;6;',
|
|||
|
|
standaloneLongDays=';'.join(days),
|
|||
|
|
standaloneShortDays=';'.join(d[:3] for d in days),
|
|||
|
|
standaloneNarrowDays=';'.join(d[:1] for d in days),
|
|||
|
|
currencyIsoCode='', currencySymbol='',
|
|||
|
|
currencyDisplayName=';' * 7,
|
|||
|
|
currencyDigits=2, currencyRounding=1,
|
|||
|
|
currencyFormat='%1%2', currencyNegativeFormat='')
|