qtbase/util/locale_database/qlocalexml.py

# Copyright (C) 2021 The Qt Company Ltd.
# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
"""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.

RelaxNG schema for the used file format can be found in qlocalexml.rnc.
QLocaleXML files can be validated using:

    jing -c qlocalexml.rnc <file.xml>

You can download jing from https://relaxng.org/jclark/jing.html if your
package manager lacks the jing package.
"""

from xml.sax.saxutils import escape

from localetools import Error, qtVersion

# Tools used by Locale:
def camel(seq):
    yield next(seq)
    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 f'\\x{n:02x}'
                   for n, c in ((ord(c), c) for c in s))

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 next((j for j, d in enumerate(text) if d not in c))
    except StopIteration:
        return len(text)

class QLocaleXmlReader (object):
    def __init__(self, filename):
        self.root = self.__parse(filename)

        from enumdata import language_map, script_map, territory_map
        # Lists of (id, enum name, code, en.xml name) tuples:
        languages = tuple(self.__loadMap('language', language_map))
        scripts = tuple(self.__loadMap('script', script_map))
        territories = tuple(self.__loadMap('territory', territory_map))
        self.__likely = tuple(self.__likelySubtagsMap()) # in enum name form

        # Mappings {ID: (enum name, code, en.xml name)}
        self.languages = {v[0]: v[1:] for v in languages}
        self.scripts = {v[0]: v[1:] for v in scripts}
        self.territories = {v[0]: v[1:] for v in territories}

        # Private mappings {enum name: (ID, code)}
        self.__langByName = {v[1]: (v[0], v[2]) for v in languages}
        self.__textByName = {v[1]: (v[0], v[2]) for v in scripts}
        self.__landByName = {v[1]: (v[0], v[2]) for v in territories}
        # Other properties:
        self.__dupes = set(v[1] for v in languages) & set(v[1] for v in territories)

        self.cldrVersion = self.root.attributes['versionCldr'].nodeValue
        self.qtVersion = self.root.attributes['versionQt'].nodeValue
        assert self.qtVersion == qtVersion, (
            'Using QLocaleXml file from incompatible Qt version',
            self.qtVersion, qtVersion
        )

    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]
            territory = self.__landByName[locale.territory][0]

            if language != 1: # C
                if territory == 0:
                    grumble(f'loadLocaleMap: No territory id for "{locale.language}"\n')

                if script == 0:
                    # Find default script for the given language and territory - see:
                    # http://www.unicode.org/reports/tr35/#Likely_Subtags
                    try:
                        try:
                            to = likely[(locale.language, 'AnyScript', locale.territory)]
                        except KeyError:
                            to = likely[(locale.language, 'AnyScript', 'AnyTerritory')]
                    except KeyError:
                        pass
                    else:
                        locale.script = to[1]
                        script = self.__textByName[locale.script][0]

            yield (language, script, territory), locale

    def aliasToIana(self):
        kid = self.__firstChildText
        for elt in self.__eachEltInGroup(self.root, 'zoneAliases', 'zoneAlias'):
            yield kid(elt, 'alias'), kid(elt, 'iana')

    def msToIana(self):
        kid = self.__firstChildText
        for elt in self.__eachEltInGroup(self.root, 'windowsZone', 'msZoneIana'):
            yield kid(elt, 'msid'), kid(elt, 'iana')

    def msLandIanas(self):
        kid = self.__firstChildText
        for elt in self.__eachEltInGroup(self.root, 'windowsZone', 'msLandZones'):
            yield kid(elt, 'msid'), kid(elt, 'territorycode'), kid(elt, 'ianaids')

    def languageIndices(self, locales):
        index = 0
        for key, value in self.languages.items():
            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)

        def keyLikely(pair, kl=self.__keyLikely):
            """Sort by IDs from first entry in pair

            We're passed a pair (h, g) of triplets (lang, script, territory) of
            pairs (ID, name); we extract the ID from each entry in the first
            triplet, then hand that triplet of IDs off to __keyLikely()."""
            return kl(tuple(x[0] for x in pair[0]))

        # Sort self.__likely to enable binary search in C++ code.
        for have, give in sorted(((self.__fromNames(has),
                                   self.__fromNames(got))
                                  for has, got in self.__likely),
                                 key = keyLikely):
            yield ('_'.join(tag(have)), ids(have),
                   '_'.join(tag(give)), ids(give))

    def defaultMap(self):
        """Map language and script to their default territory by ID.

        Yields ((language, script), territory) wherever the likely
        sub-tags mapping says language's default locale uses the given
        script and territory."""
        for have, give in self.__likely:
            if have[1:] == ('AnyScript', 'AnyTerritory') and give[2] != 'AnyTerritory':
                assert have[0] == give[0], (have, give)
                yield ((self.__langByName[give[0]][0],
                        self.__textByName[give[1]][0]),
                       self.__landByName[give[2]][0])

    def enumify(self, name, suffix):
        """Stick together the parts of an enumdata.py name.

        Names given in enumdata.py include spaces and hyphens that we
        can't include in an identifier, such as the name of a member
        of an enum type. Removing those would lose the word
        boundaries, so make sure each word starts with a capital (but
        don't simply capitalize() as some names contain words,
        e.g. McDonald, that have later capitals in them).

        We also need to resolve duplication between languages and
        territories (by adding a suffix to each) and add Script to the
        ends of script-names that don't already end in it."""
        name = name.replace('-', ' ')
        # Don't .capitalize() as McDonald is already camel-case (see enumdata.py):
        name = ''.join(word[0].upper() + word[1:] for word in name.split())
        if suffix != 'Script':
            assert not(name in self.__dupes and name.endswith(suffix))
            return name + suffix if name in self.__dupes else name

        if not name.endswith(suffix):
            name += suffix
        if name in self.__dupes:
            raise Error(f'The script name "{name}" is messy')
        return name

    # Implementation details:
    def __loadMap(self, category, enum):
        """Load the language-, script- or territory-map.

        First parameter, category, names the map to load, second is the
        enumdata.py map that corresponds to it.  Yields 4-tuples (id, enum,
        code, name) where id and enum are the enumdata numeric index and name
        (on which the QLocale enums are based), code is the ISO code and name
        is CLDR's en.xml name for the language, script or territory."""
        kid = self.__firstChildText
        for element in self.__eachEltInGroup(self.root, f'{category}List', 'naming'):
            name, key, code = self.__textThenAttrs(element, 'id', 'code')
            key = int(key)
            yield key, enum[key][0], code, name

    def __fromNames(self, names):
        # Three (ID, code) pairs:
        return self.__langByName[names[0]], self.__textByName[names[1]], self.__landByName[names[2]]

    # Likely subtag management:
    def __likelySubtagsMap(self):
        def triplet(element, keys=('language', 'script', 'territory'), 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"))

    @staticmethod
    def __keyLikely(key, huge=0x10000):
        """Sort order key for a likely subtag key

        Although the entries are (lang, script, region), sort by (lang, region,
        script) and sort 0 after all non-zero values, in each position. This
        ensures that, when several mappings partially match a requested locale,
        the one we should prefer to use appears first.

        We use 0x10000 as replacement for 0, as all IDs are unsigned short, so
        less than 2^16."""
        # Map zero to huge:
        have = tuple(x or huge for x in key)
        # Use language, territory, script for sort order:
        return have[0], have[2], have[1]

    # 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:
                # Note: do not strip(), as some group separators are
                # non-breaking spaces, that strip() will discard.
                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(f'No {name} child found')

    @classmethod
    def __firstChildText(cls, elt, key):
        return ' '.join(cls.__eltWords(cls.__firstChildElt(elt, key)))

    @classmethod
    def __textThenAttrs(cls, elt, *names):
        """Read an elements text than a sequence of its attributes.

        First parameter is the XML element, subsequent parameters name
        attributes of it. Yields the text of the element, followed by the text
        of each of the attributes in turn."""
        yield ' '.join(cls.__eltWords(elt))
        for name in names:
            yield elt.attributes[name].nodeValue

    @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 line[1:2] not in '!?':
            cut = line.find('>')
            tag = (line[1:] if cut < 0 else line[1 : cut]).strip().split()[0]
            if f'</{tag}>' not in line:
                self.current += self.__each
        return indent + line + '\n'

    def __call__(self, line):
        return self.__call(line)

class QLocaleXmlWriter (object):
    """Save the full set of locale data to a QLocaleXML file.

    The output saved by this should conform to qlocalexml.rnc's
    schema."""
    def __init__(self, cldrVersion, save = None, space = Spacer('\t')):
        """Set up to write digested CLDR data as QLocale XML.

        First argument is the version of CLDR whose data we'll be
        writing. Other arguments are optional.

        Second 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.

        Third 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('\t'), which grows indent by a tab 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('<?xml version="1.0" encoding="UTF-8" ?>'
                     # A hint to emacs to make display nicer:
                     '<!--*- tab-width: 4 -*-->')
        self.__openTag('localeDatabase', versionCldr = cldrVersion,
                       versionQt = qtVersion)

    # Output of various sections, in their usual order:
    def enumData(self, code2name):
        """Output name/id/code tables for language, script and territory.

        Parameter, code2name, is a function taking 'language',
        'script' or 'territory' and returning a lookup function that
        maps codes, of the relevant type, to their English names. This
        lookup function is passed a code and the name, both taken from
        enumdata.py, that QLocale uses, so the .get() of a dict will
        work. The English name from this lookup will be used by
        QLocale::*ToString() for the enum member whose name is based
        on the enumdata.py name passed as fallback to the lookup."""
        from enumdata import language_map, script_map, territory_map
        self.__enumTable('language', language_map, code2name)
        self.__enumTable('script', script_map, code2name)
        self.__enumTable('territory', territory_map, code2name)
        # Prepare to detect any unused codes (see __writeLocale(), close()):
        self.__languages = set(p[1] for p in language_map.values()
                               if not p[1].isspace())
        self.__scripts = set(p[1] for p in script_map.values()
                             if p[1] != 'Zzzz')
        self.__territories = set(p[1] for p in territory_map.values()
                                 if p[1] != 'ZZ')

    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 zoneData(self, alias, defaults, windowsIds):
        self.__openTag('zoneAliases')
        # iana is a single IANA ID
        # name has the same form, but has been made redundant
        for name, iana in sorted(alias.items()):
            if name == iana:
                continue
            self.__openTag('zoneAlias')
            self.inTag('alias', name)
            self.inTag('iana', iana)
            self.__closeTag('zoneAlias')
        self.__closeTag('zoneAliases')

        self.__openTag('windowsZone')
        for (msid, code), ids in windowsIds.items():
            # ianaids is a space-joined sequence of IANA IDs
            self.__openTag('msLandZones')
            self.inTag('msid', msid)
            self.inTag('territorycode', code)
            self.inTag('ianaids', ids)
            self.__closeTag('msLandZones')

        for winid, iana in defaults.items():
            self.__openTag('msZoneIana')
            self.inTag('msid', winid)
            self.inTag('iana', iana)
            self.__closeTag('msZoneIana')
        self.__closeTag('windowsZone')

    def locales(self, locales, calendars, en_US):
        """Write the data for each locale.

        First argument, locales, is the mapping whose values are the
        Locale objects, with each key being the matching tuple of
        numeric IDs for language, script, territory and variant.
        Second argument is a tuple of calendar names. Third is the
        tuple of numeric IDs that corresponds to en_US (needed to
        provide fallbacks for the C locale)."""

        self.__openTag('localeList')
        self.__openTag('locale')
        self.__writeLocale(Locale.C(locales[en_US]), calendars)
        self.__closeTag('locale')
        for key in sorted(locales.keys()):
            self.__openTag('locale')
            self.__writeLocale(locales[key], calendars)
            self.__closeTag('locale')
        self.__closeTag('localeList')

    def inTag(self, tag, text, **attrs):
        """Writes an XML element with the given content.

        First parameter, tag, is the element type; second, text, is the content
        of its body. Any keyword parameters passed specify attributes to
        include in the opening tag."""
        if attrs:
            head = ' '.join(f'{k}="{v}"' for k, v in attrs.items())
            head = f'{tag} {head}'
        else:
            head = tag
        self.__write(f'<{head}>{text}</{tag}>')

    def close(self, grumble):
        """Finish writing and grumble about any issues discovered."""
        if self.__rawOutput != self.__complain:
            self.__closeTag('localeDatabase')
        self.__rawOutput = self.__complain

        if self.__languages or self.__scripts or self.__territories:
            grumble('Some enum members are unused, corresponding to these tags:\n')
            import textwrap
            def kvetch(kind, seq, g = grumble, w = textwrap.wrap):
                g('\n\t'.join(w(f' {kind}: {", ".join(sorted(seq))}', width=80)) + '\n')
            if self.__languages:
                kvetch('Languages', self.__languages)
            if self.__scripts:
                kvetch('Scripts', self.__scripts)
            if self.__territories:
                kvetch('Territories', self.__territories)
            grumble('It may make sense to deprecate them.\n')

    # Implementation details
    @staticmethod
    def __printit(text):
        print(text, end='')
    @staticmethod
    def __complain(text):
        raise Error('Attempted to write data after closing :-(')

    @staticmethod
    def __xmlSafe(text):
        return text.replace('&', '&amp;').replace('<', '&lt;').replace('>', '&gt;')

    def __enumTable(self, tag, table, code2name):
        """Writes a table of QLocale-enum-related data.

        First parameter, tag, is 'language', 'script' or 'territory',
        identifying the relevant table. Second, table, is the enumdata.py
        mapping from numeric enum value to (enum name, ISO code) pairs for that
        type. Last is the englishNaming method of the CldrAccess being used to
        read CLDR data; it is used to map ISO codes to en.xml names."""
        self.__openTag(f'{tag}List')
        enname, safe = code2name(tag), self.__xmlSafe
        for key, (name, code) in table.items():
            self.inTag('naming', safe(enname(code, name)), id = key, code = code)
        self.__closeTag(f'{tag}List')

    def __likelySubTag(self, tag, likely):
        self.__openTag(tag)
        self.inTag('language', likely[0])
        self.inTag('script', likely[1])
        self.inTag('territory', likely[2])
        # self.inTag('variant', likely[3])
        self.__closeTag(tag)

    def __writeLocale(self, locale, calendars):
        locale.toXml(self.inTag, calendars)
        self.__languages.discard(locale.language_code)
        self.__scripts.discard(locale.script_code)
        self.__territories.discard(locale.territory_code)

    def __openTag(self, tag, **attrs):
        if attrs:
            text = ' '.join(f'{k}="{v}"' for k, v in attrs.items())
            tag = f'{tag} {text}'
        self.__write(f'<{tag}>')
    def __closeTag(self, tag):
        self.__write(f'</{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 = ("currencyDigits", "currencyRounding")
    # Convert day-name to Qt day-of-week number:
    __asdow = ("firstDayOfWeek", "weekendStart", "weekendEnd")
    # Just use the raw text:
    __astxt = ("language", "languageEndonym", "script", "territory", "territoryEndonym",
               "decimal", "group", "zero",
               "list", "percent", "minus", "plus", "exp",
               "quotationStart", "quotationEnd",
               "alternateQuotationStart", "alternateQuotationEnd",
               "listPatternPartStart", "listPatternPartMiddle",
               "listPatternPartEnd", "listPatternPartTwo", "am", "pm",
               "longDateFormat", "shortDateFormat",
               "longTimeFormat", "shortTimeFormat",
               '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.

        First parameter, lookup, is called with the names of XML elements that
        should contain the relevant data, within a QLocaleXML locale element
        (within a localeList element); these names mostly match the attributes
        of the object constructed. Its return must be the full text of the
        first child DOM node element with the given name. Attribute values are
        obtained by suitably digesting the returned element texts.

        Optional second parameter, calendars, is a sequence of calendars for
        which data is to be retrieved."""
        data = {}
        for k in cls.__asint:
            data[k] = int(lookup(k))

        for k in cls.__asdow:
            data[k] = cls.__qDoW[lookup(k)]

        for k in cls.__astxt + tuple(cls.propsMonthDay('days')):
            data['listDelim' if k == 'list' else k] = lookup(k)

        for k in cls.propsMonthDay('months'):
            data[k] = {cal: lookup('_'.join((k, cal))) for cal in calendars}

        grouping = lookup('groupSizes').split(';')
        data.update(groupLeast = int(grouping[0]),
                    groupHigher = int(grouping[1]),
                    groupTop = int(grouping[2]))

        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', 'territory'):
            write(key, get(key))
            write(f'{key}code', get(f'{key}_code'))

        for key in ('decimal', 'group', 'zero', 'list',
                    'percent', 'minus', 'plus', 'exp'):
            write(key, get(key))

        for key in ('languageEndonym', 'territoryEndonym',
                    '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)))

        write('groupSizes', ';'.join(str(x) for x in get('groupSizes')))
        for key in ('currencyDigits', 'currencyRounding'):
            write(key, get(key))

    @classmethod
    def C(cls, en_US):
        """Returns an object representing the C locale.

        Required argument, en_US, is the corresponding object for the
        en_US locale (or the en_US_POSIX one if we ever support
        variants). The C locale inherits from this, overriding what it
        may need to."""
        base = en_US.__dict__.copy()
        # Soroush's original contribution shortened Jalali month names
        # - contrary to CLDR, which doesn't abbreviate these in
        # root.xml or en.xml, although some locales do, e.g. fr_CA.
        # For compatibility with that,
        for k in ('shortMonths_persian', 'standaloneShortMonths_persian'):
            base[k] = ';'.join(x[:3] for x in base[k].split(';'))

        return cls(base,
                   language='C', language_code='',
                   language_id=0, languageEndonym='',
                   script='AnyScript', script_code='', script_id=0,
                   territory='AnyTerritory', territory_code='',
                   territory_id=0, territoryEndonym='',
                   variant='', variant_code='', variant_id=0,
                   # CLDR has non-ASCII versions of these:
                   quotationStart='"', quotationEnd='"',
                   alternateQuotationStart="'", alternateQuotationEnd="'",
                   # CLDR gives 'dddd, MMMM d, yyyy', 'M/d/yy', 'h:mm:ss Ap tttt',
                   # 'h:mm Ap' with non-breaking space before Ap.
                   longDateFormat='dddd, d MMMM yyyy', shortDateFormat='d MMM yyyy',
                   longTimeFormat='HH:mm:ss t', shortTimeFormat='HH:mm:ss',
                   # CLDR has US-$ and US-style formats:
                   currencyIsoCode='', currencySymbol='', currencyDisplayName='',
                   currencyDigits=2, currencyRounding=1,
                   currencyFormat='%1%2', currencyNegativeFormat='',
                   # We may want to fall back to CLDR for some of these:
                   firstDayOfWeek='mon', # CLDR has 'sun'
                   exp='e', # CLDR has 'E'
                   listPatternPartEnd='%1, %2', # CLDR has '%1, and %2'
                   listPatternPartTwo='%1, %2', # CLDR has '%1 and %2'
                   narrowDays='7;1;2;3;4;5;6', # CLDR has letters
                   narrowMonths_gregorian='1;2;3;4;5;6;7;8;9;10;11;12', # CLDR has letters
                   standaloneNarrowMonths_persian='F;O;K;T;M;S;M;A;A;D;B;E', # CLDR has digits
                   # Keep these explicit, despite matching CLDR:
                   decimal='.', group=',', percent='%',
                   zero='0', minus='-', plus='+',
                   am='AM', pm='PM', weekendStart='sat', weekendEnd='sun')